:3

4 files changed, 155 insertions, 74 deletions

diff --git a/.config/awesome/quarrel/native/src/lenses/application.rs b/.config/awesome/quarrel/native/src/lenses/application.rs
index 72aba8d..89b7bb4 100644
--- a/.config/awesome/quarrel/native/src/lenses/application.rs
+++ b/.config/awesome/quarrel/native/src/lenses/application.rs
@@ -1,6 +1,5 @@
 use std::{
-    fs::read_dir,
-    path::PathBuf,
+    fs::read_dir, path::PathBuf
 };
 
 use freedesktop_entry_parser as fd;
@@ -8,12 +7,54 @@ use mlua::prelude::*;
 use rayon::prelude::*;
 use url::Url;
 
-use crate::lenses::entry::{
-    entries_to_lua_table,
+use crate::lenses::{
     Entry,
+    Lense,
+    Cache
 };
 
-fn parse_entry(entry: &fd::Entry, path: &PathBuf) -> Result<Entry, ()> {
+#[derive(Default)]
+pub struct Application(pub Cache);
+
+impl Lense for Application {
+    const NAME: &str = "Application";
+
+    fn get_cache(&self) -> &Cache {
+        &self.0
+    }
+
+    fn set_cache(&mut self, cache: Cache) {
+        self.0 = cache;
+    }
+
+    fn query(_: &Lua, input: String) -> Result<Vec<Entry>, anyhow::Error> {
+        let applications_dir = "/usr/share/applications";
+        let entries = read_dir(applications_dir)?
+            .map(|result| result.map(|e| e.path()))
+            .collect::<Result<Vec<_>, std::io::Error>>()?;
+
+        let parsed_entries: Vec<Entry> = entries
+            .into_par_iter()
+            .filter(|path| path.extension().is_some_and(|ext| ext == "desktop"))
+            .filter_map(|path| {
+                parse_entry(path).ok().flatten()
+            })
+            .collect();
+
+        Ok(
+            parsed_entries
+                .into_iter()
+                .filter(|entry| entry.message.to_lowercase().contains(&input.to_lowercase()))
+                .collect(),
+        )
+    }
+}
+
+fn parse_entry(path: PathBuf) -> Result<Option<Entry>, ()> {
+    let Ok(entry) = fd::parse_entry(&path) else {
+        return Err(())
+    };
+
     let section = entry.section("Desktop Entry");
     let name = section.attr("Name").ok_or(())?.to_string();
 
@@ -38,14 +79,14 @@ fn parse_entry(entry: &fd::Entry, path: &PathBuf) -> Result<Entry, ()> {
                 }
             }
             'c' => new_exec.replace_range(index..index + 2, &name),
-            'k' => new_exec.replace_range(index..index + 2, Url::from_file_path(path)?.as_str()),
+            'k' => new_exec.replace_range(index..index + 2, Url::from_file_path(&path)?.as_str()),
 
             'f' | 'u' | 'v' | 'm' | 'd' | 'n' => new_exec.replace_range(index..index + 2, ""),
             _ => continue,
         }
     }
 
-    Ok(Entry {
+    Ok(Some(Entry {
         message: name,
         exec: Some((
             new_exec,
@@ -55,33 +96,5 @@ fn parse_entry(entry: &fd::Entry, path: &PathBuf) -> Result<Entry, ()> {
                 .parse()
                 .map_err(drop)?,
         )),
-        provider: "Application".to_string(),
-    })
-}
-
-pub fn query(lua: &Lua, input: String) -> LuaResult<LuaTable> {
-    let applications_dir = "/usr/share/applications";
-    let entries = read_dir(applications_dir)?
-        .map(|result| result.map(|e| e.path()))
-        .collect::<Result<Vec<_>, std::io::Error>>()?;
-
-    let parsed_entries: Vec<Entry> = entries
-        .into_par_iter()
-        .filter(|path| matches!(path.extension(), Some(ext) if ext == "desktop"))
-        .filter_map(|path| {
-            let Ok(entry) = fd::parse_entry(&path) else {
-                return None
-            };
-
-            parse_entry(&entry, &path).ok()
-        })
-        .collect();
-
-    Ok(entries_to_lua_table(
-        parsed_entries
-            .into_iter()
-            .filter(|entry| entry.message.to_lowercase().contains(&input.to_lowercase()))
-            .collect(),
-        lua,
-    ))
+    }))
 }
diff --git a/.config/awesome/quarrel/native/src/lenses/calculator.rs b/.config/awesome/quarrel/native/src/lenses/calculator.rs
index 07f1ee2..640bdeb 100644
--- a/.config/awesome/quarrel/native/src/lenses/calculator.rs
+++ b/.config/awesome/quarrel/native/src/lenses/calculator.rs
@@ -5,25 +5,36 @@ use cpc::{
 };
 use mlua::prelude::*;
 
