hum

Author: wiiznokes

.cargo/config.toml

@@ -1,4 +1,4 @@
 [env]
 RUST_LOG = "warn,cosmic_ext_applet_clipboard_manager=debug"
-RUST_BACKTRACE = "full"
+# RUST_BACKTRACE = "full"
 

Cargo.lock

@@ -40,6 +40,7 @@ tracing-journald = "0.3"
 constcat = "0.5"
 nucleo = "0.5"
 futures = "0.3"
+include_dir = "0.7.4"
 
 [dependencies.libcosmic]
 git = "https://github.com/pop-os/libcosmic"

Cargo.toml

@@ -2,6 +2,6 @@ CREATE TABLE IF NOT EXISTS FavoriteClipboardEntries (
     id INTEGER PRIMARY KEY,
     position INTEGER NOT NULL,
 	FOREIGN KEY (id) REFERENCES ClipboardEntries(creation) ON DELETE CASCADE,
-    UNIQUE (position),
+    -- UNIQUE (position),
     CHECK (position >= 0)
 );

migrations/20240929151638_favorite.sql

@@ -35,39 +35,37 @@ use crate::{
     app::{APP, APPID, ORG, QUALIFIER},
     config::Config,
     message::AppMsg,
-    utils::{self, now_millis, remove_dir_contents},
+    utils::{self, now_millis},
 };
 
 type TimeId = i64;
 
-const DB_VERSION: &str = "4";
+const DB_VERSION: &str = "4-dev";
 const DB_PATH: &str = constcat::concat!(APPID, "-db-", DB_VERSION, ".sqlite");
 
-// warning: if you change somethings in here, change the db version
 #[derive(Clone, Eq, Derivative)]
-#[derivative(PartialEq, Hash)]
 pub struct Entry {
-    #[derivative(PartialEq = "ignore")]
-    #[derivative(Hash = "ignore")]
     pub creation: TimeId,
-
-    #[derivative(PartialEq = "ignore")]
-    #[derivative(Hash = "ignore")]
     pub mime: String,
-
     // todo: lazelly load image in memory, since we can't search them anyways
     pub content: Vec<u8>,
-
-    #[derivative(PartialEq = "ignore")]
-    #[derivative(Hash = "ignore")]
     /// (Mime, Content)
     pub metadata: Option<EntryMetadata>,
-
-    #[derivative(PartialEq = "ignore")]
-    #[derivative(Hash = "ignore")]
     pub is_favorite: bool,
 }
 
