Simplify CI and formatting configuration

Author: laurmaedje

.github/workflows/ci.yml

@@ -0,0 +1,11 @@
+name: Continuous integration
+on: [push, pull_request]
+
+jobs:
+  ci:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@stable
+      - run: cargo build
+      - run: cargo test

.github/workflows/rust.yml

@@ -1,3 +1,4 @@
 /target
 Cargo.lock
 bench/target
+.DS_Store

.gitignore

@@ -1,10 +1,6 @@
-unstable_features = true
-
-overflow_delimited_expr = true
-spaces_around_ranges = true
-use_field_init_shorthand = true
-
+use_small_heuristics = "Max"
 max_width = 90
-struct_lit_width = 40
 chain_width = 70
-single_line_if_else_max_width = 60
+struct_lit_width = 50
+use_field_init_shorthand = true
+merge_derives = false

rustfmt.toml

@@ -150,7 +150,7 @@ impl ChunksExt for [Spanned<Chunk>] {
     fn span(&self) -> Span {
         let start = self.first().map(|c| c.span.start).unwrap_or(0);
         let end = self.last().map(|c| c.span.end).unwrap_or(start);
-        start .. end
+        start..end
     }
 
     fn to_biblatex_string(&self, is_verbatim: bool) -> String {
@@ -181,7 +181,7 @@ impl ChunksExt for [Spanned<Chunk>] {
             }
         }
 
-        for _ in 0 .. if extra_brace { 2 } else { 1 } {
+        for _ in 0..if extra_brace { 2 } else { 1 } {
             res.push('}');
         }
 
@@ -210,7 +210,7 @@ pub(crate) fn join_chunk_list(chunks: ChunksRef, sep: &str) -> Chunks {
         } else {
             res.push(Spanned::new(
                 Chunk::Normal(sep.to_string()),
-                chunk.span.start .. chunk.span.start,
+                chunk.span.start..chunk.span.start,
             ));
         }
 
@@ -234,20 +234,20 @@ pub(crate) fn split_token_lists(vals: ChunksRef, keyword: &str) -> Vec<Chunks> {
             let mut start = val.span.start;
 
             while let Some(pos) = target.find(keyword) {
-                let first = target[.. pos].trim_end();
+                let first = target[..pos].trim_end();
                 latest.push(Spanned::new(
                     Chunk::Normal(first.to_string()),
-                    start .. start + pos,
+                    start..start + pos,
                 ));
                 out.push(std::mem::take(&mut latest));
 
-                target = target[pos + keyword.len() ..].trim_start();
+                target = target[pos + keyword.len()..].trim_start();
                 start += pos + keyword.len();
             }
 
             latest.push(Spanned::new(
                 Chunk::Normal(target.to_string()),
-                start .. val.span.end,
+                start..val.span.end,
             ));
         } else {
             latest.push(val.clone());
@@ -308,7 +308,7 @@ pub(crate) fn split_values(
     }
 
     if chunk_idx + 1 < src.len() {
-        new.extend(src.drain(chunk_idx + 1 ..));
+        new.extend(src.drain(chunk_idx + 1..));
     }
 
     let item = src.last_mut().unwrap();
@@ -317,8 +317,8 @@ pub(crate) fn split_values(
     let (s1, s2) = content.split_at(str_idx);
 
     let boundry = item.span.start.saturating_add(str_idx);
-    item.span = item.span.start .. boundry;
-    let new_span = boundry .. boundry.saturating_add(s2.len());
+    item.span = item.span.start..boundry;
+    let new_span = boundry..boundry.saturating_add(s2.len());
 
     let s1 = s1.trim_end().to_string();
     let s2 = s2.trim_start().to_string();
@@ -364,13 +364,9 @@ pub(crate) mod tests {
 
     #[test]
     fn test_split() {
-        let vls = &[
-            s(N("split "), 1 .. 7),
-            s(V("exac^tly"), 9 .. 17),
-            s(N("here"), 19 .. 23),
-        ];
-        let ref1 = &[s(N("split "), 1 .. 7), s(V("exac^"), 9 .. 14)];
-        let ref2 = &[s(V("tly"), 14 .. 17), s(N("here"), 19 .. 23)];
+        let vls = &[s(N("split "), 1..7), s(V("exac^tly"), 9..17), s(N("here"), 19..23)];
+        let ref1 = &[s(N("split "), 1..7), s(V("exac^"), 9..14)];
+        let ref2 = &[s(V("tly"), 14..17), s(N("here"), 19..23)];
 
         let split = split_values(vls, 1, 5);
         assert_eq!(split.0, ref1);
@@ -380,16 +376,13 @@ pub(crate) mod tests {
     #[test]
     fn test_split_at_normal_char() {
         let vls = &[
-            s(N("split "), 1 .. 7),
-            s(V("not, "), 9 .. 14),
-            s(N("but rather, here"), 16 .. 32),
-        ];
-        let ref1 = &[
-            s(N("split "), 1 .. 7),
-            s(V("not, "), 9 .. 14),
-            s(N("but rather"), 16 .. 26),
+            s(N("split "), 1..7),
+            s(V("not, "), 9..14),
+            s(N("but rather, here"), 16..32),
         ];
-        let ref2 = &[s(N("here"), 28 .. 32)];
+        let ref1 =
+            &[s(N("split "), 1..7), s(V("not, "), 9..14), s(N("but rather"), 16..26)];
+        let ref2 = &[s(N("here"), 28..32)];
 
         let split = split_at_normal_char(vls, ',', true);
         assert_eq!(split.0, ref1);

src/chunk.rs

@@ -103,10 +103,7 @@ fn convert_result<T>(err: Result<T, RetrievalError>) -> Result<Option<T>, TypeEr
 impl Bibliography {
     /// Create a new, empty bibliography.
     pub fn new() -> Self {
-        Self {
-            entries: Vec::new(),
-            keys: BTreeMap::new(),
-        }
+        Self { entries: Vec::new(), keys: BTreeMap::new() }
     }
 
     /// Parse a bibliography from a source string.
@@ -266,11 +263,7 @@ impl Bibliography {
             if !first {
                 write!(sink, "\n")?;
             }
-            writeln!(
-                sink,
-                "{}",
-                entry.to_bibtex_string().map_err(|_| fmt::Error)?
-            )?;
+            writeln!(sink, "{}", entry.to_bibtex_string().map_err(|_| fmt::Error)?)?;
             first = false;
         }
         Ok(())
@@ -995,10 +988,7 @@ mod tests {
         let rashid = bibliography.get("rashid2016").unwrap();
         match rashid.pagination() {
             Err(RetrievalError::TypeError(s)) => {
-                assert_eq!(
-                    s,
-                    TypeError::new(352..359, TypeErrorKind::UnknownPagination)
-                );
+                assert_eq!(s, TypeError::new(352..359, TypeErrorKind::UnknownPagination));
             }
             _ => {
                 panic!()
@@ -1099,14 +1089,8 @@ mod tests {
         let contents = fs::read_to_string("tests/cross.bib").unwrap();
         let mut bibliography = Bibliography::parse(&contents).unwrap();
 
-        assert_eq!(
-            bibliography.get_mut("haug2019").unwrap().verify().is_ok(),
-            true
-        );
-        assert_eq!(
-            bibliography.get_mut("cannonfodder").unwrap().verify().is_ok(),
-            true
-        );
+        assert_eq!(bibliography.get_mut("haug2019").unwrap().verify().is_ok(), true);
+        assert_eq!(bibliography.get_mut("cannonfodder").unwrap().verify().is_ok(), true);
 
         let ill = bibliography.get("ill-defined").unwrap();
         let report = ill.verify();
@@ -1129,17 +1113,11 @@ mod tests {
 
         let e = bibliography.get("macmillan").unwrap();
         assert_eq!(e.publisher().unwrap()[0].format_verbatim(), "Macmillan");
-        assert_eq!(
-            e.location().unwrap().format_verbatim(),
-            "New York and London"
-        );
+        assert_eq!(e.location().unwrap().format_verbatim(), "New York and London");
 
         let book = bibliography.get("recursive").unwrap();
         assert_eq!(book.publisher().unwrap()[0].format_verbatim(), "Macmillan");
-        assert_eq!(
-            book.location().unwrap().format_verbatim(),
-            "New York and London"
-        );
+        assert_eq!(book.location().unwrap().format_verbatim(), "New York and London");
         assert_eq!(
             book.title().unwrap().format_verbatim(),
             "Recursive shennenigans and other important stuff"

src/lib.rs

@@ -190,22 +190,16 @@ impl<'s> BiblatexParser<'s> {
 
     /// Eat a delimiter.
     fn brace(&mut self, open: bool) -> Result<(), ParseError> {
-        let (brace, token) = if open {
-            ('{', Token::OpeningBrace)
-        } else {
-            ('}', Token::ClosingBrace)
-        };
+        let (brace, token) =
+            if open { ('{', Token::OpeningBrace) } else { ('}', Token::ClosingBrace) };
 
         let peeked = self.s.peek();
 
         if peeked == Some(brace) || peeked == Some('\"') {
             self.s.eat();
             Ok(())
         } else {
-            Err(ParseError::new(
-                self.here(),
-                ParseErrorKind::Expected(token),
-            ))
+            Err(ParseError::new(self.here(), ParseErrorKind::Expected(token)))
         }
     }
 
@@ -224,10 +218,7 @@ impl<'s> BiblatexParser<'s> {
     /// Eat an equals sign.
     fn equals(&mut self) -> Result<(), ParseError> {
         if !self.s.eat_if('=') {
-            Err(ParseError::new(
-                self.here(),
-                ParseErrorKind::Expected(Token::Equals),
-            ))
+            Err(ParseError::new(self.here(), ParseErrorKind::Expected(Token::Equals)))
         } else {
             Ok(())
         }
@@ -433,10 +424,7 @@ impl<'s> BiblatexParser<'s> {
             self.s.eat_while(is_id_continue);
             Ok(Spanned::new(self.s.from(idx), idx..self.s.cursor()))
         } else {
-            Err(ParseError::new(
-                self.here(),
-                ParseErrorKind::Expected(Token::Identifier),
-            ))
+            Err(ParseError::new(self.here(), ParseErrorKind::Expected(Token::Identifier)))
         }
     }
 
@@ -495,10 +483,9 @@ impl<'s> BiblatexParser<'s> {
         self.s.eat_whitespace();
         let fields = self.fields()?;
 
-        self.res.entries.push(Spanned::new(
-            RawEntry { key, kind, fields },
-            start..self.s.cursor(),
-        ));
+        self.res
+            .entries
+            .push(Spanned::new(RawEntry { key, kind, fields }, start..self.s.cursor()));
         Ok(())
     }