Run cargo fmt on all files

tiaanl · tiaanl · commit c6fc7d4ff3d7 · 2024-03-22T14:51:49.000+01:00
diff --git a/color/lib.rs b/color/lib.rs
@@ -55,10 +55,8 @@ where
     let token = input.next()?;
     match *token {
         Token::Hash(ref value) | Token::IDHash(ref value) => {
-            parse_hash_color(value.as_bytes()).map(|(r, g, b, a)| {
-                P::Output::from_rgba(r, g, b, a)
-            })
-        },
+            parse_hash_color(value.as_bytes()).map(|(r, g, b, a)| P::Output::from_rgba(r, g, b, a))
+        }
         Token::Ident(ref value) => parse_color_keyword(value),
         Token::Function(ref name) => {
             let name = name.clone();
diff --git a/color/tests.rs b/color/tests.rs
@@ -3,7 +3,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use super::*;
-use crate::{ColorParser, PredefinedColorSpace, Color, RgbaLegacy};
+use crate::{Color, ColorParser, PredefinedColorSpace, RgbaLegacy};
 use cssparser::{Parser, ParserInput};
 use serde_json::{self, json, Value};
 
@@ -43,7 +43,6 @@ fn assert_json_eq(results: Value, expected: Value, message: &str) {
     }
 }
 
