Support case sensitivity in author filter in commit log

ArekPiekarz · Jul 12, 2022 · 043b3f8 · 043b3f8
1 parent 18773f0
commit 043b3f8
Show file tree

Hide file tree

Showing 6 changed files with 63 additions and 6 deletions.
diff --git a/src/commit_log_author_filter_entry.rs b/src/commit_log_author_filter_entry.rs
@@ -39,6 +39,7 @@ impl CommitLogAuthorFilterEntry
         let widget = guiElementProvider.get::<gtk::Entry>("Commit log author filter entry");
         let cssProvider = setupCss(&widget);
         connectWidget(&widget, sender.clone());
+        setupCaseSensitivityButton(guiElementProvider, sender.clone());
         setupRegexButton(guiElementProvider, sender);
         Self{widget, cssProvider}
     }
@@ -72,6 +73,13 @@ fn connectWidget(widget: &gtk::Entry, sender: Sender)
 
 }
 
+fn setupCaseSensitivityButton(guiElementProvider: &GuiElementProvider, sender: Sender)
+{
+    let button = guiElementProvider.get::<gtk::ToggleButton>("Commit log author filter case button");
+    button.connect_toggled(move |button|
+        sender.send((Source::CommitLogAuthorFilterCaseButton, Event::Toggled(button.is_active()))).unwrap());
+}
+
 fn setupRegexButton(guiElementProvider: &GuiElementProvider, sender: Sender)
 {
     let button = guiElementProvider.get::<gtk::ToggleButton>("Commit log author filter regex button");

diff --git a/src/commit_log_model_filter.rs b/src/commit_log_model_filter.rs
@@ -25,6 +25,7 @@ impl IEventHandler for CommitLogModelFilter
         match (source, event) {
             (_, Event::RefilterRequested)   => self.onRefilterRequested(),
             (_, Event::TextEntered(filter)) => self.onCommitAuthorFilterChanged(filter),
+            (Source::CommitLogAuthorFilterCaseButton,  Event::Toggled(shouldEnable)) => self.onCaseSensitivityToggled(*shouldEnable),
             (Source::CommitLogAuthorFilterRegexButton, Event::Toggled(shouldEnable)) => self.onRegexToggled(*shouldEnable),
             _ => handleUnknown(source, event)
         }
@@ -51,6 +52,12 @@ impl CommitLogModelFilter
         self.handleChangeResult(result);
     }
 
