chore: clippy

Author: Serial-ATA

src/builder/compose.rs

@@ -360,7 +360,6 @@ impl DockerBuilder {
             timeout: Some(health.timeout.as_nanos() as i64),
             retries: Some(health.retries as i64),
             start_period: None,
-            ..Default::default()
         }
     }
 
@@ -411,7 +410,7 @@ impl DockerBuilder {
             }
 
             // Create a temporary directory for the build context
-            let temp_dir = tempfile::tempdir().map_err(|e| DockerError::FileError(e.into()))?;
+            let temp_dir = tempfile::tempdir()?;
             let temp_dockerfile = temp_dir.path().join("Dockerfile");
 
             // Copy the Dockerfile to temp directory
@@ -481,7 +480,7 @@ impl DockerBuilder {
         };
 
         // Pull the image if it doesn't exist
-        if let Err(_) = self.client.inspect_image(&image).await {
+        if self.client.inspect_image(&image).await.is_err() {
             let mut pull_stream = self.client.create_image(
                 Some(bollard::image::CreateImageOptions {
                     from_image: image.as_str(),

src/builder/docker_file.rs

@@ -102,7 +102,7 @@ impl DockerBuilder {
         env: Option<Vec<String>>,
     ) -> Result<String, DockerError> {
         // Create a temporary directory for the build context
-        let temp_dir = tempfile::tempdir().map_err(|e| DockerError::FileError(e.into()))?;
+        let temp_dir = tempfile::tempdir()?;
         let dockerfile_path = temp_dir.path().join("Dockerfile");
 
         // Write the Dockerfile content from our config

src/builder/management.rs

@@ -280,7 +280,7 @@ impl DockerBuilder {
             .volumes
             .unwrap_or_default()
             .into_iter()
-            .filter_map(|v| Some(v.name))
+            .map(|v| v.name)
             .collect())
     }
 

src/config/compose.rs

@@ -92,7 +92,7 @@ impl ComposeConfig {
         for (service_name, service) in &self.services {
             if let Some(env) = &service.environment {
                 for var in vars {
-                    if !env.contains_key(*var) {
+                    if !env.contains_key(var) {
                         return Err(DockerError::ValidationError(format!(
                             "Service '{}' is missing required environment variable: {}",
                             service_name, var
@@ -323,7 +323,7 @@ impl ComposeConfig {
                 })?;
                 if entry.path().extension().and_then(|s| s.to_str()) == Some("env") {
                     println!("Loading common env file: {}", entry.path().display());
-                    match std::fs::read_to_string(&entry.path()) {
+                    match std::fs::read_to_string(entry.path()) {
                         Ok(content) => {
                             let file_vars =
                                 crate::parser::compose::ComposeParser::parse_env_file(&content)?;

src/config/docker_file.rs

@@ -1,5 +1,6 @@
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
+use std::fmt::Display;
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct DockerfileConfig {
@@ -80,16 +81,16 @@ impl DockerfileConfig {
         let mut content = format!("FROM {}\n", self.base_image);
 
         for command in &self.commands {
-            content.push_str(&format!("{}\n", command.to_string()));
+            content.push_str(&format!("{}\n", command));
         }
 
         content
     }
 }
 
-impl ToString for DockerCommand {
-    fn to_string(&self) -> String {
-        match self {
+impl Display for DockerCommand {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let str = match self {
             DockerCommand::Add {
                 sources,
                 dest,
@@ -174,7 +175,7 @@ impl ToString for DockerCommand {
                 format!("LABEL {}", labels)
             }
             DockerCommand::Maintainer { name } => format!("MAINTAINER {}", name),
-            DockerCommand::Onbuild { command } => format!("ONBUILD {}", command.to_string()),
+            DockerCommand::Onbuild { command } => format!("ONBUILD {}", command),
             DockerCommand::Run { command } => format!("RUN {}", command),
             DockerCommand::Shell { shell } => format!("SHELL {}", shell_words::join(shell)),
             DockerCommand::StopSignal { signal } => format!("STOPSIGNAL {}", signal),
@@ -187,6 +188,7 @@ impl ToString for DockerCommand {
             }
             DockerCommand::Volume { paths } => format!("VOLUME {}", shell_words::join(paths)),
             DockerCommand::Workdir { path } => format!("WORKDIR {}", path),
-        }
+        };
+        write!(f, "{}", str)
     }
 }

src/config/env_vars.rs

@@ -1,7 +1,7 @@
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
-#[derive(Debug, Clone, Serialize)]
+#[derive(Debug, Default, Clone, Serialize)]
 pub struct EnvironmentVars(HashMap<String, String>);
 
 impl<'de> Deserialize<'de> for EnvironmentVars {
@@ -53,12 +53,6 @@ impl<'de> Deserialize<'de> for EnvironmentVars {
     }
 }
 
-impl Default for EnvironmentVars {
-    fn default() -> Self {
-        EnvironmentVars(HashMap::new())
-    }
-}
-
 impl EnvironmentVars {
     pub fn contains_key(&self, key: &str) -> bool {
         self.0.contains_key(key)

src/parser/compose.rs

@@ -427,6 +427,7 @@ impl ComposeParser {
 }
 
 #[cfg(test)]
+#[allow(clippy::literal_string_with_formatting_args)]
 mod tests {
     use super::*;
     use std::fs;

src/parser/docker_file.rs

@@ -42,20 +42,21 @@ impl DockerfileParser {
         };
 
         let mut current_command = String::new();
-        let mut lines = content.lines().peekable();
 
-        while let Some(line) = lines.next() {
+        for line in content.lines() {
             let line = line.trim();
             if line.is_empty() || line.starts_with('#') {
                 continue;
             }
 
             // Handle line continuations
-            if line.ends_with('\\') {
-                current_command.push_str(&line[..line.len() - 1]);
+            if let Some(s) = line.strip_suffix('\\') {
+                current_command.push_str(s);
                 current_command.push(' ');
                 continue;
-            } else if !current_command.is_empty() {
+            }
+
+            if !current_command.is_empty() {
                 current_command.push_str(line);
                 Self::parse_command(&mut config, &current_command)?;
                 current_command.clear();
@@ -303,9 +304,8 @@ impl DockerfileParser {
                 let mut current_key = String::new();
                 let mut current_value = String::new();
                 let mut in_quotes = false;
-                let mut chars = args.chars().peekable();
 
-                while let Some(c) = chars.next() {
+                for c in args.chars() {
                     match c {
                         '"' => in_quotes = !in_quotes,
                         '=' if !in_quotes && current_key.is_empty() => {
@@ -323,11 +323,7 @@ impl DockerfileParser {
                             }
                         }
                         _ => {
-                            if current_key.is_empty() {
-                                current_value.push(c);
-                            } else {
-                                current_value.push(c);
-                            }
+                            current_value.push(c);
                         }
                     }
                 }

src/tests/compose_health.rs

@@ -85,7 +85,7 @@ with_docker_cleanup!(test_healthcheck, async |test_id: &str| {
     let container_id = container_ids.get(&service_name).unwrap();
 
     // Wait for container to be healthy
-    builder.wait_for_container(&container_id).await.unwrap();
+    builder.wait_for_container(container_id).await.unwrap();
 
     // Verify healthcheck configuration
     let inspect = builder

src/tests/docker_file.rs

@@ -65,7 +65,7 @@ async fn test_dockerfile_parsing() {
     }
 
     // Verify EXPOSE commands
-    let expected_ports = vec![30333, 9933, 9944, 9615];
+    let expected_ports = [30333, 9933, 9944, 9615];
     for (i, port) in expected_ports.iter().enumerate() {
         match &commands[i + 5] {
             DockerCommand::Expose { port: p, protocol } => {
@@ -604,7 +604,7 @@ async fn test_expose_multiple_ports() {
     let content = "EXPOSE 30333 9933 9944 9615";
     let config = DockerfileParser::parse(content).unwrap();
 
-    let expected_ports = vec![30333, 9933, 9944, 9615];
+    let expected_ports = [30333, 9933, 9944, 9615];
     assert_eq!(config.commands.len(), expected_ports.len());
 
     for (i, port) in expected_ports.iter().enumerate() {
@@ -622,7 +622,7 @@ async fn test_expose_multiple_ports() {
     let config = DockerfileParser::parse(content).unwrap();
     assert_eq!(config.commands.len(), 4);
 
-    let expected = vec![
+    let expected = [
         (80, Some("tcp")),
         (443, None),
         (8080, Some("udp")),
@@ -648,7 +648,7 @@ async fn test_tangle_expose_format() {
     let content = "EXPOSE 30333 9933 9944 9615";
     let config = DockerfileParser::parse(content).unwrap();
 
-    let expected_ports = vec![30333, 9933, 9944, 9615];
+    let expected_ports = [30333, 9933, 9944, 9615];
     assert_eq!(config.commands.len(), expected_ports.len());
 
     for (i, expected_port) in expected_ports.iter().enumerate() {