self.incr_letters();
}
+ #[allow(clippy::inherent_to_string)]
pub(crate) fn to_string(&self) -> String {
if let Some(ref lower) = self.lower {
- format!("{}{}{}",
- match self.prepend {
- Some(ref p) => p,
- None => "",
- },
- self.letter,
- lower.to_string())
+ format!(
+ "{}{}{}",
+ self.prepend.unwrap_or(""),
+ self.letter,
+ lower.to_string()
+ )
} else {
- format!("{}{}",
- match self.prepend {
- Some(ref p) => p,
- None => "",
- },
- self.letter)
+ format!("{}{}", self.prepend.unwrap_or(""), self.letter)
}
}
Some(ref s) => s.len(),
None => 0,
} + 1;
- first + match self.lower {
- Some(ref s) => s.len(),
- None => 0,
- }
+ first
+ + match self.lower {
+ Some(ref s) => s.len(),
+ None => 0,
+ }
}
pub(crate) fn incr_letters(&mut self) {
}
let mut tmp = pos;
match tokens[pos] {
- Token::Keyword(Keyword::Let) |
- Token::Keyword(Keyword::Var) => {
+ Token::Keyword(Keyword::Let) | Token::Keyword(Keyword::Var) => {
tmp += 1;
}
Token::Other(_) if pos > 0 => {
while pos > 0 {
if tokens[pos].is_comment() || tokens[pos].is_white_character() {
pos -= 1;
- } else if tokens[pos] == Token::Char(ReservedChar::Comma) ||
- tokens[pos] == Token::Keyword(Keyword::Let) ||
- tokens[pos] == Token::Keyword(Keyword::Var) {
+ } else if tokens[pos] == Token::Char(ReservedChar::Comma)
+ || tokens[pos] == Token::Keyword(Keyword::Let)
+ || tokens[pos] == Token::Keyword(Keyword::Var)
+ {
break;
} else {
return None;
while tmp < tokens.len() {
if tokens[tmp].is_other() {
let mut tmp2 = tmp + 1;
- 'big: while tmp2 < tokens.len() {
+ while tmp2 < tokens.len() {
if tokens[tmp2] == Token::Operation(Operation::Equal) {
tmp2 += 1;
while tmp2 < tokens.len() {
let token = &tokens[tmp2];
- if token.is_string() || token.is_other() || token.is_regex() ||
- token.is_number() || token.is_floating_number() {
+ if token.is_string()
+ || token.is_other()
+ || token.is_regex()
+ || token.is_number()
+ || token.is_floating_number()
+ {
return Some((tmp, Some(tmp2)));
- } else if !tokens[tmp2].is_comment() &&
- !tokens[tmp2].is_white_character() {
+ } else if !tokens[tmp2].is_comment() && !tokens[tmp2].is_white_character() {
break;
}
tmp2 += 1;
}
break;
- } else if match tokens[tmp2].get_char() {
- Some(ReservedChar::Comma) | Some(ReservedChar::SemiColon) => true,
- _ => false,
- } {
+ } else if matches!(
+ tokens[tmp2].get_char(),
+ Some(ReservedChar::Comma) | Some(ReservedChar::SemiColon)
+ ) {
return Some((tmp, None));
- } else if !tokens[tmp2].is_comment() &&
- !(tokens[tmp2].is_white_character() &&
- tokens[tmp2].get_char() != Some(ReservedChar::Backline)) {
+ } else if !(tokens[tmp2].is_comment()
+ || tokens[tmp2].is_white_character()
+ && tokens[tmp2].get_char() != Some(ReservedChar::Backline))
+ {
break;
}
tmp2 += 1;
#[inline]
fn get_next<'a>(it: &mut IntoIter<Token<'a>>) -> Option<Token<'a>> {
- while let Some(t) = it.next() {
+ for t in it {
if t.is_comment() || t.is_white_character() {
- continue
+ continue;
}
return Some(t);
}
/// }
/// ```
#[inline]
-pub fn clean_tokens<'a>(tokens: Tokens<'a>) -> Tokens<'a> {
+pub fn clean_tokens(tokens: Tokens<'_>) -> Tokens<'_> {
let mut v = Vec::with_capacity(tokens.len() / 3 * 2);
let mut it = tokens.0.into_iter();
}
let token = token.unwrap();
if token.is_white_character() {
- continue
+ continue;
} else if token.get_char() == Some(ReservedChar::SemiColon) {
if v.is_empty() {
- continue
+ continue;
}
if let Some(next) = get_next(&mut it) {
if next != Token::Char(ReservedChar::CloseCurlyBrace) {
}
v.push(next);
}
- continue
+ continue;
}
v.push(token);
}
pub fn clean_token(token: &Token<'_>, next_token: &Option<&Token<'_>>) -> bool {
!token.is_comment() && {
if let Some(x) = token.get_char() {
- !x.is_white_character() &&
- (x != ReservedChar::SemiColon ||
- *next_token != Some(&Token::Char(ReservedChar::CloseCurlyBrace)))
+ !x.is_white_character()
+ && (x != ReservedChar::SemiColon
+ || *next_token != Some(&Token::Char(ReservedChar::CloseCurlyBrace)))
} else {
true
}
it: &mut IntoIter<Token<'a>>,
f: &F,
) -> Option<Token<'a>> {
- while let Some(t) = it.next() {
+ for t in it {
if (t.is_comment() || t.is_white_character()) && f(&t) {
- continue
+ continue;
}
return Some(t);
}
/// }
/// ```
#[inline]
-pub fn clean_tokens_except<'a, F: Fn(&Token<'a>) -> bool>(
- tokens: Tokens<'a>,
- f: F,
-) -> Tokens<'a> {
+pub fn clean_tokens_except<'a, F: Fn(&Token<'a>) -> bool>(tokens: Tokens<'a>, f: F) -> Tokens<'a> {
let mut v = Vec::with_capacity(tokens.len() / 3 * 2);
let mut it = tokens.0.into_iter();
let token = token.unwrap();
if token.is_white_character() {
if f(&token) {
- continue
+ continue;
}
} else if token.get_char() == Some(ReservedChar::SemiColon) {
if v.is_empty() {
if !f(&token) {
v.push(token);
}
- continue
+ continue;
}
if let Some(next) = get_next_except(&mut it, &f) {
if next != Token::Char(ReservedChar::CloseCurlyBrace) || !f(&token) {
} else if !f(&token) {
v.push(token);
}
- continue
+ continue;
}
v.push(token);
}
}
} else {
match tokens[pos] {
- Token::Keyword(Keyword::Let) |
- Token::Keyword(Keyword::Var) => {
+ Token::Keyword(Keyword::Let) | Token::Keyword(Keyword::Var) => {
looking_for_var = true;
}
_ => {}
let expected_result = "var x=['a','b',N,'d',{'x':N,'e':N,'z':'w'}];var n=N;";
let res: Tokens = ::js::simple_minify(source)
- .into_iter()
- .filter(|(x, next)| ::js::clean_token(x, next))
- .map(|(t, _)| {
- if t == Token::Keyword(Keyword::Null) {
- Token::Other("N")
- } else {
- t
- }
- })
- .collect::<Vec<_>>()
- .into();
+ .into_iter()
+ .filter(|(x, next)| ::js::clean_token(x, next))
+ .map(|(t, _)| {
+ if t == Token::Keyword(Keyword::Null) {
+ Token::Other("N")
+ } else {
+ t
+ }
+ })
+ .collect::<Vec<_>>()
+ .into();
assert_eq!(res.to_string(), expected_result);
}