clean up after review

TheAnyKey · TheAnyKey · commit 71ec5c1b8603 · 2020-05-05T05:01:16.000-04:00
diff --git a/parser/src/fstring.rs b/parser/src/fstring.rs
@@ -34,26 +34,22 @@ impl<'a> FStringParser<'a> {
                 // can be integrated better with the remainign code, but as a starting point ok
                 // in general I would do here a tokenizing of the fstrings to omit this peeking.
                 '!' if self.chars.peek() == Some(&'=') => {
-                    expression.push('!');
-                    expression.push('=');
+                    expression.push_str("!=");
                     self.chars.next();
                 }
 
                 '=' if self.chars.peek() == Some(&'=') => {
-                    expression.push('=');
-                    expression.push('=');
+                    expression.push_str("==");
                     self.chars.next();
                 }
 
                 '>' if self.chars.peek() == Some(&'=') => {
-                    expression.push('>');
-                    expression.push('=');
+                    expression.push_str(">=");
                     self.chars.next();
                 }
 
                 '<' if self.chars.peek() == Some(&'=') => {
-                    expression.push('<');
-                    expression.push('=');
+                    expression.push_str("<=");
                     self.chars.next();
                 }
 
@@ -74,8 +70,11 @@ impl<'a> FStringParser<'a> {
                         }
                     });
 
-                    let peek = self.chars.peek();
-                    if peek != Some(&'}') && peek != Some(&':') {
+                    if let Some(&peek) = self.chars.peek() {
+                        if peek != '}' && peek != ':' {
+                            return Err(ExpectedRbrace);
+                        }
+                    } else {
                         return Err(ExpectedRbrace);
                     }
                 }
@@ -197,17 +196,14 @@ impl<'a> FStringParser<'a> {
                         }
                     }
                 }
-
                 ' ' if !pred_expression_text.is_empty() => {
                     trailing_seq.push(ch);
                 }
-
                 _ => {
                     expression.push(ch);
                 }
             }
         }
-
         Err(UnclosedLbrace)
     }
 
@@ -391,7 +387,6 @@ mod tests {
 
         assert_eq!(parse_fstring("{5!a1}"), Err(ExpectedRbrace));
         assert_eq!(parse_fstring("{5!"), Err(ExpectedRbrace));
-
         assert_eq!(parse_fstring("abc{!a 'cat'}"), Err(EmptyExpression));
         assert_eq!(parse_fstring("{!a"), Err(EmptyExpression));
         assert_eq!(parse_fstring("{ !a}"), Err(EmptyExpression));

Original file line number	Diff line number	Diff line change
`@@ -34,26 +34,22 @@ impl<'a> FStringParser<'a> {`
`34`	`34`	`// can be integrated better with the remainign code, but as a starting point ok`
`35`	`35`	`// in general I would do here a tokenizing of the fstrings to omit this peeking.`
`36`	`36`	`'!' if self.chars.peek() == Some(&'=') => {`
`37`		`- expression.push('!');`
`38`		`- expression.push('=');`
	`37`	`+ expression.push_str("!=");`
`39`	`38`	`self.chars.next();`
`40`	`39`	`}`
`41`	`40`
`42`	`41`	`'=' if self.chars.peek() == Some(&'=') => {`
`43`		`- expression.push('=');`
`44`		`- expression.push('=');`
	`42`	`+ expression.push_str("==");`
`45`	`43`	`self.chars.next();`
`46`	`44`	`}`
`47`	`45`
`48`	`46`	`'>' if self.chars.peek() == Some(&'=') => {`
`49`		`- expression.push('>');`
`50`		`- expression.push('=');`
	`47`	`+ expression.push_str(">=");`
`51`	`48`	`self.chars.next();`
`52`	`49`	`}`
`53`	`50`
`54`	`51`	`'<' if self.chars.peek() == Some(&'=') => {`
`55`		`- expression.push('<');`
`56`		`- expression.push('=');`
	`52`	`+ expression.push_str("<=");`
`57`	`53`	`self.chars.next();`
`58`	`54`	`}`
`59`	`55`
`@@ -74,8 +70,11 @@ impl<'a> FStringParser<'a> {`
`74`	`70`	`}`
`75`	`71`	`});`
`76`	`72`
`77`		`- let peek = self.chars.peek();`
`78`		`- if peek != Some(&'}') && peek != Some(&':') {`
	`73`	`+ if let Some(&peek) = self.chars.peek() {`
	`74`	`+ if peek != '}' && peek != ':' {`
	`75`	`+ return Err(ExpectedRbrace);`
	`76`	`+ }`
	`77`	`+ } else {`
`79`	`78`	`return Err(ExpectedRbrace);`
`80`	`79`	`}`
`81`	`80`	`}`
`@@ -197,17 +196,14 @@ impl<'a> FStringParser<'a> {`
`197`	`196`	`}`
`198`	`197`	`}`
`199`	`198`	`}`
`200`		`-`
`201`	`199`	`' ' if !pred_expression_text.is_empty() => {`
`202`	`200`	`trailing_seq.push(ch);`
`203`	`201`	`}`
`204`		`-`
`205`	`202`	`_ => {`
`206`	`203`	`expression.push(ch);`
`207`	`204`	`}`
`208`	`205`	`}`
`209`	`206`	`}`
`210`		`-`
`211`	`207`	`Err(UnclosedLbrace)`
`212`	`208`	`}`
`213`	`209`
`@@ -391,7 +387,6 @@ mod tests {`
`391`	`387`
`392`	`388`	`assert_eq!(parse_fstring("{5!a1}"), Err(ExpectedRbrace));`
`393`	`389`	`assert_eq!(parse_fstring("{5!"), Err(ExpectedRbrace));`
`394`		`-`
`395`	`390`	`assert_eq!(parse_fstring("abc{!a 'cat'}"), Err(EmptyExpression));`
`396`	`391`	`assert_eq!(parse_fstring("{!a"), Err(EmptyExpression));`
`397`	`392`	`assert_eq!(parse_fstring("{ !a}"), Err(EmptyExpression));`