Run rustfmt on selectors, servo_arc, and style.

This was generated with:

./mach cargo fmt --package selectors &&
./mach cargo fmt --package servo_arc &&
./mach cargo fmt --package style

Using rustfmt 0.4.1-nightly (a4462d1 2018-03-26)

components/style/str.rs

@@ -22,13 +22,8 @@ pub type StaticStringVec = &'static [&'static str];
 /// A "space character" according to:
 ///
 /// <https://html.spec.whatwg.org/multipage/#space-character>
-pub static HTML_SPACE_CHARACTERS: StaticCharVec = &[
-    '\u{0020}',
-    '\u{0009}',
-    '\u{000a}',
-    '\u{000c}',
-    '\u{000d}',
-];
+pub static HTML_SPACE_CHARACTERS: StaticCharVec =
+    &['\u{0020}', '\u{0009}', '\u{000a}', '\u{000c}', '\u{000d}'];
 
 /// Whether a character is a HTML whitespace character.
 #[inline]
@@ -43,13 +38,17 @@ pub fn is_whitespace(s: &str) -> bool {
 }
 
 #[inline]
-fn not_empty(&split: &&str) -> bool { !split.is_empty() }
+fn not_empty(&split: &&str) -> bool {
+    !split.is_empty()
+}
 
 /// Split a string on HTML whitespace.
 #[inline]
-pub fn split_html_space_chars<'a>(s: &'a str) ->
-                                  Filter<Split<'a, StaticCharVec>, fn(&&str) -> bool> {
-    s.split(HTML_SPACE_CHARACTERS).filter(not_empty as fn(&&str) -> bool)
+pub fn split_html_space_chars<'a>(
+    s: &'a str,
+) -> Filter<Split<'a, StaticCharVec>, fn(&&str) -> bool> {
+    s.split(HTML_SPACE_CHARACTERS)
+        .filter(not_empty as fn(&&str) -> bool)
 }
 
 /// Split a string on commas.
@@ -78,44 +77,45 @@ fn is_exponent_char(c: char) -> bool {
 }
 
 /// Read a set of ascii digits and read them into a number.
-pub fn read_numbers<I: Iterator<Item=char>>(mut iter: Peekable<I>) -> (Option<i64>, usize) {
+pub fn read_numbers<I: Iterator<Item = char>>(mut iter: Peekable<I>) -> (Option<i64>, usize) {
     match iter.peek() {
         Some(c) if is_ascii_digit(c) => (),
         _ => return (None, 0),
     }
 
-    iter.take_while(is_ascii_digit).map(|d| {
-        d as i64 - '0' as i64
-    }).fold((Some(0i64), 0), |accumulator, d| {
-        let digits = accumulator.0.and_then(|accumulator| {
-            accumulator.checked_mul(10)
-        }).and_then(|accumulator| {
-            accumulator.checked_add(d)
-        });
-        (digits, accumulator.1 + 1)
-    })
+    iter.take_while(is_ascii_digit)
+        .map(|d| d as i64 - '0' as i64)
+        .fold((Some(0i64), 0), |accumulator, d| {
+            let digits = accumulator
+                .0
+                .and_then(|accumulator| accumulator.checked_mul(10))
+                .and_then(|accumulator| accumulator.checked_add(d));
+            (digits, accumulator.1 + 1)
+        })
 }
 
 /// Read a decimal fraction.
-pub fn read_fraction<I: Iterator<Item=char>>(mut iter: Peekable<I>,
-                                             mut divisor: f64,
-                                             value: f64) -> (f64, usize) {
+pub fn read_fraction<I: Iterator<Item = char>>(
+    mut iter: Peekable<I>,
+    mut divisor: f64,
+    value: f64,
+) -> (f64, usize) {
     match iter.peek() {
         Some(c) if is_decimal_point(*c) => (),
         _ => return (value, 0),
     }
     iter.next();
 
-    iter.take_while(is_ascii_digit).map(|d|
-        d as i64 - '0' as i64
-    ).fold((value, 1), |accumulator, d| {
-        divisor *= 10f64;
-        (accumulator.0 + d as f64 / divisor, accumulator.1 + 1)
-    })
+    iter.take_while(is_ascii_digit)
+        .map(|d| d as i64 - '0' as i64)
+        .fold((value, 1), |accumulator, d| {
+            divisor *= 10f64;
+            (accumulator.0 + d as f64 / divisor, accumulator.1 + 1)
+        })
 }
 
 /// Reads an exponent from an iterator over chars, for example `e100`.
-pub fn read_exponent<I: Iterator<Item=char>>(mut iter: Peekable<I>) -> Option<i32> {
+pub fn read_exponent<I: Iterator<Item = char>>(mut iter: Peekable<I>) -> Option<i32> {
     match iter.peek() {
         Some(c) if is_exponent_char(*c) => (),
         _ => return None,
@@ -127,31 +127,36 @@ pub fn read_exponent<I: Iterator<Item=char>>(mut iter: Peekable<I>) -> Option<i3
         Some(&'-') => {
             iter.next();
             read_numbers(iter).0.map(|exp| -exp.to_i32().unwrap_or(0))
-        }
+        },
         Some(&'+') => {
             iter.next();
             read_numbers(iter).0.map(|exp| exp.to_i32().unwrap_or(0))
-        }
-        Some(_) => read_numbers(iter).0.map(|exp| exp.to_i32().unwrap_or(0))
+        },
+        Some(_) => read_numbers(iter).0.map(|exp| exp.to_i32().unwrap_or(0)),
     }
 }
 
 /// Join a set of strings with a given delimiter `join`.
 pub fn str_join<I, T>(strs: I, join: &str) -> String
-    where I: IntoIterator<Item=T>,
-          T: AsRef<str>,
+where
+    I: IntoIterator<Item = T>,
+    T: AsRef<str>,
 {
-    strs.into_iter().enumerate().fold(String::new(), |mut acc, (i, s)| {
-        if i > 0 { acc.push_str(join); }
-        acc.push_str(s.as_ref());
-        acc
-    })
+    strs.into_iter()
+        .enumerate()
+        .fold(String::new(), |mut acc, (i, s)| {
+            if i > 0 {
+                acc.push_str(join);
+            }
+            acc.push_str(s.as_ref());
+            acc
+        })
 }
 
 /// Returns true if a given string has a given prefix with case-insensitive match.
 pub fn starts_with_ignore_ascii_case(string: &str, prefix: &str) -> bool {
     string.len() >= prefix.len() &&
-      string.as_bytes()[0..prefix.len()].eq_ignore_ascii_case(prefix.as_bytes())
+        string.as_bytes()[0..prefix.len()].eq_ignore_ascii_case(prefix.as_bytes())
 }
 
 /// Returns an ascii lowercase version of a string, only allocating if needed.