feat: Bookmarks

TODO:
- Making OkuNet posts
- Setting up an OkuNet identity
- Viewing OkuNet profiles
- Following & blocking OkuNet users

resources.gresource.xml

@@ -20,5 +20,8 @@
     <file preprocess="xml-stripblanks">user-home-symbolic.svg</file>
     <file preprocess="xml-stripblanks">note-symbolic.svg</file>
     <file preprocess="xml-stripblanks">folder-remote-symbolic.svg</file>
+    <file preprocess="xml-stripblanks">bookmark-filled-symbolic.svg</file>
+    <file preprocess="xml-stripblanks">pencil-and-paper-small-symbolic.svg</file>
+    <file preprocess="xml-stripblanks">editor-symbolic.svg</file>
   </gresource>
 </gresources>

src/bookmark_item.rs

@@ -0,0 +1,150 @@
+use glib::clone;
+use glib::property::PropertySet;
+use glib::subclass::object::ObjectImpl;
+use glib::subclass::types::ObjectSubclass;
+use glib::subclass::types::ObjectSubclassExt;
+use glib::subclass::types::ObjectSubclassIsExt;
+use glib::value::ToValue;
+use glib::ParamSpec;
+use glib::ParamSpecBoxed;
+use glib::ParamSpecBuilderExt;
+use glib::ParamSpecObject;
+use glib::ParamSpecString;
+use glib::Value;
+use once_cell::sync::Lazy;
+use std::cell::RefCell;
+use uuid::Uuid;
+use webkit2gtk::functions::uri_for_display;
+
+pub mod imp {
+    use super::*;
+
+    #[derive(Default, Debug)]
+    pub struct BookmarkItem {
+        pub(crate) url: RefCell<String>,
+        pub(crate) title: RefCell<String>,
+        pub(crate) body: RefCell<String>,
+        pub(crate) tags: RefCell<Vec<String>>,
+        pub(crate) favicon: RefCell<Option<gdk::Texture>>,
+    }
+
+    #[glib::object_subclass]
+    impl ObjectSubclass for BookmarkItem {
+        const NAME: &'static str = "OkuBookmarkItem";
+        type Type = super::BookmarkItem;
+    }
+
+    impl ObjectImpl for BookmarkItem {
+        fn properties() -> &'static [ParamSpec] {
+            static PROPERTIES: Lazy<Vec<ParamSpec>> = Lazy::new(|| {
+                vec![
+                    ParamSpecString::builder("url").readwrite().build(),
+                    ParamSpecString::builder("title").readwrite().build(),
+                    ParamSpecString::builder("body").readwrite().build(),
+                    ParamSpecBoxed::builder::<Vec<String>>("tags")
+                        .readwrite()
+                        .build(),
+                    ParamSpecObject::builder::<gdk::Texture>("favicon")
+                        .readwrite()
+                        .build(),
+                ]
+            });
+            PROPERTIES.as_ref()
+        }
+
+        fn set_property(&self, _id: usize, value: &Value, pspec: &ParamSpec) {
+            match pspec.name() {
+                "url" => {
+                    let url = value.get::<String>().unwrap();
+                    self.url.set(
+                        html_escape::encode_text(&uri_for_display(&url).unwrap_or(url.into()))
+                            .to_string(),
+                    );
+                }
+                "title" => {
+                    let title = value.get::<String>().unwrap();
+                    self.title.set(html_escape::encode_text(&title).to_string());
+                }
+                "body" => {
+                    let body = value.get::<String>().unwrap();
+                    self.body.set(html_escape::encode_text(&body).to_string());
+                }
+                "tags" => {
+                    let tags = value.get::<Vec<String>>().unwrap();
+                    self.tags.set(
+                        tags.iter()
+                            .map(|x| html_escape::encode_text(x).to_string())
+                            .collect(),
+                    );
+                }
+                "favicon" => {
+                    let favicon = value.get::<gdk::Texture>().ok();
+                    self.favicon.set(favicon);
+                }
+                _ => unimplemented!(),
+            }
+        }
+
+        fn property(&self, _id: usize, pspec: &ParamSpec) -> Value {
+            let obj = self.obj();
+            match pspec.name() {
+                "url" => obj.url().to_string().to_value(),
+                "title" => obj.title().to_value(),
+                "body" => obj.body().to_value(),
+                "tags" => obj.tags().to_value(),
+                "favicon" => obj.favicon().to_value(),
+                _ => unimplemented!(),
+            }
+        }
+    }
+}
+
+glib::wrapper! {
+    pub struct BookmarkItem(ObjectSubclass<imp::BookmarkItem>);
+}
+
+impl BookmarkItem {
+    pub fn url(&self) -> String {
+        self.imp().url.borrow().to_string()
+    }
+    pub fn title(&self) -> String {
+        self.imp().title.borrow().to_string()
+    }
+    pub fn body(&self) -> String {
+        self.imp().body.borrow().to_string()
+    }
+    pub fn tags(&self) -> Vec<String> {
+        self.imp().tags.borrow().to_owned()
+    }
+    pub fn favicon(&self) -> Option<gdk::Texture> {
+        self.imp().favicon.borrow().clone()
+    }
+    pub fn new(
+        url: String,
+        title: String,
+        body: String,
+        tags: Vec<String>,
+        favicon_database: &webkit2gtk::FaviconDatabase,
+    ) -> Self {
+        let bookmark_item = glib::Object::builder::<Self>()
+            .property("url", url.clone())
+            .property("title", title)
+            .property("body", body)
+            .property("tags", tags.clone())
+            .build();
+
+        favicon_database.favicon(
+            &url,
+            Some(&gio::Cancellable::new()),
+            clone!(
+                #[weak]
+                bookmark_item,
+                move |favicon_result| {
+                    bookmark_item.imp().favicon.set(favicon_result.ok());
+                }
+            ),
+        );
+
+        bookmark_item
+    }
+}

