fix cargo fmt issue

Author: bgreenwell

src/app.rs

@@ -1,9 +1,9 @@
 //! Defines the command-line interface for the lstr application.
 
+use crate::sort;
 use clap::{Parser, Subcommand, ValueEnum};
 use std::fmt;
 use std::path::PathBuf;
-use crate::sort;
 
 /// A blazingly fast, minimalist directory tree viewer, written in Rust.
 #[derive(Parser, Debug)]

src/sort.rs

@@ -58,7 +58,7 @@ pub struct SortOptions {
 ///
 /// ```rust
 /// use lstr::sort::{sort_entries, SortOptions, SortType};
-/// 
+///
 /// let mut entries = vec![/* ... */];
 /// let options = SortOptions {
 ///     sort_type: SortType::Name,
@@ -84,7 +84,7 @@ fn compare_entries(a: &DirEntry, b: &DirEntry, options: &SortOptions) -> Orderin
     let b_is_dir = b.file_type().map(|ft| ft.is_dir()).unwrap_or(false);
     let a_is_dotfile = is_dotfile(a);
     let b_is_dotfile = is_dotfile(b);
-    
+
     // Handle dotfiles-first and directories-first sorting
     // Order: dotfolders → folders → dotfiles → files
     if options.dotfiles_first {
@@ -94,7 +94,7 @@ fn compare_entries(a: &DirEntry, b: &DirEntry, options: &SortOptions) -> Orderin
             (false, true, false, true) | // Both regular folders  
             (true, false, true, false) | // Both dotfiles
             (false, false, false, false) => {}, // Both regular files
-            
+
             // Different categories - apply priority order
             (true, true, _, _) => return Ordering::Less,   // a is dotfolder (highest priority)
             (_, _, true, true) => return Ordering::Greater, // b is dotfolder
@@ -111,7 +111,7 @@ fn compare_entries(a: &DirEntry, b: &DirEntry, options: &SortOptions) -> Orderin
             _ => {} // Both are dirs or both are files, continue
         }
     }
