From a7c79cb5a04562be10347856642a80f0c4be89fc Mon Sep 17 00:00:00 2001
From: delta <darkussdelta@gmail.com>
Date: Fri, 17 Apr 2026 08:10:30 +0200
Subject: sync

---
 .config/awesome/quarrel/native/src/lenses/mod.rs | 90 +++++++++++++++---------
 1 file changed, 55 insertions(+), 35 deletions(-)

(limited to '.config/awesome/quarrel/native/src/lenses/mod.rs')

diff --git a/.config/awesome/quarrel/native/src/lenses/mod.rs b/.config/awesome/quarrel/native/src/lenses/mod.rs
index bb7f727..0b7864e 100644
--- a/.config/awesome/quarrel/native/src/lenses/mod.rs
+++ b/.config/awesome/quarrel/native/src/lenses/mod.rs
@@ -5,8 +5,8 @@ use std::sync::Arc;
 
 use itertools::Itertools;
 use mlua::{
-    prelude::*,
     LuaSerdeExt,
+    prelude::*,
 };
 use rayon::iter::FromParallelIterator;
 use serde::{
@@ -18,7 +18,7 @@ use serde::{
 pub enum Entries {
     Multiple(Vec<Entry>),
     Single(Entry),
-    None
+    None,
 }
 
 impl FromIterator<Entry> for Entries {
@@ -32,7 +32,7 @@ impl FromIterator<Entry> for Entries {
                 let mut vec = Vec::from([first, second]);
                 vec.extend(iter);
                 Self::Multiple(vec)
-            },
+            }
         }
     }
 }
@@ -44,8 +44,8 @@ impl From<Vec<Entry>> for Entries {
             1 => {
                 let entry = entries.into_iter().exactly_one().unwrap();
                 Self::Single(entry)
-            },
-            _ => Self::Multiple(entries)
+            }
+            _ => Self::Multiple(entries),
         }
     }
 }
@@ -55,7 +55,7 @@ impl IntoLua for Entries {
         match self {
             Entries::Multiple(entries) => entries.into_lua(lua),
             Entries::Single(entry) => entry.into_lua(lua),
-            Entries::None => Ok(LuaValue::Nil)
+            Entries::None => Ok(LuaValue::Nil),
         }
     }
 }
@@ -89,6 +89,7 @@ pub struct _Lense<T: Lense>(pub Arc<T>);
 
 pub trait Lense {
     const NAME: &'static str;
+    const PREFIX: Option<&'static str>;
 
     fn init() -> Arc<Self>;
 
@@ -98,51 +99,70 @@ pub trait Lense {
     fn set_interrupt(&self, interrupt: bool);
     fn get_interrupt(&self) -> bool;
 
-    fn entries(&self, lua: &Lua, input: String) -> Result<Entries, anyhow::Error>;
-    fn filter(&self, entries: Entries, input: String) -> Entries {
-        let entry_contains = |entry: &Entry| {
-            entry.message.to_lowercase().contains(&input.to_lowercase())
-        };
+    fn entries(&self, lua: &Lua, input: &str) -> Result<Entries, anyhow::Error>;
+    fn filter(&self, entries: Entries, input: &str) -> Entries {
+        let entry_contains =
+            |entry: &Entry| entry.message.to_lowercase().contains(&input.to_lowercase());
         match entries {
-            Entries::Multiple(entries) => entries.into_iter()
-                .filter(entry_contains)
-                .collect(),
-            Entries::Single(entry) => if entry_contains(&entry) { Entries::Single(entry) } else { Entries::None }
-            Entries::None => Entries::None
+            Entries::Multiple(entries) => entries.into_iter().filter(entry_contains).collect(),
+            Entries::Single(entry) => {
+                if entry_contains(&entry) {
+                    Entries::Single(entry)
+                } else {
+                    Entries::None
+                }
+            }
+            Entries::None => Entries::None,
         }
     }
 }
 
 impl<T: Lense + 'static> LuaUserData for _Lense<T> {
     fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {
-        fields.add_field_method_get("stale", |_, this| {
-            Ok(matches!(this.0.get_cache(), Cache::Stale))
+        fields.add_field_method_get("stale", |_, Self(this)| {
+            Ok(matches!(this.get_cache(), Cache::Stale))
         });
 
         fields.add_field("name", T::NAME);
     }
 
     fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {
-        methods.add_method_mut("query", |lua, this, input: String| {
-            this.0.set_interrupt(false); // reset interrupt so that we can use the lense again
-            return Ok(match this.0.get_cache() {
-                Cache::Valid(entries) => this.0.filter(entries.clone(), input),
-                Cache::Stale => {
-                    let entries = this.0.entries(lua, input.clone()).map_err(LuaError::external)?;
-                    let mut entries = this.0.filter(entries, input);
-                    match entries {
-                        Entries::Multiple(ref mut entries) => entries.sort_by(|a, b| a.message.cmp(&b.message)),
-                        _ => {}
-                    }
-                    this.0.set_cache(Cache::Valid(entries.clone()));
-                    entries
+        methods.add_method_mut("query", |lua, Self(this), input: String| {
+            if T::PREFIX.is_some_and(|prefix| input.starts_with(prefix)) || T::PREFIX.is_none() {
+                let input = if let Some(prefix) = T::PREFIX {
+                    input.trim_start_matches(prefix)
+                } else {
+                    &input
                 }
-            });
+                .trim();
+
+                this.set_interrupt(false); // reset interrupt so that we can use the lense again
+                
+                return Ok(match this.get_cache() {
+                    Cache::Valid(entries) => this.filter(entries.clone(), input),
+                    Cache::Stale => {
+                        let entries = this.entries(lua, input).map_err(LuaError::external)?;
+                        let mut entries = this.filter(entries, input);
+                        match entries {
+                            Entries::Multiple(ref mut entries) => {
+                                entries.sort_by(|a, b| a.message.cmp(&b.message))
+                            }
+                            _ => {}
+                        }
+                        this.set_cache(Cache::Valid(entries.clone()));
+                        entries
+                    }
+                });
+            } else {
+                return Ok(Entries::None);
+            }
         });
 
-        methods.add_method_mut("mark_stale", |_, this, _: ()| {
-            Ok(this.0.set_cache(Cache::Stale))
+        methods.add_method_mut("mark_stale", |_, Self(this), _: ()| {
+            Ok(this.set_cache(Cache::Stale))
+        });
+        methods.add_method_mut("interrupt", |_, Self(this), _: ()| {
+            Ok(this.set_interrupt(true))
         });
-        methods.add_method_mut("interrupt", |_, this, _: ()| Ok(this.0.set_interrupt(true)));
     }
 }
-- 
cgit v1.2.3