From 861034dc2f32d4900f6a2b9414065344e1a02857 Mon Sep 17 00:00:00 2001
From: mhead <mtrxhead@protonmail.com>
Date: Tue, 2 Jul 2024 19:39:18 +0530
Subject: [PATCH 1/4] Refactor suffix mapping to use HashMap a*.jpg=01;32nd
 HashSet for case sensitivity handling

---
 src/lib.rs | 153 +++++++++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 132 insertions(+), 21 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 1032dc1..899b51a 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -27,7 +27,7 @@
 mod fs;
 pub mod style;
 
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::env;
 use std::ffi::OsString;
 use std::fs::{DirEntry, FileType, Metadata};
@@ -220,6 +220,33 @@ impl Colorable for DirEntry {
 
 const LS_COLORS_DEFAULT: &str = "rs=0:lc=\x1b[:rc=m:cl=\x1b[K:ex=01;32:sg=30;43:su=37;41:di=01;34:st=37;44:ow=34;42:tw=30;42:ln=01;36:bd=01;33:cd=01;33:do=01;35:pi=33:so=01;35:";
 
+#[derive(Default, Debug, Clone)]
+struct SuffixMapping {
+    mappings: HashMap<FileNameSuffix, Option<Style>>,
+    case_sensitive: HashSet<FileNameSuffix>,
+}
+
+impl SuffixMapping {
+    fn push(&mut self, suffix: FileNameSuffix, style: Option<Style>) {
+        let normalized_suffix = suffix.to_ascii_lowercase();
+        // decides whether new mapping and it's varaints should be treated as case-sensitive
+        let is_case_sensitive = self.mappings.iter().any(|(m_suffix, m_style)| {
+            //any entry that are not exactly same as the new suffix
+            (*m_suffix != suffix)
+                // but is the same string with different letter case
+                && (normalized_suffix == m_suffix.to_ascii_lowercase())
+                // and it's mapped to a different style other than the new style 
+                && (style != *m_style)
+        });
+        if is_case_sensitive {
+            self.case_sensitive.insert(normalized_suffix);
+        } else {
+            self.case_sensitive.remove(&normalized_suffix);
+        }
+        self.mappings.insert(suffix, style);
+    }
+}
+
 /// Holds information about how different file system entries should be colorized / styled.
 #[derive(Debug, Clone)]
 pub struct LsColors {
@@ -228,10 +255,7 @@ pub struct LsColors {
     /// Whether Indicator::RegularFile falls back to Indicator::Normal
     /// (see <https://github.com/sharkdp/lscolors/issues/48#issuecomment-1582830387>)
     file_normal_fallback: bool,
-
-    // Note: you might expect to see a `HashMap` for `suffix_mapping` as well, but we need to
-    // preserve the exact order of the mapping in order to be consistent with `ls`.
-    suffix_mapping: Vec<(FileNameSuffix, Option<Style>)>,
+    suffix_mapping: SuffixMapping,
 }
 
 impl Default for LsColors {
@@ -250,7 +274,7 @@ impl LsColors {
         LsColors {
             indicator_mapping: HashMap::new(),
             file_normal_fallback: true,
-            suffix_mapping: vec![],
+            suffix_mapping: SuffixMapping::default(),
         }
     }
 
@@ -278,8 +302,7 @@ impl LsColors {
             if let Some([entry, ansi_style]) = parts.get(0..2) {
                 let style = Style::from_ansi_sequence(ansi_style);
                 if let Some(suffix) = entry.strip_prefix('*') {
-                    self.suffix_mapping
-                        .push((suffix.to_string().to_ascii_lowercase(), style));
+                    self.suffix_mapping.push(suffix.to_string(), style);
                 } else if let Some(indicator) = Indicator::from(entry) {
                     if let Some(style) = style {
                         self.indicator_mapping.insert(indicator, style);
@@ -421,21 +444,30 @@ impl LsColors {
 
     /// Get the ANSI style for a string. This does not have to be a valid filepath.
     pub fn style_for_str(&self, file_str: &str) -> Option<&Style> {
-        // make input lowercase for compatibility reasons
-        let input = file_str.to_ascii_lowercase();
-        let input_ref = input.as_str();
-
-        // We need to traverse LS_COLORS from back to front
-        // to be consistent with `ls`:
-        for (suffix, style) in self.suffix_mapping.iter().rev() {
-            // Note: For some reason, 'ends_with' is much
-            // slower if we omit `.as_str()` here:
-            if input_ref.ends_with(suffix.as_str()) {
-                return style.as_ref();
+        let file_str_normalized = file_str.to_ascii_lowercase();
+        let mut last_matched_style = None;
+        let mut last_matched_len = 0;
+        for (suffix, style) in self.suffix_mapping.mappings.iter() {
+            let suffix_len = suffix.len();
+            if last_matched_len > suffix_len {
+                continue;
+            }
+            let suffix_normalized = suffix.to_ascii_lowercase();
+            let case_sensitive = self
+                .suffix_mapping
+                .case_sensitive
+                .contains(&suffix_normalized);
+            if case_sensitive {
+                if file_str.ends_with(suffix) {
+                    last_matched_len = suffix_len;
+                    last_matched_style = style.as_ref();
+                }
+            } else if file_str_normalized.ends_with(&suffix_normalized) {
+                last_matched_len = suffix_len;
+                last_matched_style = style.as_ref();
             }
         }
-        // It was not found
-        None
+        last_matched_style
     }
 
     /// Get the ANSI style for a path, given the corresponding `Metadata` struct.
@@ -842,4 +874,83 @@ mod tests {
         let style = lscolors.style_for_path(&tmp_file_path);
         assert_eq!(None, style);
     }
+    #[test]
+    fn file_suffix_case() {
+        let assert_bold_fg_magenta = |style: Option<&Style>| {
+            Some(Color::Magenta) == style.and_then(|v| v.foreground)
+                && matches!(style,Some(sty) if sty.font_style.bold )
+        };
+        let assert_bold_fg_green = |style: Option<&Style>| {
+            Some(Color::Green) == style.and_then(|v| v.foreground)
+                && matches!(style,Some(sty) if sty.font_style.bold )
+        };
+
+        // *.jpg is specified only once so any suffix that has .jpg should match
+        // without caring about the letter case
+        let lscolors = LsColors::from_string("*.jpg=01;35:*.Z=01;31");
+        let lowercase_suffix = lscolors.style_for_str("img1.jpg");
+        assert!(assert_bold_fg_magenta(lowercase_suffix));
+        let uppercase_suffix = lscolors.style_for_str("img1.JPG");
+        assert!(assert_bold_fg_magenta(uppercase_suffix));
+        let mixedcase_suffix = lscolors.style_for_str("img1.JpG");
+        assert!(assert_bold_fg_magenta(mixedcase_suffix));
+
+        // *.jpg is specified more than once with different cases and style, so
+        // case should matter here
+        let lscolors = LsColors::from_string("*.jpg=01;35:*.JPG=01;32");
+        let lowercase_suffix = lscolors.style_for_str("img1.jpg");
+        assert!(assert_bold_fg_magenta(lowercase_suffix));
+        let uppercase_suffix = lscolors.style_for_str("img1.JPG");
+        assert!(assert_bold_fg_green(uppercase_suffix));
+        let mixedcase_suffix = lscolors.style_for_str("img1.JpG");
+        assert!(mixedcase_suffix.is_none());
+
+        // *.jpg is specified more than once with different cases but style is same, so
+        // case can ignored
+        let lscolors = LsColors::from_string("*.jpg=01;35:*.JPG=01;35");
+        let lowercase_suffix = lscolors.style_for_str("img1.jpg");
+        assert!(assert_bold_fg_magenta(lowercase_suffix));
+        let uppercase_suffix = lscolors.style_for_str("img1.JPG");
+        assert!(assert_bold_fg_magenta(uppercase_suffix));
+        let mixedcase_suffix = lscolors.style_for_str("img1.JpG");
+        assert!(assert_bold_fg_magenta(mixedcase_suffix));
+
+        // last *.jpg gets more priority resulting in same style across
+        // different cases specified, so case can ignored
+        let lscolors = LsColors::from_string("*.jpg=01;32:*.jpg=01;35:*.JPG=01;35");
+        let lowercase_suffix = lscolors.style_for_str("img1.jpg");
+        assert!(assert_bold_fg_magenta(lowercase_suffix));
+        let uppercase_suffix = lscolors.style_for_str("img1.JPG");
+        assert!(assert_bold_fg_magenta(uppercase_suffix));
+        let mixedcase_suffix = lscolors.style_for_str("img1.JpG");
+        assert!(assert_bold_fg_magenta(mixedcase_suffix));
+
+        // same as above with different combinations
+        let lscolors = LsColors::from_string("*.jpg=01;32:*.jpg=01;35:*.JPG=01;32:*.jpg=01;32");
+        let lowercase_suffix = lscolors.style_for_str("img1.jpg");
+        assert!(assert_bold_fg_green(lowercase_suffix));
+        let uppercase_suffix = lscolors.style_for_str("img1.JPG");
+        assert!(assert_bold_fg_green(uppercase_suffix));
+        let mixedcase_suffix = lscolors.style_for_str("img1.JpG");
+        assert!(assert_bold_fg_green(mixedcase_suffix));
+
+        // last *.jpg gets more priority resulting in different style across
+        // different cases specified, so case matters
+        let lscolors = LsColors::from_string("*.jpg=01;32:*.jpg=01;35:*.JPG=01;32");
+        let lowercase_suffix = lscolors.style_for_str("img1.jpg");
+        assert!(assert_bold_fg_magenta(lowercase_suffix));
+        let uppercase_suffix = lscolors.style_for_str("img1.JPG");
+        assert!(assert_bold_fg_green(uppercase_suffix));
+        let mixedcase_suffix = lscolors.style_for_str("img1.JpG");
+        assert!(mixedcase_suffix.is_none());
+
+        // same as above with different combinations
+        let lscolors = LsColors::from_string("*.jpg=01;32:*.jpg=01;35:*.JPG=01;35:*.jpg=01;32");
+        let lowercase_suffix = lscolors.style_for_str("img1.jpg");
+        assert!(assert_bold_fg_green(lowercase_suffix));
+        let uppercase_suffix = lscolors.style_for_str("img1.JPG");
+        assert!(assert_bold_fg_magenta(uppercase_suffix));
+        let mixedcase_suffix = lscolors.style_for_str("img1.JpG");
+        assert!(mixedcase_suffix.is_none());
+    }
 }

From 6c458e78a5bdf92aa764b24b6995c715e4166c4f Mon Sep 17 00:00:00 2001
From: mhead <mtrxhead@protonmail.com>
Date: Wed, 3 Jul 2024 23:41:35 +0530
Subject: [PATCH 2/4] suffix mapping: reduced complexity; fix regression of
 suffix overriding

---
 src/lib.rs | 135 +++++++++++++++++++++++++++++++++++------------------
 1 file changed, 90 insertions(+), 45 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 899b51a..f759717 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -27,7 +27,7 @@
 mod fs;
 pub mod style;
 
-use std::collections::{HashMap, HashSet};
+use std::collections::HashMap;
 use std::env;
 use std::ffi::OsString;
 use std::fs::{DirEntry, FileType, Metadata};
@@ -143,6 +143,7 @@ impl Indicator {
 }
 
 type FileNameSuffix = String;
+type Priority = usize;
 
 /// Iterator over the path components with their respective style.
 pub struct StyledComponents<'a> {
@@ -221,29 +222,30 @@ impl Colorable for DirEntry {
 const LS_COLORS_DEFAULT: &str = "rs=0:lc=\x1b[:rc=m:cl=\x1b[K:ex=01;32:sg=30;43:su=37;41:di=01;34:st=37;44:ow=34;42:tw=30;42:ln=01;36:bd=01;33:cd=01;33:do=01;35:pi=33:so=01;35:";
 
 #[derive(Default, Debug, Clone)]
-struct SuffixMapping {
-    mappings: HashMap<FileNameSuffix, Option<Style>>,
-    case_sensitive: HashSet<FileNameSuffix>,
+struct SuffixMappingEntry {
+    /// Keys are non-normalized suffixes(variants of the suffix), and values are
+    /// tuples containing an style and their priority.
+    /// We need to store the priority (the index of the entry in the env) here
+    /// because ls has an overriding mechanism. For example,
+    /// *.gz=01;33:*.tar.gz=01;31: and *.tar.gz=01;31:*.gz=01;33: are not the
+    /// same.
+    variants: HashMap<FileNameSuffix, (Option<Style>, Priority)>,
+    // whether the variants are case sensitive or not
+    case_sensitive: bool,
 }
 
-impl SuffixMapping {
-    fn push(&mut self, suffix: FileNameSuffix, style: Option<Style>) {
-        let normalized_suffix = suffix.to_ascii_lowercase();
-        // decides whether new mapping and it's varaints should be treated as case-sensitive
-        let is_case_sensitive = self.mappings.iter().any(|(m_suffix, m_style)| {
-            //any entry that are not exactly same as the new suffix
-            (*m_suffix != suffix)
-                // but is the same string with different letter case
-                && (normalized_suffix == m_suffix.to_ascii_lowercase())
-                // and it's mapped to a different style other than the new style 
-                && (style != *m_style)
+impl SuffixMappingEntry {
+    fn push(&mut self, suffix: FileNameSuffix, style: Option<Style>, priority: Priority) {
+        // Determines if the new mapping and its variants should be treated as
+        // case-sensitive.
+        let is_case_sensitive = self.variants.iter().any(|(v_suffix, (v_style, _))| {
+            //Any entry that are not exactly same as the new suffix,
+            (*v_suffix != suffix)
+                // and it is mapped to a different style other than the new style.
+                && (style != *v_style)
         });
-        if is_case_sensitive {
-            self.case_sensitive.insert(normalized_suffix);
-        } else {
-            self.case_sensitive.remove(&normalized_suffix);
-        }
-        self.mappings.insert(suffix, style);
+        self.case_sensitive = is_case_sensitive;
+        self.variants.insert(suffix, (style, priority));
     }
 }
 
@@ -255,7 +257,7 @@ pub struct LsColors {
     /// Whether Indicator::RegularFile falls back to Indicator::Normal
     /// (see <https://github.com/sharkdp/lscolors/issues/48#issuecomment-1582830387>)
     file_normal_fallback: bool,
-    suffix_mapping: SuffixMapping,
+    suffix_mapping: HashMap<FileNameSuffix, SuffixMappingEntry>,
 }
 
 impl Default for LsColors {
@@ -274,7 +276,7 @@ impl LsColors {
         LsColors {
             indicator_mapping: HashMap::new(),
             file_normal_fallback: true,
-            suffix_mapping: SuffixMapping::default(),
+            suffix_mapping: HashMap::new(),
         }
     }
 
@@ -296,13 +298,12 @@ impl LsColors {
     }
 
     fn add_from_string(&mut self, input: &str) {
-        for entry in input.split(':') {
+        for (idx, entry) in input.split(':').enumerate() {
             let parts: Vec<_> = entry.split('=').collect();
-
             if let Some([entry, ansi_style]) = parts.get(0..2) {
                 let style = Style::from_ansi_sequence(ansi_style);
                 if let Some(suffix) = entry.strip_prefix('*') {
-                    self.suffix_mapping.push(suffix.to_string(), style);
+                    self.add_suffix_entry(suffix.to_string(), style, idx);
                 } else if let Some(indicator) = Indicator::from(entry) {
                     if let Some(style) = style {
                         self.indicator_mapping.insert(indicator, style);
@@ -317,6 +318,18 @@ impl LsColors {
         }
     }
 
+    fn add_suffix_entry(
+        &mut self,
+        suffix: FileNameSuffix,
+        style: Option<Style>,
+        priority: Priority,
+    ) {
+        // We use `to_ascii_lowercase` here to normalize suffix to use as keys.
+        let suffix_normalized = suffix.to_ascii_lowercase();
+        let suffix_mapping_entry = self.suffix_mapping.entry(suffix_normalized).or_default();
+        suffix_mapping_entry.push(suffix, style, priority);
+    }
+
     /// Get the ANSI style for a given path.
     ///
     /// *Note:* this function calls `Path::symlink_metadata` internally. If you already happen to
@@ -444,27 +457,42 @@ impl LsColors {
 
     /// Get the ANSI style for a string. This does not have to be a valid filepath.
     pub fn style_for_str(&self, file_str: &str) -> Option<&Style> {
+        let file_str_len = file_str.len();
         let file_str_normalized = file_str.to_ascii_lowercase();
-        let mut last_matched_style = None;
-        let mut last_matched_len = 0;
-        for (suffix, style) in self.suffix_mapping.mappings.iter() {
-            let suffix_len = suffix.len();
-            if last_matched_len > suffix_len {
-                continue;
-            }
-            let suffix_normalized = suffix.to_ascii_lowercase();
-            let case_sensitive = self
-                .suffix_mapping
-                .case_sensitive
-                .contains(&suffix_normalized);
-            if case_sensitive {
-                if file_str.ends_with(suffix) {
-                    last_matched_len = suffix_len;
-                    last_matched_style = style.as_ref();
+        let mut last_matched_style: Option<&Style> = None;
+        let mut last_matched_priority = 0;
+        for (suffix_normalized, suffix_mapping_entry) in self.suffix_mapping.iter() {
+            // check if there is an entry for the suffix
+            if file_str_normalized.ends_with(suffix_normalized) {
+                // check whether the entry is marked as case sensitive or not
+                if suffix_mapping_entry.case_sensitive {
+                    // then we need to check whether there is a suffix that exactly
+                    // matches in different variants.
+                    // we could do that by finding the suffix variant that appears in the filename,
+                    let file_str_suffix = &file_str[file_str_len - suffix_normalized.len()..];
+                    // and use that to find the corresponding style.
+                    if let Some((style, priority)) =
+                        suffix_mapping_entry.variants.get(file_str_suffix)
+                    {
+                        if *priority >= last_matched_priority {
+                            last_matched_style = style.as_ref();
+                            last_matched_priority = *priority;
+                        }
+                    }
+                } else {
+                    // case doesn't matter, that means every variant has
+                    // the same style so we could just take the first one.
+                    let (style, priority) = suffix_mapping_entry
+                        .variants
+                        .values()
+                        .next()
+                        // it okay to unwrap here, because there should exist atleast one variant.
+                        .unwrap();
+                    if *priority >= last_matched_priority {
+                        last_matched_style = style.as_ref();
+                        last_matched_priority = *priority;
+                    }
                 }
-            } else if file_str_normalized.ends_with(&suffix_normalized) {
-                last_matched_len = suffix_len;
-                last_matched_style = style.as_ref();
             }
         }
         last_matched_style
@@ -595,17 +623,34 @@ mod tests {
     fn style_for_path_uses_correct_ordering() {
         let lscolors = LsColors::from_string("*.foo=01;35:*README.foo=33;44");
 
+        // dummy.foo matches to *.foo without getting overriden.
         let style_foo = lscolors.style_for_path("some/folder/dummy.foo").unwrap();
         assert_eq!(FontStyle::bold(), style_foo.font_style);
         assert_eq!(Some(Color::Magenta), style_foo.foreground);
         assert_eq!(None, style_foo.background);
 
+        // README.foo matches to *README.foo by overriding *.foo
         let style_readme = lscolors
             .style_for_path("some/other/folder/README.foo")
             .unwrap();
         assert_eq!(FontStyle::default(), style_readme.font_style);
         assert_eq!(Some(Color::Yellow), style_readme.foreground);
         assert_eq!(Some(Color::Blue), style_readme.background);
+
+        let lscolors = LsColors::from_string("*README.foo=33;44:*.foo=01;35");
+
+        let style_foo = lscolors.style_for_path("some/folder/dummy.foo").unwrap();
+        assert_eq!(FontStyle::bold(), style_foo.font_style);
+        assert_eq!(Some(Color::Magenta), style_foo.foreground);
+        assert_eq!(None, style_foo.background);
+
+        // README.foo matches to *.foo because *.foo overrides *README.foo
+        let style_readme = lscolors
+            .style_for_path("some/other/folder/README.foo")
+            .unwrap();
+        assert_eq!(FontStyle::bold(), style_readme.font_style);
+        assert_eq!(Some(Color::Magenta), style_readme.foreground);
+        assert_eq!(None, style_readme.background);
     }
 
     #[test]

From 6f8a7a3753af9cf5b62259cef71993d385805726 Mon Sep 17 00:00:00 2001
From: mhead <mtrxhead@protonmail.com>
Date: Thu, 4 Jul 2024 00:11:46 +0530
Subject: [PATCH 3/4] use max priority suffix  when case doesn't matter

---
 src/lib.rs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index f759717..bad5dbd 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -480,12 +480,11 @@ impl LsColors {
                         }
                     }
                 } else {
-                    // case doesn't matter, that means every variant has
-                    // the same style so we could just take the first one.
+                    // case doesn't matter, but we need select the one with the biggest priority.
                     let (style, priority) = suffix_mapping_entry
                         .variants
                         .values()
-                        .next()
+                        .max_by(|x, y| x.1.cmp(&y.1))
                         // it okay to unwrap here, because there should exist atleast one variant.
                         .unwrap();
                     if *priority >= last_matched_priority {

From 73fb17b72154d47f04f5b42d43f1e8fc8bc3e2fa Mon Sep 17 00:00:00 2001
From: mhead <mtrxhead@protonmail.com>
Date: Thu, 4 Jul 2024 16:39:55 +0530
Subject: [PATCH 4/4] suffix mapping reduced complexity

---
 src/lib.rs | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index bad5dbd..0fc4e3a 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -235,17 +235,12 @@ struct SuffixMappingEntry {
 }
 
 impl SuffixMappingEntry {
-    fn push(&mut self, suffix: FileNameSuffix, style: Option<Style>, priority: Priority) {
-        // Determines if the new mapping and its variants should be treated as
-        // case-sensitive.
-        let is_case_sensitive = self.variants.iter().any(|(v_suffix, (v_style, _))| {
-            //Any entry that are not exactly same as the new suffix,
-            (*v_suffix != suffix)
-                // and it is mapped to a different style other than the new style.
-                && (style != *v_style)
-        });
-        self.case_sensitive = is_case_sensitive;
-        self.variants.insert(suffix, (style, priority));
+    fn init_case_sensitivity(&mut self) {
+        // we treat an entry as case-insensitive when all the styles are equal
+        let mut iter = self.variants.values();
+        // it's okay to unwrap here because there must be atleast element present
+        let (ref_style, _) = iter.next().unwrap();
+        self.case_sensitive = iter.any(|(style, _)| style != ref_style);
     }
 }
 
@@ -316,6 +311,9 @@ impl LsColors {
                 }
             }
         }
+        self.suffix_mapping
+            .values_mut()
+            .for_each(|entry| entry.init_case_sensitivity());
     }
 
     fn add_suffix_entry(
@@ -327,7 +325,9 @@ impl LsColors {
         // We use `to_ascii_lowercase` here to normalize suffix to use as keys.
         let suffix_normalized = suffix.to_ascii_lowercase();
         let suffix_mapping_entry = self.suffix_mapping.entry(suffix_normalized).or_default();
-        suffix_mapping_entry.push(suffix, style, priority);
+        suffix_mapping_entry
+            .variants
+            .insert(suffix, (style, priority));
     }
 
     /// Get the ANSI style for a given path.