Merge branch 'imag-bookmark-remove-collections' into master

Signed-off-by: Matthias Beyer <mail@beyermatthias.de>

bin/domain/imag-bookmark/Cargo.toml

@@ -25,11 +25,14 @@ toml = "0.5.1"
 toml-query = "0.9.2"
 failure = "0.1.5"
 resiter = "0.4.0"
+url = "2"
 
 libimagrt        = { version = "0.10.0", path = "../../../lib/core/libimagrt" }
 libimagerror     = { version = "0.10.0", path = "../../../lib/core/libimagerror" }
+libimagstore     = { version = "0.10.0", path = "../../../lib/core/libimagstore" }
 libimagbookmark  = { version = "0.10.0", path = "../../../lib/domain/libimagbookmark" }
 libimagentrylink = { version = "0.10.0", path = "../../../lib/entry/libimagentrylink" }
+libimagentryurl  = { version = "0.10.0", path = "../../../lib/entry/libimagentryurl" }
 libimagutil      = { version = "0.10.0", path = "../../../lib/etc/libimagutil" }
 
 [dependencies.clap]
@@ -37,6 +40,11 @@ version = "2.33.0"
 default-features = false
 features = ["color", "suggestions", "wrap_help"]
 
+[dependencies.uuid]
+version = "0.7"
+default-features = false
+features = ["serde", "v4"]
+
 [lib]
 name = "libimagbookmarkfrontend"
 path = "src/lib.rs"

bin/domain/imag-bookmark/src/lib.rs

@@ -37,6 +37,8 @@
 extern crate clap;
 #[macro_use] extern crate log;
 extern crate toml;
+extern crate url;
+extern crate uuid;
 extern crate toml_query;
 #[macro_use] extern crate failure;
 extern crate resiter;
@@ -44,25 +46,27 @@ extern crate resiter;
 extern crate libimagbookmark;
 extern crate libimagrt;
 extern crate libimagerror;
+extern crate libimagstore;
 extern crate libimagutil;
-extern crate libimagentrylink;
+extern crate libimagentryurl;
 
 use std::io::Write;
-use std::ops::DerefMut;
 
-use toml_query::read::TomlValueReadTypeExt;
 use failure::Error;
 use failure::err_msg;
 use failure::Fallible as Result;
 use resiter::AndThen;
+use resiter::IterInnerOkOrElse;
 use clap::App;
+use url::Url;
 
 use libimagrt::runtime::Runtime;
 use libimagrt::application::ImagApplication;
-use libimagbookmark::collection::BookmarkCollection;
+use libimagstore::iter::get::StoreIdGetIteratorExtension;
-use libimagbookmark::collection::BookmarkCollectionStore;
+use libimagbookmark::store::BookmarkStore;
-use libimagbookmark::link::Link as BookmarkLink;
+use libimagbookmark::bookmark::Bookmark;
-use libimagentrylink::linkable::Linkable;
+use libimagentryurl::link::Link;
+
 
 mod ui;
 