-use crate::lenses::entry::{
-    entries_to_lua_table,
+use crate::lenses::{
     Entry,
+    Cache,
+    Lense
 };
 
-pub fn query(lua: &Lua, input: String) -> LuaResult<LuaTable> {
-    let result = match eval(input.trim(), true, Unit::Celsius, false) {
-        Ok(result) => {
-            format!("{result}")
-        }
-        Err(_) => return lua.create_table(),
-    };
-
-    Ok(entries_to_lua_table(
-        vec![Entry {
-            message: result,
-            exec: None,
-            provider: "Calculator".to_string(),
-        }],
-        lua,
-    ))
+pub struct Calculator;
+
+impl Lense for Calculator {
+    const NAME: &str = "Calculator";
+
+    fn get_cache(&self) -> &Cache {
+        &Cache::Stale
+    }
+
+    fn set_cache(&mut self, _: Cache) {}
+
+    fn query(_: &Lua, input: String) -> Result<Vec<Entry>, anyhow::Error> {
+        let result = match eval(input.trim(), true, Unit::Celsius, false) {
+            Ok(result) => {
+                format!("{result}")
+            }
+            Err(err) => { return Err(anyhow::anyhow!(err)); },
+        };
+
+        Ok(vec![Entry {
+                message: result,
+                exec: None,
+            }; 1]
+        )
+    }
 }
+
diff --git a/.config/awesome/quarrel/native/src/lenses/entry.rs b/.config/awesome/quarrel/native/src/lenses/entry.rs
deleted file mode 100644
index c7ac09e..0000000
--- a/.config/awesome/quarrel/native/src/lenses/entry.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-use mlua::{
-    prelude::*,
-    LuaSerdeExt,
-};
-use serde::Serialize;
-
-#[derive(Serialize, Clone)]
-pub struct Entry {
-    pub message: String,
-    pub exec: Option<(String, bool)>,
-    pub provider: String,
-}
-
-pub fn entries_to_lua_table(entries: Vec<Entry>, lua: &Lua) -> LuaTable {
-    match lua.to_value(&entries).unwrap() {
-        LuaValue::Table(t) => t,
-        _ => unreachable!(),
-    }
-}
diff --git a/.config/awesome/quarrel/native/src/lenses/mod.rs b/.config/awesome/quarrel/native/src/lenses/mod.rs
index d0db6f7..6eb5b58 100644
--- a/.config/awesome/quarrel/native/src/lenses/mod.rs
+++ b/.config/awesome/quarrel/native/src/lenses/mod.rs
@@ -1,3 +1,79 @@
 pub mod application;
 pub mod calculator;
-pub mod entry;
+
+use mlua::{
+    prelude::*,
+    LuaSerdeExt,
+};
+use serde::{Serialize, Deserialize};
+
+#[derive(Deserialize, Serialize, Clone)]
+pub struct Entry {
+    pub message: String,
+    pub exec: Option<(String, bool)>,
+}
+
+impl IntoLua for Entry {
+    fn into_lua(self, lua: &Lua) -> LuaResult<LuaValue> {
+        return lua.to_value(&self)
+    }
+}
+
+impl FromLua for Entry {
+    fn from_lua(value: LuaValue, lua: &Lua) -> LuaResult<Self> {
+        return lua.from_value(value);
+    }
+}
+
+#[derive(Default)]
+pub enum Cache {
+    Valid(Vec<Entry>),
+    #[default]
+    Stale
+}
+
+pub struct _Lense<T: Lense>(pub T);
+
+pub trait Lense {
+    const NAME: &'static str;
+
+    fn set_cache(&mut self, cache: Cache);
+    fn get_cache(&self) -> &Cache;
+
+    fn query(lua: &Lua, input: String) -> Result<Vec<Entry>, anyhow::Error>;
+}
+
+impl<T: Lense + 'static> LuaUserData for _Lense<T> {
+    fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {
+        // fields.add_field_method_get("cache", |lua, this| {
+        //     let cache = this.0.get_cache();
+        //     match cache {
+        //         Cache::Valid(cache) => Ok(cache.clone().into_lua(lua)?),
+        //         Cache::Stale => Ok(LuaNil)
+        //     }
+        // });
+
+        // fields.add_field_method_set("cache", |_, this, cache: Vec<Entry>| {
+        //     Ok(this.0.set_cache(Cache::Valid(cache)))
+        // });
+
+        fields.add_field_method_get("stale", |_, this| Ok(matches!(this.0.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| {
+            return Ok(match this.0.get_cache() {
+                Cache::Valid(entries) => entries.clone(),
+                Cache::Stale => {
+                    let entries = T::query(lua, input).map_err(LuaError::external)?;
+                    this.0.set_cache(Cache::Valid(entries.clone()));
+                    entries
+                }
+            });
+        });
+
+        methods.add_method_mut("mark_stale", |_, this, _: ()| Ok(this.0.set_cache(Cache::Stale)) );
+    }
+}