-
 fn run_raw_json_tests<F: Fn(Value, Value) -> ()>(json_data: &str, run: F) {
     let items = match serde_json::from_str(json_data) {
         Ok(Value::Array(items)) => items,
@@ -92,11 +91,14 @@ fn color3() {
 #[cfg_attr(all(miri, feature = "skip_long_tests"), ignore)]
 #[test]
 fn color3_hsl() {
-    run_color_tests(include_str!("../src/css-parsing-tests/color3_hsl.json"), |c| {
-        c.ok()
-            .map(|v| v.to_css_string().to_json())
-            .unwrap_or(Value::Null)
-    })
+    run_color_tests(
+        include_str!("../src/css-parsing-tests/color3_hsl.json"),
+        |c| {
+            c.ok()
+                .map(|v| v.to_css_string().to_json())
+                .unwrap_or(Value::Null)
+        },
+    )
 }
 
 /// color3_keywords.json is different: R, G and B are in 0..255 rather than 0..1
@@ -115,11 +117,14 @@ fn color3_keywords() {
 #[cfg_attr(all(miri, feature = "skip_long_tests"), ignore)]
 #[test]
 fn color4_hwb() {
-    run_color_tests(include_str!("../src/css-parsing-tests/color4_hwb.json"), |c| {
-        c.ok()
-            .map(|v| v.to_css_string().to_json())
-            .unwrap_or(Value::Null)
-    })
+    run_color_tests(
+        include_str!("../src/css-parsing-tests/color4_hwb.json"),
+        |c| {
+            c.ok()
+                .map(|v| v.to_css_string().to_json())
+                .unwrap_or(Value::Null)
+        },
+    )
 }
 
 #[cfg_attr(all(miri, feature = "skip_long_tests"), ignore)]
diff --git a/macros/lib.rs b/macros/lib.rs
@@ -48,9 +48,7 @@ fn get_byte_from_lit(lit: &syn::Lit) -> u8 {
 
 fn get_byte_from_expr_lit(expr: &syn::Expr) -> u8 {
     match *expr {
-        syn::Expr::Lit(syn::ExprLit { ref lit, .. }) => {
-            get_byte_from_lit(lit)
-        }
+        syn::Expr::Lit(syn::ExprLit { ref lit, .. }) => get_byte_from_lit(lit),
         _ => unreachable!(),
     }
 }
@@ -69,7 +67,9 @@ fn parse_pat_to_table<'a>(
                 table[value as usize] = case_id;
             }
         }
-        &syn::Pat::Range(syn::PatRange { ref start, ref end, .. }) => {
+        &syn::Pat::Range(syn::PatRange {
+            ref start, ref end, ..
+        }) => {
             let lo = get_byte_from_expr_lit(&start.as_ref().unwrap());
             let hi = get_byte_from_expr_lit(&end.as_ref().unwrap());
             for value in lo..hi {
diff --git a/src/cow_rc_str.rs b/src/cow_rc_str.rs
@@ -4,7 +4,7 @@
 
 use std::borrow::{Borrow, Cow};
 use std::rc::Rc;
-use std::{cmp, fmt, hash, marker, mem, ops, slice, str, ptr};
+use std::{cmp, fmt, hash, marker, mem, ops, ptr, slice, str};
 
 /// A string that is either shared (heap-allocated and reference-counted) or borrowed.
 ///
diff --git a/src/parser.rs b/src/parser.rs
@@ -748,7 +748,7 @@ impl<'i: 't, 't> Parser<'i, 't> {
             match self.parse_until_before(Delimiter::Comma, &mut parse_one) {
                 Ok(v) => values.push(v),
                 Err(e) if !ignore_errors => return Err(e),
-                Err(_) => {},
+                Err(_) => {}
             }
             match self.next() {
                 Err(_) => return Ok(values),
diff --git a/src/rules_and_declarations.rs b/src/rules_and_declarations.rs
@@ -253,10 +253,10 @@ where
             self.input.skip_whitespace();
             let start = self.input.state();
             match self.input.next_including_whitespace_and_comments().ok()? {
-                Token::CloseCurlyBracket |
-                Token::WhiteSpace(..) |
-                Token::Semicolon |
-                Token::Comment(..) => continue,
+                Token::CloseCurlyBracket
+                | Token::WhiteSpace(..)
+                | Token::Semicolon
+                | Token::Comment(..) => continue,
                 Token::AtKeyword(ref name) => {
                     let name = name.clone();
                     return Some(parse_at_rule(&start, name, self.input, &mut *self.parser));
@@ -294,7 +294,7 @@ where
                             &mut *self.parser,
                             Delimiter::Semicolon | Delimiter::CurlyBracketBlock,
                         ) {
-                            return Some(Ok(qual))
+                            return Some(Ok(qual));
                         }
                     }
 
diff --git a/src/serializer.rs b/src/serializer.rs
@@ -49,7 +49,8 @@ where
         dtoa_short::write(dest, value)?
     };
 
-    if int_value.is_none() && value.fract() == 0. && !notation.decimal_point && !notation.scientific {
+    if int_value.is_none() && value.fract() == 0. && !notation.decimal_point && !notation.scientific
+    {
         dest.write_str(".0")?;
     }
     Ok(())
diff --git a/src/tests.rs b/src/tests.rs
@@ -5,7 +5,6 @@
 #[cfg(feature = "bench")]
 extern crate test;
 
-
 use serde_json::{self, json, Map, Value};
 
 #[cfg(feature = "bench")]
@@ -35,10 +34,7 @@ fn almost_equals(a: &Value, b: &Value) -> bool {
         (&Value::Bool(a), &Value::Bool(b)) => a == b,
         (Value::String(a), Value::String(b)) => a == b,
         (Value::Array(a), Value::Array(b)) => {
-            a.len() == b.len()
-                && a.iter()
-                    .zip(b.iter())
-                    .all(|(a, b)| almost_equals(a, b))
+            a.len() == b.len() && a.iter().zip(b.iter()).all(|(a, b)| almost_equals(a, b))
         }
         (&Value::Object(_), &Value::Object(_)) => panic!("Not implemented"),
         (&Value::Null, &Value::Null) => true,
@@ -433,8 +429,7 @@ fn serializer(preserve_comments: bool) {
                 preserve_comments: bool,
             ) {
                 while let Ok(token) = if preserve_comments {
-                    input
-                        .next_including_whitespace_and_comments().cloned()
+                    input.next_including_whitespace_and_comments().cloned()
                 } else {
                     input.next_including_whitespace().cloned()
                 } {
@@ -592,8 +587,6 @@ fn line_numbers() {
 
 #[test]
 fn overflow() {
-    
-
     let css = r"
          2147483646
          2147483647
diff --git a/src/tokenizer.rs b/src/tokenizer.rs
@@ -255,7 +255,9 @@ impl<'a> Tokenizer<'a> {
 
     #[inline]
     pub fn see_function(&mut self, name: &str) {
-        if self.var_or_env_functions == SeenStatus::LookingForThem && (name.eq_ignore_ascii_case("var") || name.eq_ignore_ascii_case("env")) {
+        if self.var_or_env_functions == SeenStatus::LookingForThem
+            && (name.eq_ignore_ascii_case("var") || name.eq_ignore_ascii_case("env"))
+        {
             self.var_or_env_functions = SeenStatus::SeenAtLeastOne;
         }
     }
@@ -320,10 +322,12 @@ impl<'a> Tokenizer<'a> {
 
     pub fn current_source_line(&self) -> &'a str {
         let current = self.position();
-        let start = self.slice(SourcePosition(0)..current)
+        let start = self
+            .slice(SourcePosition(0)..current)
             .rfind(|c| matches!(c, '\r' | '\n' | '\x0C'))
             .map_or(0, |start| start + 1);
-        let end = self.slice(current..SourcePosition(self.input.len()))
+        let end = self
+            .slice(current..SourcePosition(self.input.len()))
             .find(|c| matches!(c, '\r' | '\n' | '\x0C'))
             .map_or(self.input.len(), |end| current.0 + end);
         self.slice(SourcePosition(start)..SourcePosition(end))
@@ -422,7 +426,10 @@ impl<'a> Tokenizer<'a> {
 
     #[inline]
     fn next_char(&self) -> char {
-        unsafe { self.input.get_unchecked(self.position().0..) }.chars().next().unwrap()
+        unsafe { self.input.get_unchecked(self.position().0..) }
+            .chars()
+            .next()
+            .unwrap()
     }
 
     // Given that a newline has been seen, advance over the newline
@@ -1052,9 +1059,13 @@ fn consume_numeric<'a>(tokenizer: &mut Tokenizer<'a>) -> Token<'a> {
 
     let mut value = sign * (integral_part + fractional_part);
 
-    if tokenizer.has_at_least(1) && matches!(tokenizer.next_byte_unchecked(), b'e' | b'E') && (tokenizer.byte_at(1).is_ascii_digit() || (tokenizer.has_at_least(2)
+    if tokenizer.has_at_least(1)
+        && matches!(tokenizer.next_byte_unchecked(), b'e' | b'E')
+        && (tokenizer.byte_at(1).is_ascii_digit()
+            || (tokenizer.has_at_least(2)
                 && matches!(tokenizer.byte_at(1), b'+' | b'-')
-                && tokenizer.byte_at(2).is_ascii_digit())) {
+                && tokenizer.byte_at(2).is_ascii_digit()))
+    {
         is_integer = false;
         tokenizer.advance(1);
         let (has_sign, sign) = match tokenizer.next_byte_unchecked() {

Original file line number	Diff line number	Diff line change
`@@ -48,9 +48,7 @@ fn get_byte_from_lit(lit: &syn::Lit) -> u8 {`
`48`	`48`
`49`	`49`	`fn get_byte_from_expr_lit(expr: &syn::Expr) -> u8 {`
`50`	`50`	`match *expr {`
`51`		`- syn::Expr::Lit(syn::ExprLit { ref lit, .. }) => {`
`52`		`- get_byte_from_lit(lit)`
`53`		`- }`
	`51`	`+ syn::Expr::Lit(syn::ExprLit { ref lit, .. }) => get_byte_from_lit(lit),`
`54`	`52`	`_ => unreachable!(),`
`55`	`53`	`}`
`56`	`54`	`}`
`@@ -69,7 +67,9 @@ fn parse_pat_to_table<'a>(`
`69`	`67`	`table[value as usize] = case_id;`
`70`	`68`	`}`
`71`	`69`	`}`
`72`		`- &syn::Pat::Range(syn::PatRange { ref start, ref end, .. }) => {`
	`70`	`+ &syn::Pat::Range(syn::PatRange {`
	`71`	`+ ref start, ref end, ..`
	`72`	`+ }) => {`
`73`	`73`	`let lo = get_byte_from_expr_lit(&start.as_ref().unwrap());`
`74`	`74`	`let hi = get_byte_from_expr_lit(&end.as_ref().unwrap());`
`75`	`75`	`for value in lo..hi {`
Original file line number	Diff line number	Diff line change
`@@ -748,7 +748,7 @@ impl<'i: 't, 't> Parser<'i, 't> {`
`748`	`748`	`match self.parse_until_before(Delimiter::Comma, &mut parse_one) {`
`749`	`749`	`Ok(v) => values.push(v),`
`750`	`750`	`Err(e) if !ignore_errors => return Err(e),`
`751`		`- Err(_) => {},`
	`751`	`+ Err(_) => {}`
`752`	`752`	`}`
`753`	`753`	`match self.next() {`
`754`	`754`	`Err(_) => return Ok(values),`
Original file line number	Diff line number	Diff line change
`@@ -49,7 +49,8 @@ where`
`49`	`49`	`dtoa_short::write(dest, value)?`
`50`	`50`	`};`
`51`	`51`
`52`		`- if int_value.is_none() && value.fract() == 0. && !notation.decimal_point && !notation.scientific {`
	`52`	`+ if int_value.is_none() && value.fract() == 0. && !notation.decimal_point && !notation.scientific`
	`53`	`+ {`
`53`	`54`	`dest.write_str(".0")?;`
`54`	`55`	`}`
`55`	`56`	`Ok(())`