@@ -75,9 +79,9 @@ impl ImagApplication for ImagBookmark {
     fn run(rt: Runtime) -> Result<()> {
         match rt.cli().subcommand_name().ok_or_else(|| err_msg("No subcommand called"))? {
             "add"        => add(&rt),
-            "collection" => collection(&rt),
             "list"       => list(&rt),
             "remove"     => remove(&rt),
+            "find"       => find(&rt),
             other        => {
                 debug!("Unknown command");
                 if rt.handle_unknown_subcommand("imag-bookmark", other, rt.cli())?.success() {
@@ -108,105 +112,84 @@ impl ImagApplication for ImagBookmark {
 
 fn add(rt: &Runtime) -> Result<()> {
     let scmd = rt.cli().subcommand_matches("add").unwrap();
-    let coll = get_collection_name(rt, "add", "collection")?;
-
-    let mut collection = BookmarkCollectionStore::get(rt.store(), &coll)?
-        .ok_or_else(|| format_err!("No bookmark collection '{}' found", coll))?;
-
-    rt.report_touched(collection.get_location())?;
-
     scmd.values_of("urls")
         .unwrap()
         .into_iter()
-        .map(|url| {
+        .map(|s| Url::parse(s).map_err(Error::from))
-            let new_ids = BookmarkCollection::add_link(collection.deref_mut(), rt.store(), BookmarkLink::from(url))?;
+        .and_then_ok(|url| {
-            rt.report_all_touched(new_ids.into_iter()).map_err(Error::from)
+            let (uuid, fle) = rt.store().add_bookmark(url.clone())?;
+            debug!("Created entry for url '{}' with uuid '{}'", url, uuid);
+            info!("{} = {}", url, uuid);
+            rt.report_touched(fle.get_location()).map_err(Error::from)
         })
         .collect()
 }
 
-fn collection(rt: &Runtime) -> Result<()> {
-    let scmd = rt.cli().subcommand_matches("collection").unwrap();
-
-    if scmd.is_present("add") { // adding a new collection
-        let name = scmd.value_of("add").unwrap();
-        let id   = BookmarkCollectionStore::new(rt.store(), &name)?;
-        rt.report_touched(id.get_location())?;
-        info!("Created: {}", name);
-    }
-
-    if scmd.is_present("remove") { // remove a collection
-        let name = scmd.value_of("remove").unwrap();
-
-        { // remove all links
-            BookmarkCollectionStore::get(rt.store(), &name)?
-                .ok_or_else(|| format_err!("Collection does not exist: {}", name))?
-                .unlink(rt.store())?;
-        }
-
-        BookmarkCollectionStore::delete(rt.store(), &name)?;
-        info!("Deleted: {}", name);
-    }
-
-    Ok(())
-}
-
 fn list(rt: &Runtime) -> Result<()> {
-    let coll = get_collection_name(rt, "list", "collection")?;
+    rt.store()
+        .all_bookmarks()?
+        .into_get_iter()
+        .map_inner_ok_or_else(|| err_msg("Did not find one entry"))
+        .and_then_ok(|entry| {
+            if entry.is_bookmark()? {
+                let url = entry.get_url()?
+                    .ok_or_else(|| format_err!("Failed to retrieve URL for {}", entry.get_location()))?;
+                if !rt.output_is_pipe() {
+                    writeln!(rt.stdout(), "{}", url)?;
+                }
 
-    let collection = BookmarkCollectionStore::get(rt.store(), &coll)?
+                rt.report_touched(entry.get_location()).map_err(Error::from)
-        .ok_or_else(|| format_err!("No bookmark collection '{}' found", coll))?;
+            } else {
-
+                Ok(())
-    rt.report_touched(collection.get_location())?;
+            }
-
-    let mut i = 0; // poor mans enumerate()
-
-    collection
-        .get_links(rt.store())?
-        .and_then_ok(|link| {
-            let r = writeln!(rt.stdout(), "{: >3}: {}", i, link).map_err(Error::from);
-            i += 1;
-            r
         })
         .collect()
 }
 
 fn remove(rt: &Runtime) -> Result<()> {
-    let scmd = rt.cli().subcommand_matches("remove").unwrap();
+    rt.ids::<crate::ui::PathProvider>()?
-    let coll = get_collection_name(rt, "list", "collection")?;
+        .ok_or_else(|| err_msg("No ids supplied"))?
-
-    let mut collection = BookmarkCollectionStore::get(rt.store(), &coll)?
-        .ok_or_else(|| format_err!("No bookmark collection '{}' found", coll))?;
-
-    rt.report_touched(collection.get_location())?;
-
-    scmd.values_of("urls")
-        .unwrap()
         .into_iter()
-        .map(|url| {
+        .map(Ok)
-            let removed_links = BookmarkCollection::remove_link(collection.deref_mut(), rt.store(), BookmarkLink::from(url))?;
+        .into_get_iter(rt.store())
-            rt.report_all_touched(removed_links.into_iter()).map_err(Error::from)
+        .map_inner_ok_or_else(|| err_msg("Did not find one entry"))
+        .and_then_ok(|fle| {
+            rt.report_touched(fle.get_location())
+                .map_err(Error::from)
+                .and_then(|_| rt.store().remove_bookmark(fle))
         })
         .collect()
 }
 
+fn find(rt: &Runtime) -> Result<()> {
+    let substr = rt.cli().subcommand_matches("find").unwrap().value_of("substr").unwrap();
 
-fn get_collection_name(rt: &Runtime,
+    if let Some(ids) = rt.ids::<crate::ui::PathProvider>()? {
-                       subcommand_name: &str,
+        ids.into_iter()
-                       collection_argument_name: &str)
+            .map(Ok)
-    -> Result<String>
+            .into_get_iter(rt.store())
-{
-    if let Some(cn) = rt.cli()
-        .subcommand_matches(subcommand_name)
-        .and_then(|scmd| scmd.value_of(collection_argument_name).map(String::from))
-    {
-        return Ok(cn)
     } else {
-        rt.config().ok_or_else(|| err_msg("No configuration availablew"))
+        rt.store()
-            .and_then(|cfg| {
+            .all_bookmarks()?
-                cfg.read_string("bookmark.default_collection")?
+            .into_get_iter()
-                    .ok_or_else(|| err_msg("Missing config: 'bookmark.default_collection'."))
-            })
     }
+    .map_inner_ok_or_else(|| err_msg("Did not find one entry"))
+    .and_then_ok(|fle| {
+        if fle.is_bookmark()? {
+            let url = fle
+                .get_url()?
+                .ok_or_else(|| format_err!("Failed to retrieve URL for {}", fle.get_location()))?;
+            if url.as_str().contains(substr) {
+                if !rt.output_is_pipe() {
+                    writeln!(rt.stdout(), "{}", url)?;
+                }
+                rt.report_touched(fle.get_location()).map_err(Error::from)
+            } else {
+                Ok(())
+            }
+        } else {
+            Ok(())
+        }
+    })
+    .collect()
 }
-

bin/domain/imag-bookmark/src/ui.rs

@@ -17,23 +17,21 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 //
 
-use clap::{Arg, App, SubCommand};
+use std::path::PathBuf;
+
+use failure::Fallible as Result;
+use clap::{Arg, ArgMatches, App, SubCommand};
 
 use libimagutil::cli_validators::*;
+use libimagstore::storeid::StoreId;
+use libimagstore::storeid::IntoStoreId;
+use libimagrt::runtime::IdPathProvider;
 
 pub fn build_ui<'a>(app: App<'a, 'a>) -> App<'a, 'a> {
     app
         .subcommand(SubCommand::with_name("add")
                    .about("Add bookmarks")
                    .version("0.1")
-                   .arg(Arg::with_name("collection")
-                        .long("collection")
-                        .short("c")
-                        .takes_value(true)
-                        .required(false)
-                        .multiple(false)
-                        .value_name("COLLECTION")
-                        .help("Add to this collection, if not specified default from config will be used"))
                    .arg(Arg::with_name("urls")
                         .index(1)
                         .takes_value(true)
@@ -47,22 +45,13 @@ pub fn build_ui<'a>(app: App<'a, 'a>) -> App<'a, 'a> {
         .subcommand(SubCommand::with_name("remove")
                    .about("Remove bookmarks")
                    .version("0.1")
-                   .arg(Arg::with_name("collection")
+                   .arg(Arg::with_name("ids")
-                        .long("collection")
-                        .short("c")
-                        .takes_value(true)
-                        .required(false)
-                        .multiple(false)
-                        .value_name("COLLECTION")
-                        .help("Remove from this collection, if not specified default from config will be used"))
-                   .arg(Arg::with_name("urls")
                         .index(1)
                         .takes_value(true)
                         .required(true)
                         .multiple(true)
-                        .value_name("URL")
+                        .value_name("ID")
-                        .validator(is_url)
+                        .help("Remove these urls, specified as ID"))
-                        .help("Remove this url(s)"))
                    )
 
         // .subcommand(SubCommand::with_name("open")
@@ -79,32 +68,63 @@ pub fn build_ui<'a>(app: App<'a, 'a>) -> App<'a, 'a> {
         //            )
 
         .subcommand(SubCommand::with_name("list")
-                   .about("List bookmarks")
+                   .about("List bookmarks, if used in pipe, ignores everything that is not a bookmark")
                    .version("0.1")
-                   .arg(Arg::with_name("collection")
+
-                        .long("collection")
+                   .arg(Arg::with_name("ids")
-                        .short("c")
+                        .index(1)
                         .takes_value(true)
                         .required(false)
-                        .multiple(false)
+                        .multiple(true)
-                        .value_name("COLLECTION")
+                        .value_name("ID")
-                        .help("Select from this collection, if not specified default from config will be used"))
+                        .help("IDs of bookmarks to list"))
                    )
 
-        .subcommand(SubCommand::with_name("collection")
+        .subcommand(SubCommand::with_name("find")
-                   .about("Collection commands")
+                   .about("Find a bookmark by substring of URL")
                    .version("0.1")
-                   .arg(Arg::with_name("add")
+
-                        .long("add")
+                   .arg(Arg::with_name("substr")
-                        .short("a")
+                        .index(1)
                         .takes_value(true)
-                        .value_name("NAME")
+                        .required(true)
-                        .help("Add a collection with this name"))
+                        .multiple(false)
-                   .arg(Arg::with_name("remove")
+                        .value_name("str")
-                        .long("remove")
+                        .help("Substring to search in the URL."))
-                        .short("r")
+
+                   .arg(Arg::with_name("ids")
+                        .index(2)
                         .takes_value(true)
-                        .value_name("NAME")
+                        .required(false)
-                        .help("Remove a collection with this name (and all links)"))
+                        .multiple(true)
+                        .value_name("IDs")
+                        .help("IDs to search in (if not passed, searches all bookmarks. Can also be provided via STDIN"))
                    )
 }
+
+pub struct PathProvider;
+impl IdPathProvider for PathProvider {
+    fn get_ids(matches: &ArgMatches) -> Result<Option<Vec<StoreId>>> {
+        fn no_ids_error() -> Result<Option<Vec<StoreId>>> {
+            Err(format_err!("Command does not get IDs as input"))
+        }
+
+        fn get_id_paths(field: &str, subm: &ArgMatches) -> Result<Option<Vec<StoreId>>> {
+            subm.values_of(field)
+                .map(|v| v
+                     .map(PathBuf::from)
+                     .map(|pb| pb.into_storeid())
+                     .collect::<Result<Vec<_>>>()
+                )
+                .transpose()
+        }
+
+        match matches.subcommand() {
+            ("add", _) => no_ids_error(),
+            ("remove", Some(subm)) => get_id_paths("ids", subm),
+            ("list", Some(subm)) => get_id_paths("ids", subm),
+            ("find", Some(subm)) => get_id_paths("ids", subm),
+            (other, _) => Err(format_err!("Not a known command: {}", other)),
+        }
+    }
+}

lib/domain/libimagbookmark/Cargo.toml

@@ -28,4 +28,11 @@ libimagstore     = { version = "0.10.0", path = "../../../lib/core/libimagstore"
 libimagerror     = { version = "0.10.0", path = "../../../lib/core/libimagerror" }
 libimagentrylink = { version = "0.10.0", path = "../../../lib/entry/libimagentrylink" }
 libimagentryurl  = { version = "0.10.0", path = "../../../lib/entry/libimagentryurl" }
+libimagentryutil = { version = "0.10.0", path = "../../../lib/entry/libimagentryutil" }
+
+[dependencies.uuid]
+version = "0.7"
+default-features = false
+features = ["serde", "v4"]
+
 

lib/domain/libimagbookmark/src/bookmark.rs

@@ -17,60 +17,21 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 //
 
-use std::ops::{Deref, DerefMut};
-
 use failure::Fallible as Result;
-use failure::ResultExt;
-use failure::Error;
-use failure::err_msg;
 
-use url::Url;
+use libimagentryutil::isa::Is;
+use libimagentryutil::isa::IsKindHeaderPathProvider;
+use libimagstore::store::Entry;
 
-#[derive(Debug, Clone)]
+provide_kindflag_path!(pub IsBookmark, "bookmark.is_bookmark");
-pub struct Link(String);
 
-impl From<String> for Link {
+pub trait Bookmark {
+    fn is_bookmark(&self) -> Result<bool>;
+}
 
-    fn from(s: String) -> Link {
+impl Bookmark for Entry {
-        Link(s)
+    fn is_bookmark(&self) -> Result<bool> {
+        self.is::<IsBookmark>()
     }
-
-}
-
-impl<'a> From<&'a str> for Link {
-
-    fn from(s: &'a str) -> Link {
-        Link(String::from(s))
-    }
-
-}
-
-impl Deref for Link {
-    type Target = String;
-
-    fn deref(&self) -> &String {
-        &self.0
-    }
-
-}
-
-impl DerefMut for Link {
-
-    fn deref_mut(&mut self) -> &mut String {
-        &mut self.0
-    }
-
-}
-
-pub trait IntoUrl {
-    fn into_url(self) -> Result<Url>;
-}
-
-impl IntoUrl for Link {
-
-    fn into_url(self) -> Result<Url> {
-        Url::parse(&self[..]).context(err_msg("Link parsing error")).map_err(Error::from)
-    }
-
 }
 

lib/domain/libimagbookmark/src/collection.rs

@@ -1,191 +0,0 @@
-//
-// imag - the personal information management suite for the commandline
-// Copyright (C) 2015-2019 Matthias Beyer <mail@beyermatthias.de> and contributors
-//
-// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU Lesser General Public
-// License as published by the Free Software Foundation; version
-// 2.1 of the License.
-//
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-// Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public
-// License along with this library; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-//
-
-//! BookmarkCollection module
-//!
-//! A BookmarkCollection is nothing more than a simple store entry. One can simply call functions
-//! from the libimagentryurl::linker::UrlLinker trait on this to generate external links.
-//!
-//! The BookmarkCollection type offers helper functions to get all links or such things.
-
-use regex::Regex;
-
-use failure::Fallible as Result;
-use failure::ResultExt;
-use failure::Error;
-
-use libimagstore::store::Store;
-use libimagstore::store::Entry;
-use libimagstore::store::FileLockEntry;
-use libimagstore::storeid::StoreId;
-use libimagentryurl::linker::UrlLinker;
-use libimagentryurl::iter::UrlIter;
-use libimagentrylink::linkable::Linkable;
-use libimagentrylink::link::Link as StoreLink;
-
-use crate::link::Link;
-
-use self::iter::LinksMatchingRegexIter;
-
-pub trait BookmarkCollectionStore<'a> {
-    fn new(&'a self, name: &str)                     -> Result<FileLockEntry<'a>>;
-    fn get(&'a self, name: &str)                     -> Result<Option<FileLockEntry<'a>>>;
-    fn delete(&'a self, name: &str)                     -> Result<()>;
-}
-
-impl<'a> BookmarkCollectionStore<'a> for Store {
-
-    #[allow(clippy::new_ret_no_self)]
-    fn new(&'a self, name: &str) -> Result<FileLockEntry<'a>> {
-        crate::module_path::new_id(name)
-            .and_then(|id| self.create(id)
-                      .context("Failed to create FileLockEntry")
-                      .map_err(Error::from))
-            .context("Failed to create Id for new Bookmark Collection")
-            .map_err(Error::from)
-    }
-
-    fn get(&'a self, name: &str) -> Result<Option<FileLockEntry<'a>>> {
-        crate::module_path::new_id(name)
-            .and_then(|id| self.get(id)
-                      .context("Failed to get FileLockEntry")
-                      .map_err(Error::from))
-            .context("Failed to get Bookmark Collection")
-            .map_err(Error::from)
-    }
-
-    fn delete(&'a self, name: &str) -> Result<()> {
-        crate::module_path::new_id(name)
-            .and_then(|id| self.delete(id)
-                      .context("Failed to delete FileLockEntry")
-                      .map_err(Error::from))
-            .context("Failed to delete Bookmark Collection")
-            .map_err(Error::from)
-    }
-
-}
-
-pub trait BookmarkCollection : Sized + Linkable + UrlLinker {
-    fn get_links<'a>(&self, store: &'a Store)                    -> Result<UrlIter<'a>>;
-    fn link_entries(&self)                                       -> Result<Vec<StoreLink>>;
-    fn add_link(&mut self, store: &Store, l: Link)               -> Result<Vec<StoreId>>;
-    fn get_links_matching<'a>(&self, store: &'a Store, r: Regex) -> Result<LinksMatchingRegexIter<'a>>;
-    fn remove_link(&mut self, store: &Store, l: Link)            -> Result<Vec<StoreId>>;
-}
-
-impl BookmarkCollection for Entry {
-
-    fn get_links<'a>(&self, store: &'a Store) -> Result<UrlIter<'a>> {
-        self.get_urls(store)
-    }
-
-    #[allow(clippy::redundant_closure)]
-    fn link_entries(&self) -> Result<Vec<StoreLink>> {
-        use libimagentryurl::util::is_external_link_storeid;
-        self.links().map(|v| v.filter(|id| is_external_link_storeid(id)).collect())
-    }
-
-    fn add_link(&mut self, store: &Store, l: Link) -> Result<Vec<StoreId>> {
-        use crate::link::IntoUrl;
-        l.into_url().and_then(|url| self.add_url(store, url))
-    }
-
-    fn get_links_matching<'a>(&self, store: &'a Store, r: Regex) -> Result<LinksMatchingRegexIter<'a>> {
-        use self::iter::IntoLinksMatchingRegexIter;
-        self.get_urls(store).map(|iter| iter.matching_regex(r))
-    }
-
-    fn remove_link(&mut self, store: &Store, l: Link) -> Result<Vec<StoreId>> {
-        use crate::link::IntoUrl;
-        l.into_url().and_then(|url| self.remove_url(store, url))
-    }
-
-}
-
-pub mod iter {
-    use crate::link::Link;
-    use failure::Fallible as Result;
-    use regex::Regex;
-
-    use libimagentryurl::iter::UrlIter;
-
-    pub struct LinkIter<I>(I)
-        where I: Iterator<Item = Link>;
-
-    impl<I: Iterator<Item = Link>> LinkIter<I> {
-        pub fn new(i: I) -> LinkIter<I> {
-            LinkIter(i)
-        }
-    }
-
-    impl<I: Iterator<Item = Link>> Iterator for LinkIter<I> {
-        type Item = Link;
-
-        fn next(&mut self) -> Option<Self::Item> {
-            self.0.next()
-        }
-    }
-
-    impl<I> From<I> for LinkIter<I> where I: Iterator<Item = Link> {
-        fn from(i: I) -> LinkIter<I> {
-            LinkIter(i)
-        }
-    }
-
-    pub struct LinksMatchingRegexIter<'a>(UrlIter<'a>, Regex);
-
-    impl<'a> LinksMatchingRegexIter<'a> {
-        pub fn new(i: UrlIter<'a>, r: Regex) -> LinksMatchingRegexIter<'a> {
-            LinksMatchingRegexIter(i, r)
-        }
-    }
-
-    impl<'a> Iterator for LinksMatchingRegexIter<'a> {
-        type Item = Result<Link>;
-
-        fn next(&mut self) -> Option<Self::Item> {
-            loop {
-                let n = match self.0.next() {
-                    Some(Ok(n))  => n,
-                    Some(Err(e)) => return Some(Err(e)),
-                    None         => return None,
-                };
-
-                let s = n.into_string();
-                if self.1.is_match(&s[..]) {
-                    return Some(Ok(Link::from(s)))
-                } else {
-                    continue;
-                }
-            }
-        }
-    }
-
-    pub trait IntoLinksMatchingRegexIter<'a> {
-        fn matching_regex(self, _: Regex) -> LinksMatchingRegexIter<'a>;
-    }
-
-    impl<'a> IntoLinksMatchingRegexIter<'a> for UrlIter<'a> {
-        fn matching_regex(self, r: Regex) -> LinksMatchingRegexIter<'a> {
-            LinksMatchingRegexIter(self, r)
-        }
-    }
-
-}
-

lib/domain/libimagbookmark/src/lib.rs

@@ -38,15 +38,18 @@
 )]
 
 extern crate url;
+extern crate uuid;
 extern crate regex;
 #[macro_use] extern crate failure;
 
 #[macro_use] extern crate libimagstore;
+#[macro_use] extern crate libimagentryutil;
 extern crate libimagerror;
 extern crate libimagentrylink;
 extern crate libimagentryurl;
 
 module_entry_path_mod!("bookmark");
 
-pub mod collection;
+pub mod bookmark;
-pub mod link;
+pub mod store;
+

lib/domain/libimagbookmark/src/store.rs

@@ -0,0 +1,107 @@
+//
+// imag - the personal information management suite for the commandline
+// Copyright (C) 2015-2019 Matthias Beyer <mail@beyermatthias.de> and contributors
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; version
+// 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+//
+
+use failure::Fallible as Result;
+use uuid::Uuid;
+use url::Url;
+
+use libimagstore::store::Store;
+use libimagstore::storeid::StoreId;
+use libimagstore::store::FileLockEntry;
+use libimagstore::iter::Entries;
+use libimagentryurl::link::Link;
+use libimagentryutil::isa::Is;
+
+use crate::bookmark::IsBookmark;
+use crate::bookmark::Bookmark;
+
+pub trait BookmarkStore {
+
+    fn add_bookmark<'a>(&'a self, url: Url) -> Result<(Uuid, FileLockEntry<'a>)>;
+
+    fn get_bookmark_by_uuid<'a>(&'a self, uuid: &Uuid) -> Result<Option<FileLockEntry<'a>>>;
+    fn get_bookmark_by_id<'a>(&'a self, sid: StoreId) -> Result<Option<FileLockEntry<'a>>>;
+
+    fn remove_bookmark_by_uuid(&self, uuid: &Uuid) -> Result<()>;
+
+    fn remove_bookmark<'a>(&self, fle: FileLockEntry<'a>) -> Result<()>;
+
+    fn all_bookmarks<'a>(&'a self) -> Result<Entries<'a>>;
+
+}
+
+impl BookmarkStore for Store {
+    fn add_bookmark<'a>(&'a self, url: Url) -> Result<(Uuid, FileLockEntry<'a>)> {
+        let uuid = uuid::Uuid::new_v4();
+        id_for_uuid(&uuid)
+            .and_then(|id| self.create(id))
+            .and_then(|mut entry| {
+                entry.set_isflag::<IsBookmark>()?;
+                entry.set_url(url).map(|_| (uuid, entry))
+            })
+    }
+
+    fn get_bookmark_by_uuid<'a>(&'a self, uuid: &Uuid) -> Result<Option<FileLockEntry<'a>>> {
+        id_for_uuid(uuid).and_then(|id| self.get(id))
+    }
+
+    /// Get a bookmark by store id
+    ///
+    ///
+    /// # Warning
+    ///
+    /// Returns an error if the StoreId does not refer to an entry that is a Bookmark.
+    /// If you want to ignore these errors on this API level and handle these errors yourself,
+    /// use Store::get()
+    ///
+    fn get_bookmark_by_id<'a>(&'a self, sid: StoreId) -> Result<Option<FileLockEntry<'a>>> {
+        if let Some(entry) = self.get(sid)? {
+            if !entry.is_bookmark()? {
+                return Err(format_err!("Not a bookmark: {}", entry.get_location()));
+            } else {
+                Ok(Some(entry))
+            }
+        } else {
+            Ok(None)
+        }
+    }
+
+    fn remove_bookmark_by_uuid(&self, uuid: &Uuid) -> Result<()> {
+        id_for_uuid(uuid).and_then(|id| self.delete(id))
+    }
+
+    fn remove_bookmark<'a>(&self, fle: FileLockEntry<'a>) -> Result<()> {
+        if fle.is_bookmark()? {
+            let id = fle.get_location().clone();
+            drop(fle);
+            self.delete(id)
+        } else {
+            Err(format_err!("Not a bookmark: {}", fle.get_location()))
+        }
+    }
+
+    fn all_bookmarks<'a>(&'a self) -> Result<Entries<'a>> {
+        self.entries()?.in_collection("bookmark")
+    }
+}
+
+fn id_for_uuid(uuid: &Uuid) -> Result<StoreId> {
+    crate::module_path::new_id(uuid.to_hyphenated().encode_lower(&mut Uuid::encode_buffer()))
+}
+