refactor: solve clippy warnings

buildkite.yaml

@@ -78,3 +78,12 @@ steps:
     command:
       - echo +++
       - nix flake check
+
+  - label: lint
+    if: build.branch != "main"
+    command:
+      - echo --- Load environment
+      - direnv allow
+      - eval "$(direnv export bash)"
+      - echo +++ Run Linter
+      - cargo clippy

src/builder.rs

@@ -44,8 +44,8 @@ pub fn build(
         config.clone(),
         force_wide,
         path,
-        crate::position::Position::new(),
+        crate::position::Position::default(),
-        crate::position::Position::new(),
+        crate::position::Position::default(),
     );
 
     build_step(

src/children.rs

@@ -126,15 +126,12 @@ impl Children {
 
     pub fn drain_comment<F: FnMut(String)>(&mut self, mut callback: F) {
         if let Some(child) = self.peek_next() {
-            match child.element.kind() {
+            if let rnix::SyntaxKind::TOKEN_COMMENT = child.element.kind() {
-                rnix::SyntaxKind::TOKEN_COMMENT => {
+                callback(dedent_comment(
-                    callback(dedent_comment(
+                    &child.pos,
-                        &child.pos,
+                    child.element.into_token().unwrap().text(),
-                        child.element.into_token().unwrap().text(),
+                ));
-                    ));
+                self.move_next();
-                    self.move_next();
-                }
-                _ => {}
             }
         }
     }

src/cli.rs

@@ -150,8 +150,8 @@ pub fn tui(
 
     while !finished {
         loop {
-            match receiver.try_recv() {
+            if let Ok(event) = receiver.try_recv() {
-                Ok(event) => match event {
+                match event {
                     Event::FormattedPath(formatted_path) => {
                         match formatted_path.result {
                             Ok(changed) => {
@@ -175,20 +175,14 @@ pub fn tui(
                         finished = true;
                     }
                     Event::Input(key) => {
-                        match key {
+                        if let termion::event::Key::Ctrl('c') = key {
-                            termion::event::Key::Ctrl('c') => {
+                            return Err(std::io::ErrorKind::Interrupted.into());
-                                return Err(
+                        }
-                                    std::io::ErrorKind::Interrupted.into()
-                                );
-                            }
-                            _ => {}
-                        };
                     }
                     Event::Tick => {
                         break;
                     }
-                },
+                }
-                Err(_) => {}
             }
         }
 

src/config.rs

@@ -9,11 +9,13 @@ pub struct Config {
     layout: Layout,
 }
 
-impl Config {
+impl Default for Config {
-    pub fn new() -> Config {
+    fn default() -> Config {
         Config { layout: Layout::Tall }
     }
+}
 
+impl Config {
     pub fn layout(&self) -> &Layout {
         &self.layout
     }

src/main.rs

@@ -1,7 +1,7 @@
 fn main() -> std::io::Result<()> {
     let matches = alejandra::cli::parse(std::env::args().collect());
 
-    let config = alejandra::config::Config::new();
+    let config = alejandra::config::Config::default();
 
     match matches.values_of("paths") {
         Some(paths) => {

src/position.rs

@@ -4,11 +4,13 @@ pub struct Position {
     pub line:   usize,
 }
 
-impl Position {
+impl Default for Position {
-    pub fn new() -> Position {
+    fn default() -> Position {
         Position { column: 0, line: 1 }
     }
+}
 
+impl Position {
     pub fn update(&mut self, text: &str) {
         let chars: Vec<char> = text.chars().collect();
         let newlines = chars.iter().filter(|&c| *c == '\n').count();

src/rules/bin_op_and_or_default.rs

@@ -28,16 +28,14 @@ pub fn rule_with_configuration(
         crate::config::Layout::Tall => {
             let kind = child.element.kind();
 
-            if parent_kind == "bin_op_and_or_default"
+            if (parent_kind == "bin_op_and_or_default"
                 && matches!(
                     kind,
                     rnix::SyntaxKind::NODE_BIN_OP
                         | rnix::SyntaxKind::NODE_OR_DEFAULT
-                )
+                ))
-            {
+                || (parent_kind == "select"
-                steps.push_back(crate::builder::Step::Format(child.element));
+                    && matches!(kind, rnix::SyntaxKind::NODE_SELECT))
-            } else if parent_kind == "select"
-                && matches!(kind, rnix::SyntaxKind::NODE_SELECT)
             {
                 steps.push_back(crate::builder::Step::Format(child.element));
             } else {

src/rules/if_else.rs

@@ -36,13 +36,8 @@ pub fn rule(
             if crate::builder::fits_in_single_line(
                 build_ctx,
                 child.element.clone(),
-            ) {
+            ) || (branch == "else"
-                steps.push_back(crate::builder::Step::Whitespace);
+                && child.element.kind() == rnix::SyntaxKind::NODE_IF_ELSE)
-                steps.push_back(crate::builder::Step::FormatWider(
-                    child.element,
-                ));
-            } else if branch == "else"
-                && child.element.kind() == rnix::SyntaxKind::NODE_IF_ELSE
             {
                 steps.push_back(crate::builder::Step::Whitespace);
                 steps.push_back(crate::builder::Step::FormatWider(

src/rules/key_value.rs

@@ -83,22 +83,20 @@ pub fn rule(
                 steps.push_back(crate::builder::Step::Indent);
                 steps.push_back(crate::builder::Step::NewLine);
                 steps.push_back(crate::builder::Step::Pad);
-            } else if false
+            } else if matches!(
-                || matches!(
+                child_expr.element.kind(),
-                    child_expr.element.kind(),
+                rnix::SyntaxKind::NODE_ASSERT
-                    rnix::SyntaxKind::NODE_ASSERT
+                    | rnix::SyntaxKind::NODE_ATTR_SET
-                        | rnix::SyntaxKind::NODE_ATTR_SET
+                    | rnix::SyntaxKind::NODE_PAREN
-                        | rnix::SyntaxKind::NODE_PAREN
+                    | rnix::SyntaxKind::NODE_LAMBDA
-                        | rnix::SyntaxKind::NODE_LAMBDA
+                    | rnix::SyntaxKind::NODE_LET_IN
-                        | rnix::SyntaxKind::NODE_LET_IN
+                    | rnix::SyntaxKind::NODE_LIST
-                        | rnix::SyntaxKind::NODE_LIST
+                    | rnix::SyntaxKind::NODE_STRING
-                        | rnix::SyntaxKind::NODE_STRING
+                    | rnix::SyntaxKind::NODE_WITH
-                        | rnix::SyntaxKind::NODE_WITH
+            ) || (matches!(
-                )
+                child_expr.element.kind(),
-                || (matches!(
+                rnix::SyntaxKind::NODE_APPLY
-                    child_expr.element.kind(),
+            ) && !newlines)
-                    rnix::SyntaxKind::NODE_APPLY
-                ) && !newlines)
             {
                 steps.push_back(crate::builder::Step::Whitespace);
             } else {

src/rules/let_in.rs

@@ -10,11 +10,13 @@ pub fn rule(
 
     let items_count = node
         .children()
-        .filter(|element| match element.kind() {
+        .filter(|element| {
-            rnix::SyntaxKind::NODE_KEY_VALUE
+            matches!(
-            | rnix::SyntaxKind::NODE_INHERIT
+                element.kind(),
-            | rnix::SyntaxKind::NODE_INHERIT_FROM => true,
+                rnix::SyntaxKind::NODE_KEY_VALUE
-            _ => false,
+                    | rnix::SyntaxKind::NODE_INHERIT
+                    | rnix::SyntaxKind::NODE_INHERIT_FROM
+            )
         })
         .count();
 

src/rules/pattern.rs

@@ -21,10 +21,12 @@ pub fn rule(
 
     let items_count = node
         .children_with_tokens()
-        .filter(|element| match element.kind() {
+        .filter(|element| {
-            rnix::SyntaxKind::TOKEN_ELLIPSIS
+            matches!(
-            | rnix::SyntaxKind::NODE_PAT_ENTRY => true,
+                element.kind(),
-            _ => false,
+                rnix::SyntaxKind::TOKEN_ELLIPSIS
+                    | rnix::SyntaxKind::NODE_PAT_ENTRY
+            )
         })
         .count();