src/database/bookmark.rs

@@ -14,7 +14,7 @@ use tantivy::{
     collector::TopDocs,
     directory::MmapDirectory,
     query::QueryParser,
-    schema::{Field, Schema, Value, TEXT},
+    schema::{Field, Schema, Value, STORED, TEXT},
     Directory, Index, IndexReader, IndexWriter, TantivyDocument, Term,
 };
 use tokio::sync::Mutex;
@@ -24,10 +24,13 @@ pub(crate) static BOOKMARK_INDEX_PATH: LazyLock<PathBuf> =
 pub(crate) static BOOKMARK_SCHEMA: LazyLock<(Schema, HashMap<&str, Field>)> = LazyLock::new(|| {
     let mut schema_builder = Schema::builder();
     let fields = HashMap::from([
-        ("url", schema_builder.add_text_field("url", TEXT)),
-        ("title", schema_builder.add_text_field("title", TEXT)),
-        ("body", schema_builder.add_text_field("body", TEXT)),
-        ("tag", schema_builder.add_text_field("tag", TEXT)),
+        ("url", schema_builder.add_text_field("url", TEXT | STORED)),
+        (
+            "title",
+            schema_builder.add_text_field("title", TEXT | STORED),
+        ),
+        ("body", schema_builder.add_text_field("body", TEXT | STORED)),
+        ("tag", schema_builder.add_text_field("tag", TEXT | STORED)),
     ]);
     let schema = schema_builder.build();
     (schema, fields)
@@ -139,11 +142,26 @@ impl BrowserDatabase {
             .collect())
     }
 
+    pub fn rebuild_bookmark_index(&self) -> miette::Result<()> {
+        let mut index_writer = BOOKMARK_INDEX_WRITER
+            .clone()
+            .try_lock_owned()
+            .into_diagnostic()?;
+        index_writer.delete_all_documents().into_diagnostic()?;
+        self.get_bookmarks()?
+            .into_par_iter()
+            .filter_map(|x| index_writer.add_document(x.into()).ok())
+            .collect::<Vec<_>>();
+        index_writer.commit().into_diagnostic()?;
+        Ok(())
+    }
+
     pub fn upsert_bookmark(&self, bookmark: Bookmark) -> miette::Result<Option<Bookmark>> {
         let rw: transaction::RwTransaction<'_> =
             self.database.rw_transaction().into_diagnostic()?;
         let old_value: Option<Bookmark> = rw.upsert(bookmark.clone()).into_diagnostic()?;
         rw.commit().into_diagnostic()?;
+        self.bookmark_sender.send_replace(());
 
         let mut index_writer = BOOKMARK_INDEX_WRITER
             .clone()
@@ -170,6 +188,7 @@ impl BrowserDatabase {
             .filter_map(|bookmark| rw.upsert(bookmark).ok())
             .collect();
         rw.commit().into_diagnostic()?;
+        self.bookmark_sender.send_replace(());
 
         let mut index_writer = BOOKMARK_INDEX_WRITER
             .clone()
@@ -189,6 +208,7 @@ impl BrowserDatabase {
         let rw = self.database.rw_transaction().into_diagnostic()?;
         let removed_bookmark = rw.remove(bookmark).into_diagnostic()?;
         rw.commit().into_diagnostic()?;
+        self.bookmark_sender.send_replace(());
 
         let mut index_writer = BOOKMARK_INDEX_WRITER
             .clone()
@@ -207,6 +227,7 @@ impl BrowserDatabase {
             .filter_map(|bookmark| rw.remove(bookmark).ok())
             .collect();
         rw.commit().into_diagnostic()?;
+        self.bookmark_sender.send_replace(());
 
         let mut index_writer = BOOKMARK_INDEX_WRITER
             .clone()
@@ -231,8 +252,8 @@ impl BrowserDatabase {
             .into_diagnostic()?)
     }
 
-    pub fn get_bookmark(&self, original_uri: String) -> miette::Result<Option<Bookmark>> {
+    pub fn get_bookmark(&self, url: String) -> miette::Result<Option<Bookmark>> {
         let r = self.database.r_transaction().into_diagnostic()?;
-        Ok(r.get().primary(original_uri).into_diagnostic()?)
+        Ok(r.get().primary(url).into_diagnostic()?)
     }
 }

src/database/core.rs

@@ -19,6 +19,7 @@ pub(crate) static MODELS: LazyLock<Models> = LazyLock::new(|| {
 pub struct BrowserDatabase {
     pub(super) database: Database<'static>,
     pub history_sender: tokio::sync::watch::Sender<()>,
+    pub bookmark_sender: tokio::sync::watch::Sender<()>,
 }
 
 impl BrowserDatabase {
@@ -28,12 +29,16 @@ impl BrowserDatabase {
                 .create(&MODELS, &*DATABASE_PATH)
                 .into_diagnostic()?,
             history_sender: tokio::sync::watch::channel(()).0,
+            bookmark_sender: tokio::sync::watch::channel(()).0,
         };
         if database.get_history_records()?.len() as u64
             != HISTORY_RECORD_INDEX_READER.searcher().num_docs()
         {
             database.rebuild_history_record_index()?;
         }
+        if database.get_bookmarks()?.len() as u64 != BOOKMARK_INDEX_READER.searcher().num_docs() {
+            database.rebuild_bookmark_index()?;
+        }
         Ok(database)
     }
 

src/main.rs

@@ -21,6 +21,7 @@
     html_logo_url = "https://github.com/OkuBrowser/oku/raw/master/branding/logo-filled.svg",
     html_favicon_url = "https://github.com/OkuBrowser/oku/raw/master/branding/logo-filled.svg"
 )]
+pub mod bookmark_item;
 pub mod config;
 pub mod database;
 pub mod history_item;
@@ -320,6 +321,28 @@ async fn main() {
     application.connect_window_added(clone!(move |_, window| {
         let window: widgets::window::Window = window.clone().downcast().unwrap();
         let ctx = glib::MainContext::default();
+        let mut bookmark_rx = DATABASE.bookmark_sender.subscribe();
+        ctx.spawn_local_with_priority(
+            glib::source::Priority::HIGH,
+            clone!(
+                #[weak]
+                window,
+                async move {
+                    loop {
+                        bookmark_rx.borrow_and_update();
+                        info!("Bookmarks updated … ");
+                        window.bookmarks_updated();
+                        match bookmark_rx.changed().await {
+                            Ok(_) => continue,
+                            Err(e) => {
+                                error!("{}", e);
+                                break;
+                            }
+                        }
+                    }
+                }
+            ),
+        );
         let mut history_rx = DATABASE.history_sender.subscribe();
         ctx.spawn_local_with_priority(
             glib::source::Priority::HIGH,