Skip to content

Commit 0926e23

Browse files
LilyFooteLilyFoote
committed
Remove content from Argument and FilterToken
1 parent 3e6e023 commit 0926e23

File tree

2 files changed

+28
-66
lines changed

2 files changed

+28
-66
lines changed

‎src/lex.rs

+23-61
Original file line numberDiff line numberDiff line change
@@ -236,13 +236,12 @@ pub enum ArgumentType {
236236
}
237237

238238
#[derive(Debug, PartialEq, Eq)]
239-
pub struct Argument<'t> {
239+
pub struct Argument {
240240
pub argument_type: ArgumentType,
241-
pub content: &'t str,
242241
pub at: (usize, usize),
243242
}
244243

245-
impl<'a, 't> Argument<'a> {
244+
impl<'t> Argument {
246245
pub fn content(&self, template: &'t str) -> &'t str {
247246
let (start, len) = self.at;
248247
let end = start + len;
@@ -264,13 +263,12 @@ impl<'a, 't> Argument<'a> {
264263
}
265264

266265
#[derive(Debug, PartialEq, Eq)]
267-
pub struct FilterToken<'t> {
268-
pub content: &'t str,
266+
pub struct FilterToken {
269267
pub at: (usize, usize),
270-
pub argument: Option<Argument<'t>>,
268+
pub argument: Option<Argument>,
271269
}
272270

273-
impl<'a, 't> FilterToken<'a> {
271+
impl<'t> FilterToken {
274272
pub fn content(&self, template: &'t str) -> &'t str {
275273
let (start, len) = self.at;
276274
&template[start..start + len]
@@ -402,7 +400,7 @@ impl<'t> FilterLexer<'t> {
402400
&mut self,
403401
chars: &mut std::str::Chars,
404402
end: char,
405-
) -> Result<Argument<'t>, VariableLexerError> {
403+
) -> Result<Argument, VariableLexerError> {
406404
let mut count = 1;
407405
loop {
408406
let next = match chars.next() {
@@ -419,12 +417,10 @@ impl<'t> FilterLexer<'t> {
419417
chars.next();
420418
} else if next == end {
421419
let at = (self.byte, count);
422-
let content = &self.rest[1..count - 1];
423420
self.rest = &self.rest[count..];
424421
self.byte += count;
425422
return Ok(Argument {
426423
argument_type: ArgumentType::Text,
427-
content,
428424
at,
429425
});
430426
}
@@ -434,11 +430,11 @@ impl<'t> FilterLexer<'t> {
434430
fn lex_translated(
435431
&mut self,
436432
chars: &mut std::str::Chars,
437-
) -> Result<Argument<'t>, VariableLexerError> {
433+
) -> Result<Argument, VariableLexerError> {
438434
let start = self.byte;
439435
self.byte += START_TRANSLATE_LEN;
440436
self.rest = &self.rest[START_TRANSLATE_LEN..];
441-
let token = match chars.next() {
437+
match chars.next() {
442438
None => {
443439
let at = (start, START_TRANSLATE_LEN);
444440
self.rest = "";
@@ -458,7 +454,6 @@ impl<'t> FilterLexer<'t> {
458454
self.rest = &self.rest[END_TRANSLATE_LEN..];
459455
Ok(Argument {
460456
argument_type: ArgumentType::TranslatedText,
461-
content: token.content,
462457
at: (start, self.byte - start),
463458
})
464459
}
@@ -470,28 +465,27 @@ impl<'t> FilterLexer<'t> {
470465
}
471466
}
472467

473-
fn lex_numeric(&mut self) -> Argument<'t> {
468+
fn lex_numeric(&mut self) -> Argument {
474469
let end = self
475470
.rest
476471
.find(|c: char| !(c.is_ascii_digit() || c == '-' || c == '.' || c == 'e'))
477472
.unwrap_or(self.rest.len());
478473
let content = &self.rest[..end];
479474
// Match django bug
480-
let (content, end) = match content[1..].find('-') {
481-
Some(n) => (&content[..n + 1], n + 1),
482-
None => (content, end),
475+
let end = match content[1..].find('-') {
476+
Some(n) => n + 1,
477+
None => end,
483478
};
484479
// End match django bug
485480
self.rest = &self.rest[end..];
486481
let at = (self.byte, end);
487482
self.byte += end;
488483
Argument {
489484
argument_type: ArgumentType::Numeric,
490-
content,
491485
at,
492486
}
493487
}
494-
fn lex_variable_argument(&mut self) -> Result<Argument<'t>, VariableLexerError> {
488+
fn lex_variable_argument(&mut self) -> Result<Argument, VariableLexerError> {
495489
let content = trim_variable(self.rest);
496490
match check_variable_attrs(content, self.byte) {
497491
Ok(()) => {}
@@ -506,12 +500,11 @@ impl<'t> FilterLexer<'t> {
506500
self.rest = &self.rest[end..];
507501
Ok(Argument {
508502
argument_type: ArgumentType::Variable,
509-
content,
510503
at,
511504
})
512505
}
513506

514-
fn lex_filter(&mut self) -> Result<FilterToken<'t>, VariableLexerError> {
507+
fn lex_filter(&mut self) -> Result<FilterToken, VariableLexerError> {
515508
let filter = self.rest.trim_start();
516509
let start = self.rest.len() - filter.len();
517510
self.byte += start;
@@ -528,11 +521,7 @@ impl<'t> FilterLexer<'t> {
528521
self.byte += end;
529522
self.rest = &self.rest[end..];
530523
let argument = self.lex_argument()?;
531-
Ok(FilterToken {
532-
content: filter,
533-
at,
534-
argument,
535-
})
524+
Ok(FilterToken { at, argument })
536525
}
537526
_ => {
538527
let next = self.rest.find("|").unwrap_or(self.rest.len());
@@ -543,7 +532,7 @@ impl<'t> FilterLexer<'t> {
543532
}
544533
}
545534

546-
fn lex_argument(&mut self) -> Result<Option<Argument<'t>>, VariableLexerError> {
535+
fn lex_argument(&mut self) -> Result<Option<Argument>, VariableLexerError> {
547536
let next = match (self.rest.find("|"), self.rest.find(":")) {
548537
(_, None) => return Ok(None),
549538
(Some(f), Some(a)) if f < a => return Ok(None),
@@ -577,10 +566,10 @@ impl<'t> FilterLexer<'t> {
577566

578567
fn lex_remainder(
579568
&mut self,
580-
token: FilterToken<'t>,
569+
token: FilterToken,
581570
remainder: &'t str,
582571
start_next: usize,
583-
) -> Result<FilterToken<'t>, VariableLexerError> {
572+
) -> Result<FilterToken, VariableLexerError> {
584573
match remainder.find(|c: char| !c.is_whitespace()) {
585574
None => {
586575
self.rest = &self.rest[start_next..];
@@ -606,7 +595,7 @@ impl<'t> FilterLexer<'t> {
606595
}
607596

608597
impl<'t> Iterator for FilterLexer<'t> {
609-
type Item = Result<FilterToken<'t>, VariableLexerError>;
598+
type Item = Result<FilterToken, VariableLexerError>;
610599

611600
fn next(&mut self) -> Option<Self::Item> {
612601
if self.rest.is_empty() {
@@ -890,10 +879,10 @@ mod lexer_tests {
890879
mod variable_lexer_tests {
891880
use super::*;
892881

893-
fn contents<'t>(
894-
template: &'t str,
895-
tokens: Vec<Result<FilterToken<'_>, VariableLexerError>>,
896-
) -> Vec<(&'t str, Option<&'t str>)> {
882+
fn contents(
883+
template: &str,
884+
tokens: Vec<Result<FilterToken, VariableLexerError>>,
885+
) -> Vec<(&str, Option<&str>)> {
897886
tokens
898887
.iter()
899888
.map(|t| match t {
@@ -956,7 +945,6 @@ mod variable_lexer_tests {
956945
assert_eq!(
957946
tokens,
958947
vec![Ok(FilterToken {
959-
content: "title",
960948
at: (11, 5),
961949
argument: None,
962950
})]
@@ -975,12 +963,10 @@ mod variable_lexer_tests {
975963
vec![
976964
Ok(FilterToken {
977965
argument: None,
978-
content: "title",
979966
at: (11, 5),
980967
}),
981968
Ok(FilterToken {
982969
argument: None,
983-
content: "length",
984970
at: (17, 6),
985971
}),
986972
]
@@ -1030,10 +1016,8 @@ mod variable_lexer_tests {
10301016
vec![Ok(FilterToken {
10311017
argument: Some(Argument {
10321018
argument_type: ArgumentType::Text,
1033-
content: "foo",
10341019
at: (19, 5),
10351020
}),
1036-
content: "default",
10371021
at: (11, 7),
10381022
})]
10391023
);
@@ -1051,10 +1035,8 @@ mod variable_lexer_tests {
10511035
vec![Ok(FilterToken {
10521036
argument: Some(Argument {
10531037
argument_type: ArgumentType::Text,
1054-
content: "foo",
10551038
at: (19, 5),
10561039
}),
1057-
content: "default",
10581040
at: (11, 7),
10591041
})]
10601042
);
@@ -1072,10 +1054,8 @@ mod variable_lexer_tests {
10721054
vec![Ok(FilterToken {
10731055
argument: Some(Argument {
10741056
argument_type: ArgumentType::Text,
1075-
content: "foo\\\'",
10761057
at: (19, 7),
10771058
}),
1078-
content: "default",
10791059
at: (11, 7),
10801060
})]
10811061
);
@@ -1096,10 +1076,8 @@ mod variable_lexer_tests {
10961076
vec![Ok(FilterToken {
10971077
argument: Some(Argument {
10981078
argument_type: ArgumentType::TranslatedText,
1099-
content: "foo",
11001079
at: (19, 8),
11011080
}),
1102-
content: "default",
11031081
at: (11, 7),
11041082
})]
11051083
);
@@ -1117,10 +1095,8 @@ mod variable_lexer_tests {
11171095
vec![Ok(FilterToken {
11181096
argument: Some(Argument {
11191097
argument_type: ArgumentType::TranslatedText,
1120-
content: "foo",
11211098
at: (19, 8),
11221099
}),
1123-
content: "default",
11241100
at: (11, 7),
11251101
})]
11261102
);
@@ -1138,10 +1114,8 @@ mod variable_lexer_tests {
11381114
vec![Ok(FilterToken {
11391115
argument: Some(Argument {
11401116
argument_type: ArgumentType::Numeric,
1141-
content: "500",
11421117
at: (19, 3),
11431118
}),
1144-
content: "default",
11451119
at: (11, 7),
11461120
})]
11471121
);
@@ -1159,10 +1133,8 @@ mod variable_lexer_tests {
11591133
vec![Ok(FilterToken {
11601134
argument: Some(Argument {
11611135
argument_type: ArgumentType::Numeric,
1162-
content: "-0.5",
11631136
at: (19, 4),
11641137
}),
1165-
content: "default",
11661138
at: (11, 7),
11671139
})]
11681140
);
@@ -1180,10 +1152,8 @@ mod variable_lexer_tests {
11801152
vec![Ok(FilterToken {
11811153
argument: Some(Argument {
11821154
argument_type: ArgumentType::Numeric,
1183-
content: "5.2e3",
11841155
at: (19, 5),
11851156
}),
1186-
content: "default",
11871157
at: (11, 7),
11881158
})]
11891159
);
@@ -1227,10 +1197,8 @@ mod variable_lexer_tests {
12271197
vec![Ok(FilterToken {
12281198
argument: Some(Argument {
12291199
argument_type: ArgumentType::Variable,
1230-
content: "spam",
12311200
at: (19, 4),
12321201
}),
1233-
content: "default",
12341202
at: (11, 7),
12351203
})]
12361204
);
@@ -1249,15 +1217,12 @@ mod variable_lexer_tests {
12491217
Ok(FilterToken {
12501218
argument: Some(Argument {
12511219
argument_type: ArgumentType::Variable,
1252-
content: "spam",
12531220
at: (19, 4),
12541221
}),
1255-
content: "default",
12561222
at: (11, 7),
12571223
}),
12581224
Ok(FilterToken {
12591225
argument: None,
1260-
content: "title",
12611226
at: (24, 5),
12621227
}),
12631228
]
@@ -1280,15 +1245,12 @@ mod variable_lexer_tests {
12801245
Ok(FilterToken {
12811246
argument: Some(Argument {
12821247
argument_type: ArgumentType::Text,
1283-
content: "spam",
12841248
at: (19, 6),
12851249
}),
1286-
content: "default",
12871250
at: (11, 7),
12881251
}),
12891252
Ok(FilterToken {
12901253
argument: None,
1291-
content: "title",
12921254
at: (26, 5),
12931255
}),
12941256
]

‎src/parse.rs

+5-5
Original file line numberDiff line numberDiff line change
@@ -112,9 +112,9 @@ impl<'t> Parser<'t> {
112112
let filter_token = filter_token?;
113113
let argument = match filter_token.argument {
114114
None => None,
115-
Some(a) => Some(a.parse(self.template)?),
115+
Some(ref a) => Some(a.parse(self.template)?),
116116
};
117-
let filter = Filter::new(filter_token.content, var, argument);
117+
let filter = Filter::new(filter_token.content(self.template), var, argument);
118118
var = TokenTree::Filter(Box::new(filter));
119119
}
120120
Ok(var)
@@ -125,14 +125,14 @@ impl<'t> Parser<'t> {
125125
}
126126
}
127127

128-
impl<'t> Argument<'t> {
129-
fn parse(self, template: &'t str) -> Result<TokenTree<'t>, ParseError> {
128+
impl<'t> Argument {
129+
fn parse(&self, template: &'t str) -> Result<TokenTree<'t>, ParseError> {
130130
Ok(match self.argument_type {
131131
ArgumentType::Variable => {
132132
TokenTree::Variable(Variable::new(self.content(template), self.at))
133133
}
134134
ArgumentType::Text => TokenTree::Text(self.content(template)),
135-
ArgumentType::Numeric => match self.content.parse::<BigInt>() {
135+
ArgumentType::Numeric => match self.content(template).parse::<BigInt>() {
136136
Ok(n) => TokenTree::Int(n),
137137
Err(_) => match self.content(template).parse::<f64>() {
138138
Ok(f) => TokenTree::Float(f),

0 commit comments

Comments
 (0)