Fix code formatting issues detected by rustfmt

Author: erik-balfe

src/display/format.rs

@@ -22,7 +22,7 @@ fn format_single_entry(
     entry: &DirectoryEntry,
     prefix: &str,
     is_last: bool,
-    _config: &DisplayConfig,  // Renamed to _config to avoid unused warning
+    _config: &DisplayConfig, // Renamed to _config to avoid unused warning
 ) -> String {
     let connector = if is_last { "└── " } else { "├── " };
 

src/display/state.rs

@@ -140,11 +140,18 @@ impl<'a> DisplayState<'a> {
             self.depth
         );
 
-        let connector = if ctx.is_last { "└── " } else { "├── " };
+        let connector = if ctx.is_last {
+            "└── "
+        } else {
+            "├── "
+        };
         let mut output = format!("{}{}{}", ctx.prefix, connector, entry.name);
 
         if entry.is_gitignored && entry.is_dir {
-            output.push_str(&format!(" {} [folded: system]\n", super::utils::format_metadata(entry)));
+            output.push_str(&format!(
+                " {} [folded: system]\n",
+                super::utils::format_metadata(entry)
+            ));
         } else {
             output.push_str(&format!(" {}\n", super::utils::format_metadata(entry)));
         }
@@ -168,12 +175,17 @@ impl<'a> DisplayState<'a> {
         );
 
         if items.is_empty() || self.lines_remaining == 0 {
-            debug!("Early return: empty={}, no_lines={}", items.is_empty(), self.lines_remaining == 0);
+            debug!(
+                "Early return: empty={}, no_lines={}",
+                items.is_empty(),
+                self.lines_remaining == 0
+            );
             return;
         }
 
         let budget = self.calculate_level_budget(items.len());
-        let section = self.calculate_display_section(items.len(), budget.min(self.config.dir_limit));
+        let section =
+            self.calculate_display_section(items.len(), budget.min(self.config.dir_limit));
 
         debug!(
             "Display plan: budget={}, head={}, tail={}, hidden={}",
@@ -218,7 +230,10 @@ impl<'a> DisplayState<'a> {
 
         // Show hidden items message if needed
         if section.total_hidden > 0 && self.lines_remaining > 0 {
-            debug!("Adding hidden items indicator: {} items", section.total_hidden);
+            debug!(
+                "Adding hidden items indicator: {} items",
+                section.total_hidden
+            );
             self.output.push_str(&format!(
                 "{}├── ... {} item{} hidden ...\n",
                 prefix,

src/display/tests.rs

@@ -95,7 +95,8 @@ fn test_head_tail_pattern() {
 
     println!("Output:\n{}", state.output);
 
-    let visible_lines: Vec<_> = state.output
+    let visible_lines: Vec<_> = state
+        .output
         .lines()
         .filter(|l| !l.contains("items hidden"))
         .collect();
@@ -154,7 +155,8 @@ fn test_nested_directory_budget() {
             let dir_content = extract_directory_content(&state.output, dir);
             assert!(
                 !dir_content.is_empty(),
-                "Directory {} should show some content", dir
+                "Directory {} should show some content",
+                dir
             );
         }
     }
@@ -193,13 +195,18 @@ fn test_real_project_structure() {
         let mut state = DisplayState::new(config.max_lines, &config);
         state.show_items(&src_contents, "");
 
-        println!("\nTesting with max_lines = {}:\n{}", max_lines, state.output);
+        println!(
+            "\nTesting with max_lines = {}:\n{}",
+            max_lines, state.output
+        );
 
         // Verify line limit
         let line_count = state.output.lines().count();
         assert!(
             line_count <= max_lines,
-            "Output exceeded {} lines (got {})", max_lines, line_count
+            "Output exceeded {} lines (got {})",
+            max_lines,
+            line_count
         );
 
         // Verify content visibility
@@ -265,30 +272,42 @@ fn test_expanded_project_structure() {
 
     // Test cases with expected content checks
     let test_cases = vec![
-        (5, ExpectedContent {
-            should_show_src: false,
-            should_show_src_contents: false,
-            min_visible_items: 2,
-            should_show_head_tail: false,
-        }),
-        (10, ExpectedContent {
-            should_show_src: true,
-            should_show_src_contents: true,
-            min_visible_items: 4,
-            should_show_head_tail: true,
-        }),
-        (15, ExpectedContent {
-            should_show_src: true,
-            should_show_src_contents: true,
-            min_visible_items: 6,
-            should_show_head_tail: true,
-        }),
-        (20, ExpectedContent {
-            should_show_src: true,
-            should_show_src_contents: true,
-            min_visible_items: 8,
-            should_show_head_tail: true,
-        }),
+        (
+            5,
+            ExpectedContent {
+                should_show_src: false,
+                should_show_src_contents: false,
+                min_visible_items: 2,
+                should_show_head_tail: false,
+            },
+        ),
+        (
+            10,
+            ExpectedContent {
+                should_show_src: true,
+                should_show_src_contents: true,
+                min_visible_items: 4,
+                should_show_head_tail: true,
+            },
+        ),
+        (
+            15,
+            ExpectedContent {
+                should_show_src: true,
+                should_show_src_contents: true,
+                min_visible_items: 6,
+                should_show_head_tail: true,
+            },
+        ),
+        (
+            20,
+            ExpectedContent {
+                should_show_src: true,
+                should_show_src_contents: true,
+                min_visible_items: 8,
+                should_show_head_tail: true,
+            },
+        ),
     ];
 
     for (max_lines, expected) in test_cases {
@@ -325,30 +344,38 @@ fn test_expanded_project_structure() {
         }
 
         // Count visible items (non-hidden lines)
-        let visible_items = output.lines()
+        let visible_items = output
+            .lines()
             .filter(|l| !l.contains("items hidden"))
             .count();
 
         println!("Visible items: {}", visible_items);
 
         // Basic structure checks based on available space
         if expected.should_show_src {
-            assert!(output.contains("src"), "Should show src directory with {} lines", max_lines);
+            assert!(
+                output.contains("src"),
+                "Should show src directory with {} lines",
+                max_lines
+            );
         }
 
         if expected.should_show_src_contents {
             // For src directory
             assert!(
                 output.contains("display") || output.contains("main.rs"),
-                "Should show some src directory contents with {} lines", max_lines
+                "Should show some src directory contents with {} lines",
+                max_lines
             );
 
             // Verify head/tail pattern if expected
             if expected.should_show_head_tail {
                 let src_section = output
                     .lines()
                     .skip_while(|l| !l.contains("src"))
-                    .take_while(|l| l.starts_with("│   ") || l.starts_with("├──") || l.starts_with("└──"))
+                    .take_while(|l| {
+                        l.starts_with("│   ") || l.starts_with("├──") || l.starts_with("└──")
+                    })
                     .collect::<Vec<_>>()
                     .join("\n");
 
@@ -408,29 +435,20 @@ fn test_extended_head_tail_pattern() {
     println!("Output:\n{}", state.output);
 
     let output = state.output;
-    
+
     println!("\nContent analysis:");
     for line in output.lines() {
         println!("{}", line);
     }
 
     // Should show directory
-    assert!(
-        output.contains("src"),
-        "Should show src directory"
-    );
-    
+    assert!(output.contains("src"), "Should show src directory");
+
     // Should show some files from beginning
-    assert!(
-        output.contains("file1.rs"),
-        "Should show first file"
-    );
+    assert!(output.contains("file1.rs"), "Should show first file");
 
     // Should show hidden items indicator
-    assert!(
-        output.contains("items hidden"),
-        "Should show hidden items"
-    );
+    assert!(output.contains("items hidden"), "Should show hidden items");
 
     // Line limit verification
     assert!(

src/log_macros.rs

@@ -1,4 +1,3 @@
-
 #[cfg(debug_assertions)]
 #[macro_export]
 macro_rules! debug_log {
@@ -39,4 +38,4 @@ macro_rules! info_log {
 #[macro_export]
 macro_rules! info_log {
     ($($arg:tt)*) => {};
-}
+}

src/scanner.rs

@@ -15,7 +15,7 @@ pub fn scan_directory(
         .file_name()
         .map(|n| n.to_string_lossy().to_string())
         .unwrap_or_else(|| root.to_string_lossy().to_string());
-    
+
     // Early return for non-directories or when max_depth is 0
     if !root_metadata.is_dir() || max_depth == 0 {
         return Ok(DirectoryEntry {
@@ -32,7 +32,7 @@ pub fn scan_directory(
             is_gitignored: gitignore.is_ignored(root),
         });
     }
-    
+
     // Initialize the root entry with temporary metadata
     // We'll calculate accurate size and file count as we traverse
     let mut root_entry = DirectoryEntry {
@@ -48,13 +48,13 @@ pub fn scan_directory(
         children: Vec::new(),
         is_gitignored: gitignore.is_ignored(root),
     };
-    
+
     // For gitignored directories, provide basic metadata without deep traversal
     if root_entry.is_gitignored {
         // Do a quick scan to get file counts without going deep
         let mut file_count = 0;
         let mut total_size = 0;
-        
+
         if let Ok(entries) = fs::read_dir(root) {
             for entry in entries.flatten() {
                 if let Ok(metadata) = entry.metadata() {
@@ -69,29 +69,29 @@ pub fn scan_directory(
                 }
             }
         }
-        
+
         // If total size is still 0 but we know it's a directory, use a placeholder size
         if total_size == 0 && file_count > 0 {
             total_size = 1024 * 1024; // 1MB placeholder
         }
-        
+
         // Update the metadata
         root_entry.metadata.files_count = file_count;
         root_entry.metadata.size = total_size;
-        
+
         return Ok(root_entry);
     }
-    
+
     let mut entries = Vec::new();
-    
+
     // Read the directory and process entries
     for dir_entry in fs::read_dir(root)? {
         let dir_entry = dir_entry?;
         let path = dir_entry.path();
         let metadata = dir_entry.metadata()?;
         let name = dir_entry.file_name().to_string_lossy().to_string();
         let is_gitignored = gitignore.is_ignored(&path);
-        
+
         if metadata.is_dir() {
             // Recursively scan subdirectories if depth allows
             if max_depth > 1 {
@@ -121,15 +121,15 @@ pub fn scan_directory(
                     children: Vec::new(),
                     is_gitignored,
                 });
-                
+
                 // Update parent size
                 root_entry.metadata.size += metadata.len();
             }
         } else {
             // For files, update parent metadata and add to entries
             root_entry.metadata.files_count += 1;
             root_entry.metadata.size += metadata.len();
-            
+
             entries.push(DirectoryEntry {
                 path,
                 name,
@@ -145,9 +145,9 @@ pub fn scan_directory(
             });
         }
     }
-    
+
     // Set the children
     root_entry.children = entries;
-    
+
     Ok(root_entry)
 }