rustfmt

Author: SimonSapin

build/match_byte.rs

@@ -73,7 +73,12 @@ fn get_byte_from_expr_lit(expr: &Box<syn::Expr>) -> u8 {
 }
 
 /// Parse a pattern and fill the table accordingly
-fn parse_pat_to_table<'a>(pat: &'a syn::Pat, case_id: u8, wildcard: &mut Option<&'a syn::Ident>, table: &mut [u8; 256]) {
+fn parse_pat_to_table<'a>(
+    pat: &'a syn::Pat,
+    case_id: u8,
+    wildcard: &mut Option<&'a syn::Ident>,
+    table: &mut [u8; 256],
+) {
     match pat {
         &syn::Pat::Lit(syn::PatLit { ref expr, .. }) => {
             let value = get_byte_from_expr_lit(expr);
@@ -108,7 +113,7 @@ fn parse_pat_to_table<'a>(pat: &'a syn::Pat, case_id: u8, wildcard: &mut Option<
                     *byte = case_id;
                 }
             }
-        },
+        }
         &syn::Pat::Or(syn::PatOr { ref cases, .. }) => {
             for case in cases {
                 parse_pat_to_table(case, case_id, wildcard, table);

src/rules_and_declarations.rs

@@ -268,9 +268,7 @@ where
             let start = self.input.state();
             // FIXME: remove intermediate variable when lifetimes are non-lexical
             let ident = match self.input.next_including_whitespace_and_comments() {
-                Ok(&Token::WhiteSpace(_)) | Ok(&Token::Comment(_)) | Ok(&Token::Semicolon) => {
-                    continue
-                }
+                Ok(&Token::WhiteSpace(_)) | Ok(&Token::Comment(_)) | Ok(&Token::Semicolon) => continue,
                 Ok(&Token::Ident(ref name)) => Ok(Ok(name.clone())),
                 Ok(&Token::AtKeyword(ref name)) => Ok(Err(name.clone())),
                 Ok(token) => Err(token.clone()),

src/serializer.rs

@@ -451,15 +451,24 @@ impl TokenSerializationType {
             ),
             Number => matches!(
                 other.0,
-                Ident | Function | UrlOrBadUrl | DelimMinus | Number | Percentage | DelimPercent | Dimension
+                Ident
+                    | Function
+                    | UrlOrBadUrl
+                    | DelimMinus
+                    | Number
+                    | Percentage
+                    | DelimPercent
+                    | Dimension
             ),
             DelimAt => matches!(other.0, Ident | Function | UrlOrBadUrl | DelimMinus),
             DelimDotOrPlus => matches!(other.0, Number | Percentage | Dimension),
             DelimAssorted | DelimAsterisk => matches!(other.0, DelimEquals),
             DelimBar => matches!(other.0, DelimEquals | DelimBar | DashMatch),
             DelimSlash => matches!(other.0, DelimAsterisk | SubstringMatch),
             Nothing | WhiteSpace | Percentage | UrlOrBadUrl | Function | CDC | OpenParen
-            | DashMatch | SubstringMatch | DelimQuestion | DelimEquals | DelimPercent | Other => false,
+            | DashMatch | SubstringMatch | DelimQuestion | DelimEquals | DelimPercent | Other => {
+                false
+            }
         }
     }
 }

src/tests.rs

@@ -6,7 +6,7 @@
 extern crate test;
 
 use encoding_rs;
-use serde_json::{self, Value, json, Map};
+use serde_json::{self, json, Map, Value};
 
 #[cfg(feature = "bench")]
 use self::test::Bencher;
@@ -30,7 +30,7 @@ fn almost_equals(a: &Value, b: &Value) -> bool {
             let a = a.as_f64().unwrap();
             let b = b.as_f64().unwrap();
             (a - b).abs() <= a.abs() * 1e-6
-        },
+        }
 
         (&Value::Bool(a), &Value::Bool(b)) => a == b,
         (&Value::String(ref a), &Value::String(ref b)) => a == b,
@@ -410,15 +410,16 @@ fn unicode_range() {
                 Ok(None)
             }
         });
-        result.unwrap()
+        result
+            .unwrap()
             .iter()
-            .map(|v|
-                if let Some((v0, v1)) = v{
+            .map(|v| {
+                if let Some((v0, v1)) = v {
                     json!([v0, v1])
                 } else {
                     Value::Null
                 }
-            )
+            })
             .collect::<Vec<_>>()
             .to_json()
     });
@@ -809,7 +810,11 @@ trait ToJson {
     fn to_json(&self) -> Value;
 }
 
-impl<T> ToJson for T where T: Clone, Value: From<T> {
+impl<T> ToJson for T
+where
+    T: Clone,
+    Value: From<T>,
+{
     fn to_json(&self) -> Value {
         Value::from(self.clone())
     }