-    
+
     // Apply the primary sorting strategy
     match options.sort_type {
         SortType::Name => compare_by_name(a, b, options),
@@ -125,7 +125,7 @@ fn compare_entries(a: &DirEntry, b: &DirEntry, options: &SortOptions) -> Orderin
 fn compare_by_name(a: &DirEntry, b: &DirEntry, options: &SortOptions) -> Ordering {
     let name_a = a.file_name();
     let name_b = b.file_name();
-    
+
     if options.natural_sort {
         compare_natural(name_a, name_b)
     } else if options.case_sensitive {
@@ -147,10 +147,10 @@ fn compare_by_size(a: &DirEntry, b: &DirEntry) -> Ordering {
 fn compare_by_modified(a: &DirEntry, b: &DirEntry) -> Ordering {
     let modified_a = a.metadata().ok().and_then(|m| m.modified().ok());
     let modified_b = b.metadata().ok().and_then(|m| m.modified().ok());
-    
+
     match (modified_a, modified_b) {
         (Some(a_time), Some(b_time)) => a_time.cmp(&b_time),
-        (Some(_), None) => Ordering::Less,    // Files with known time sort first
+        (Some(_), None) => Ordering::Less, // Files with known time sort first
         (None, Some(_)) => Ordering::Greater,
         (None, None) => Ordering::Equal,
     }
@@ -160,13 +160,13 @@ fn compare_by_modified(a: &DirEntry, b: &DirEntry) -> Ordering {
 fn compare_by_extension(a: &DirEntry, b: &DirEntry, options: &SortOptions) -> Ordering {
     let ext_a = get_extension(a.file_name());
     let ext_b = get_extension(b.file_name());
-    
+
     let ext_cmp = if options.case_sensitive {
         ext_a.cmp(&ext_b)
     } else {
         compare_case_insensitive_str(&ext_a, &ext_b)
     };
-    
+
     // If extensions are equal, fall back to name comparison
     if ext_cmp == Ordering::Equal {
         compare_by_name(a, b, options)
@@ -180,7 +180,7 @@ fn compare_natural(a: &OsStr, b: &OsStr) -> Ordering {
     // Convert to strings for natural comparison
     let str_a = a.to_string_lossy();
     let str_b = b.to_string_lossy();
-    
+
     // Use the natord crate for natural ordering
     natord::compare(&str_a, &str_b)
 }
@@ -196,12 +196,12 @@ fn compare_case_insensitive(a: &OsStr, b: &OsStr) -> Ordering {
 fn compare_default_order(a: &OsStr, b: &OsStr) -> Ordering {
     let str_a = a.to_string_lossy();
     let str_b = b.to_string_lossy();
-    
+
     // Compare character by character using the specified priority
     for (char_a, char_b) in str_a.chars().zip(str_b.chars()) {
         let order_a = char_sort_priority(char_a);
         let order_b = char_sort_priority(char_b);
-        
+
         match order_a.cmp(&order_b) {
             Ordering::Equal => {
                 // Same priority category, compare within category
@@ -213,7 +213,7 @@ fn compare_default_order(a: &OsStr, b: &OsStr) -> Ordering {
             other => return other,
         }
     }
-    
+
     // If all compared characters are equal, compare by length
     str_a.len().cmp(&str_b.len())
 }
@@ -233,10 +233,7 @@ fn char_sort_priority(c: char) -> u8 {
 
 /// Checks if a directory entry is a dotfile/dotfolder (starts with '.').
 fn is_dotfile(entry: &DirEntry) -> bool {
-    entry
-        .file_name()
-        .to_string_lossy()
-        .starts_with('.')
+    entry.file_name().to_string_lossy().starts_with('.')
 }
 
 /// Performs case-insensitive comparison on regular strings.
@@ -271,7 +268,7 @@ mod tests {
         // Test case-insensitive comparison
         let name_a = OsStr::new("Apple");
         let name_b = OsStr::new("banana");
-        
+
         let result = compare_case_insensitive(name_a, name_b);
         assert_eq!(result, Ordering::Less); // "apple" < "banana"
     }
@@ -280,7 +277,7 @@ mod tests {
     fn test_case_sensitive_name_sorting() {
         let name_a = OsStr::new("Apple");
         let name_b = OsStr::new("banana");
-        
+
         let result = name_a.cmp(name_b);
         assert_eq!(result, Ordering::Less); // "Apple" < "banana" in ASCII
     }
@@ -289,22 +286,22 @@ mod tests {
     fn test_natural_sorting() {
         let name_a = OsStr::new("file1.txt");
         let name_b = OsStr::new("file10.txt");
-        
+
         let result = compare_natural(name_a, name_b);
         assert_eq!(result, Ordering::Less); // file1 < file10 naturally
-        
+
         // Test that regular lexicographic would give opposite result
         let lexicographic = name_a.cmp(name_b);
         assert_eq!(lexicographic, Ordering::Less); // Actually "file1.txt" < "file10.txt" lexicographically too
-        
+
         // Better test: "file2.txt" vs "file10.txt"
         let name_c = OsStr::new("file2.txt");
         let name_d = OsStr::new("file10.txt");
-        
+
         let natural_result = compare_natural(name_c, name_d);
         let lexicographic_result = name_c.cmp(name_d);
-        
-        assert_eq!(natural_result, Ordering::Less);  // file2 < file10 naturally
+
+        assert_eq!(natural_result, Ordering::Less); // file2 < file10 naturally
         assert_eq!(lexicographic_result, Ordering::Greater); // "file2.txt" > "file10.txt" lexicographically
     }
 
@@ -328,14 +325,14 @@ mod tests {
     }
 
     #[test]
-    fn test_reverse_sorting() {        
+    fn test_reverse_sorting() {
         let name_a = OsStr::new("apple");
         let name_b = OsStr::new("banana");
-        
+
         // Normal comparison: apple < banana
         let normal = compare_case_insensitive(name_a, name_b);
         assert_eq!(normal, Ordering::Less);
-        
+
         // With reverse option, the final result should be flipped
         // (This would be handled by the sort_entries function)
     }
@@ -346,7 +343,7 @@ mod tests {
         assert_eq!(compare_default_order(OsStr::new("1file"), OsStr::new("Afile")), Ordering::Less);
         assert_eq!(compare_default_order(OsStr::new("Afile"), OsStr::new("afile")), Ordering::Less);
         assert_eq!(compare_default_order(OsStr::new("afile"), OsStr::new("zfile")), Ordering::Less);
-        
+
         // Test within same category
         assert_eq!(compare_default_order(OsStr::new("1file"), OsStr::new("2file")), Ordering::Less);
         assert_eq!(compare_default_order(OsStr::new("Afile"), OsStr::new("Bfile")), Ordering::Less);
@@ -374,4 +371,4 @@ mod tests {
         assert!(!OsStr::new("visible.txt").to_string_lossy().starts_with('.'));
         assert!(!OsStr::new("normal").to_string_lossy().starts_with('.'));
     }
-}
+}

src/tui.rs

@@ -342,18 +342,15 @@ fn scan_directory(
 ) -> anyhow::Result<Vec<FileEntry>> {
     let mut builder = WalkBuilder::new(path);
     builder.hidden(!args.all).git_ignore(args.gitignore);
-    
+
     // Collect all DirEntry objects first, filtering out the root path
-    let mut dir_entries: Vec<_> = builder
-        .build()
-        .flatten()
-        .filter(|result| result.path() != path)
-        .collect();
-    
+    let mut dir_entries: Vec<_> =
+        builder.build().flatten().filter(|result| result.path() != path).collect();
+
     // Apply sorting to the DirEntry objects
     let sort_options = args.to_sort_options();
     sort::sort_entries(&mut dir_entries, &sort_options);
-    
+
     // Convert DirEntry objects to FileEntry objects
     let mut entries = Vec::new();
     for result in dir_entries {

src/view.rs

@@ -70,7 +70,6 @@ pub fn run(args: &ViewArgs, ls_colors: &LsColors) -> anyhow::Result<()> {
     sort::sort_entries(&mut entries, &sort_options);
 
     for entry in entries {
-
         let is_dir = entry.file_type().is_some_and(|ft| ft.is_dir());
         if args.dirs_only && !is_dir {
             continue;