+impl Hash for Entry {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.content.hash(state);
+    }
+}
+
+impl PartialEq for Entry {
+    fn eq(&self, other: &Self) -> bool {
+        self.content == other.content
+    }
+}
+
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct EntryMetadata {
     pub mime: String,
@@ -228,8 +226,6 @@ pub struct Db {
     query: String,
     needle: Option<Atom>,
     matcher: Matcher,
-    // time
-    last_update: i64,
     data_version: i64,
     favorites: Favorites,
 }
@@ -275,6 +271,13 @@ impl Favorites {
     fn fav(&self) -> &Vec<TimeId> {
         &self.favorites
     }
+
+    fn change(&mut self, prev: &TimeId, new: TimeId) {
+        let pos = self.favorites.iter().position(|e| e == prev).unwrap();
+        self.favorites[pos] = new;
+        self.favorites_hash_set.remove(prev);
+        self.favorites_hash_set.insert(new);
+    }
 }
 
 impl Db {
@@ -300,7 +303,11 @@ impl Db {
 
         let mut conn = SqliteConnection::connect(db_path).await?;
 
-        let migration_path = Path::new(constcat::concat!("/usr/share/", APP, "/migrations"));
+        let migration_path = db_dir.join("migrations");
+        std::fs::create_dir_all(&migration_path)?;
+        include_dir::include_dir!("migrations")
+            .extract(&migration_path)
+            .unwrap();
 
         match sqlx::migrate::Migrator::new(migration_path).await {
             Ok(migrator) => migrator,
@@ -352,7 +359,6 @@ impl Db {
             query: String::default(),
             needle: None,
             matcher: Matcher::new(nucleo::Config::DEFAULT),
-            last_update: 0,
             favorites: Favorites::default(),
         };
 
@@ -378,9 +384,9 @@ impl Db {
 
             let mut max = 0;
             for row in &rows {
-                max = std::cmp::max(max, self.favorites.insert_row(row));
+                max = std::cmp::max(max, self.favorites.insert_row(row) + 1);
             }
-            assert!(max == self.favorite_len() - 1);
+            assert!(max == self.favorite_len());
         }
 
         {
@@ -467,18 +473,39 @@ impl Db {
             // safe to unwrap since we insert before
             let last_row = self.get_last_row().await?.unwrap();
 
+            let new_id = last_row.creation;
+
             let data_hash = data.get_hash();
 
             if let Some(old_id) = self.hashs.remove(&data_hash) {
                 self.state.remove(&old_id);
 
+                if self.favorites.contains(&old_id) {
+                    data.is_favorite = true;
+                    let query_delete_old_id = r#"
+                        UPDATE FavoriteClipboardEntries
+                        SET id = $1
+                        WHERE id = $2;
+                    "#;
+
+                    sqlx::query(query_delete_old_id)
+                        .bind(new_id)
+                        .bind(old_id)
+                        .execute(&mut self.conn)
+                        .await?;
+
+                    self.favorites.change(&old_id, new_id);
+                } else {
+                    data.is_favorite = false;
+                }
+
                 // in case 2 same data were inserted in a short period
                 // we don't want to remove the old_id
-                if last_row.creation != old_id {
+                if new_id != old_id {
                     let query_delete_old_id = r#"
-                    DELETE FROM ClipboardEntries
-                    WHERE creation = ?;
-                "#;
+                        DELETE FROM ClipboardEntries
+                        WHERE creation = ?;
+                    "#;
 
                     sqlx::query(query_delete_old_id)
                         .bind(old_id)
@@ -487,11 +514,10 @@ impl Db {
                 }
             }
 
-            data.creation = last_row.creation;
+            data.creation = new_id;
 
             self.hashs.insert(data_hash, data.creation);
             self.state.insert(data.creation, data);
-            self.last_update = now_millis();
 
             self.search();
             Ok(())
@@ -512,7 +538,6 @@ impl Db {
 
         self.hashs.remove(&data.get_hash());
         self.state.remove(&data.creation);
-        self.last_update = now_millis();
 
         if data.is_favorite {
             self.favorites.remove(&data.creation);
@@ -532,7 +557,6 @@ impl Db {
         self.state.clear();
         self.filtered.clear();
         self.hashs.clear();
-        self.last_update = now_millis();
         self.favorites.clear();
 
         Ok(())
@@ -552,10 +576,11 @@ impl Db {
             sqlx::query(query)
                 .bind(pos as i32)
                 .execute(&mut self.conn)
-                .await?;
+                .await
+                .unwrap();
         }
 
-        let index = index.unwrap_or(self.favorite_len());
+        let index = index.unwrap_or(self.favorite_len() - 1);
 
         {
             let query = r#"
@@ -570,6 +595,10 @@ impl Db {
                 .await?;
         }
 
+        if let Some(e) = self.state.get_mut(&entry.creation) {
+            e.is_favorite = true;
+        }
+
         Ok(())
     }
 
@@ -600,6 +629,9 @@ impl Db {
                 .await?;
         }
 
+        if let Some(e) = self.state.get_mut(&entry.creation) {
+            e.is_favorite = false;
+        }
         Ok(())
     }
 
@@ -745,6 +777,8 @@ mod test {
 
     use anyhow::Result;
     use cosmic::{iced_sctk::util, widget::canvas::Path};
+    use tracing_subscriber::{fmt, layer::SubscriberExt, util::SubscriberInitExt, EnvFilter};
+
 
     use crate::{
         config::Config,
@@ -754,6 +788,16 @@ mod test {
     use super::{Db, Entry};
 
     fn prepare_db_dir() -> PathBuf {
+        let fmt_layer = fmt::layer().with_target(false);
+        let filter_layer = EnvFilter::try_from_default_env().unwrap_or(EnvFilter::new(format!(
+            "warn,{}=info",
+            env!("CARGO_CRATE_NAME")
+        )));
+        tracing_subscriber::registry()
+            .with(filter_layer)
+            .with(fmt_layer)
+            .init();
+
         let db_dir = PathBuf::from("tests");
         let _ = std::fs::create_dir_all(&db_dir);
         remove_dir_contents(&db_dir);
@@ -925,4 +969,86 @@ mod test {
         db.insert(data).await.unwrap();
         assert!(db.len() == 2);
     }
+
+    #[tokio::test]
+    #[serial]
+    async fn favorites() {
+        let db_path = prepare_db_dir();
+
+        let mut db = Db::inner_new(&Config::default(), &db_path).await.unwrap();
+
+        let now1 = 1000;
+
+        let data1 = Entry::new(
+            now1,
+            "text/plain".into(),
+            "content1".as_bytes().into(),
+            None,
+            false,
+        );
+
+        db.insert(data1).await.unwrap();
+
+        let now2 = 2000;
+
+        let data2 = Entry::new(
+            now2,
+            "text/plain".into(),
+            "content2".as_bytes().into(),
+            None,
+            false,
+        );
+
+        db.insert(data2).await.unwrap();
+
+        let now3 = 3000;
+
+        let data3 = Entry::new(
+            now3,
+            "text/plain".into(),
+            "content3".as_bytes().into(),
+            None,
+            false,
+        );
+
+        db.insert(data3.clone()).await.unwrap();
+
+        db.add_favorite(&db.state.get(&now3).unwrap().clone(), None)
+            .await
+            .unwrap();
+
+        db.delete(&db.state.get(&now3).unwrap().clone())
+            .await
+            .unwrap();
+
+        assert_eq!(db.favorite_len(), 0);
+
+        db.insert(data3).await.unwrap();
+
+        db.add_favorite(&db.state.get(&now1).unwrap().clone(), None)
+            .await
+            .unwrap();
+
+        db.add_favorite(&db.state.get(&now3).unwrap().clone(), None)
+            .await
+            .unwrap();
+
+        db.add_favorite(&db.state.get(&now2).unwrap().clone(), Some(1))
+            .await
+            .unwrap();
+
+        assert_eq!(db.favorite_len(), 3);
+
+        assert_eq!(db.favorites.fav(), &vec![now1, now2, now3]);
+
+        drop(db);
+        
+
+        let db = Db::inner_new(&Config::default(), &db_path).await.unwrap();
+
+        assert_eq!(db.len(), 3);
+
+        assert_eq!(db.favorite_len(), 3);
+        assert_eq!(db.favorites.fav(), &vec![now1, now2, now3]);
+    }
 }