+    fn onCaseSensitivityToggled(&mut self, shouldEnable: bool)
+    {
+        let result = self.authorFilter.borrow_mut().setCaseSensitivityEnabled(shouldEnable);
+        self.handleChangeResult(result);
+    }
+
     fn onRegexToggled(&mut self, shouldEnable: bool)
     {
         let result = self.authorFilter.borrow_mut().setRegexEnabled(shouldEnable);

diff --git a/src/event.rs b/src/event.rs
@@ -90,6 +90,7 @@ pub enum Source
     CommitButton,
     CommitDiffViewWidget,
     CommitLogAuthorFilterEntry,
+    CommitLogAuthorFilterCaseButton,
     CommitLogAuthorFilterRegexButton,
     CommitLogModelFilter,
     CommitLogView,

diff --git a/src/gui.rs b/src/gui.rs
@@ -180,6 +180,7 @@ fn setupDispatching(gui: GuiObjects, mut repository: Rc<RefCell<Repository>>, re
         (S::CommitButton,                     E::CommitRequested(_))      => repository.handle(source, &event),
         (S::CommitDiffViewWidget,             E::ZoomRequested(_))        => commitDiffView.handle(source, &event),
         (S::CommitLogAuthorFilterEntry,       E::TextEntered(_))          => commitLogModelFilter.handle(source, &event),
+        (S::CommitLogAuthorFilterCaseButton,  E::Toggled(_))              => commitLogModelFilter.handle(source, &event),
         (S::CommitLogAuthorFilterRegexButton, E::Toggled(_))              => commitLogModelFilter.handle(source, &event),
         (S::CommitLogModelFilter,             E::RefilterRequested)       => (&mut commitLogView, &mut commitLogModelFilter).handle(source, &event),
         (S::CommitLogModelFilter,             E::RefilterEnded)           => commitLogView.handle(source, &event),

diff --git a/src/main_window.glade b/src/main_window.glade
@@ -455,7 +455,7 @@
                 <property name="can-focus">False</property>
                 <property name="orientation">vertical</property>
                 <child>
-                  <!-- n-columns=3 n-rows=1 -->
+                  <!-- n-columns=4 n-rows=1 -->
                   <object class="GtkGrid" id="Commit log filters grid">
                     <property name="name">Commit log filters grid</property>
                     <property name="can-focus">False</property>
@@ -494,6 +494,20 @@
                         <property name="receives-default">True</property>
                         <property name="tooltip-text" translatable="yes">Regular expressions</property>
                       </object>
+                      <packing>
+                        <property name="left-attach">3</property>
+                        <property name="top-attach">0</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkToggleButton" id="Commit log author filter case button">
+                        <property name="label" translatable="yes">Aa</property>
+                        <property name="name">Commit log author filter case button</property>
+                        <property name="visible">True</property>
+                        <property name="can-focus">True</property>
+                        <property name="receives-default">True</property>
+                        <property name="tooltip-text" translatable="yes">Case sensitivity</property>
+                      </object>
                       <packing>
                         <property name="left-attach">2</property>
                         <property name="top-attach">0</property>

diff --git a/src/text_filter.rs b/src/text_filter.rs
@@ -4,6 +4,7 @@ use regex::{Regex, RegexBuilder};
 
 pub(crate) struct TextFilter
 {
+    caseSensitive: bool,
     regexState: RegexState
 }
 
@@ -18,15 +19,15 @@ impl TextFilter
 {
     pub(crate) fn new() -> Self
     {
-        Self{regexState: RegexState::Disabled{text: String::new()}}
+        Self{caseSensitive: false, regexState: RegexState::Disabled{text: String::new()}}
     }
 
     pub(crate) fn setText(&mut self, newText: &str) -> Result<()>
     {
         match &mut self.regexState {
             RegexState::Disabled{text} => *text = newText.into(),
             RegexState::Invalid{text} => {
-                match RegexBuilder::new(newText).case_insensitive(true).build() {
+                match RegexBuilder::new(newText).case_insensitive(!self.caseSensitive).build() {
                     Ok(newRegex) => self.regexState = RegexState::Valid{regex: newRegex},
                     Err(e) => {
                         *text = newText.into();
@@ -35,7 +36,7 @@ impl TextFilter
                 }
             },
             RegexState::Valid{regex} => {
-                match RegexBuilder::new(newText).case_insensitive(true).build() {
+                match RegexBuilder::new(newText).case_insensitive(!self.caseSensitive).build() {
                     Ok(newRegex) => *regex = newRegex,
                     Err(e) => {
                         self.regexState = RegexState::Invalid{text: newText.into()};
@@ -47,12 +48,31 @@ impl TextFilter
         Ok(())
     }
 
+    pub(crate) fn setCaseSensitivityEnabled(&mut self, shouldEnable: bool) -> Result<()>
+    {
+        self.caseSensitive = shouldEnable;
+        match &mut self.regexState {
+            RegexState::Disabled{..} => (),
+            RegexState::Invalid{..} => bail!(""),
+            RegexState::Valid{regex} => {
+                match RegexBuilder::new(regex.as_str()).case_insensitive(!shouldEnable).build() {
+                    Ok(newRegex) => self.regexState = RegexState::Valid{regex: newRegex},
+                    Err(e) => {
+                        self.regexState = RegexState::Invalid{text: regex.as_str().into()};
+                        bail!(e)
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
+
     pub(crate) fn setRegexEnabled(&mut self, shouldEnable: bool) -> Result<()>
     {
         if shouldEnable {
             match &mut self.regexState {
                 RegexState::Disabled{text} => {
-                    match RegexBuilder::new(&text).case_insensitive(true).build() {
+                    match RegexBuilder::new(&text).case_insensitive(!self.caseSensitive).build() {
                         Ok(regex) => self.regexState = RegexState::Valid{regex},
                         Err(e) => {
                             self.regexState = RegexState::Invalid{text: text.clone()};
@@ -85,7 +105,13 @@ impl TextFilter
     pub(crate) fn isMatch(&self, input: &str) -> bool
     {
         match &self.regexState {
-            RegexState::Disabled{text} => input.to_lowercase().contains(text),
+            RegexState::Disabled{text} => {
+                if self.caseSensitive {
+                    input.contains(text)
+                } else {
+                    input.to_lowercase().contains(&text.to_lowercase())
+                }
+            },
             RegexState::Invalid{..} => false,
             RegexState::Valid{regex} => regex.is_match(input)
         }