diff --git a/bin/core/imag-annotate/src/main.rs b/bin/core/imag-annotate/src/main.rs index f86d71fa..a1ed5a7d 100644 --- a/bin/core/imag-annotate/src/main.rs +++ b/bin/core/imag-annotate/src/main.rs @@ -66,7 +66,7 @@ use libimagrt::runtime::Runtime; use libimagrt::setup::generate_runtime_setup; use libimagstore::store::FileLockEntry; use libimagstore::iter::get::StoreIdGetIteratorExtension; -use libimagentrylink::linker::InternalLinker; +use libimagentrylink::linker::Linkable; mod ui; @@ -124,7 +124,7 @@ fn add(rt: &Runtime) { .ok_or_else(|| format_err!("Not found: {}", id.local_display_string())) .map_err_trace_exit_unwrap(); - let _ = entry.add_internal_link(&mut annotation).map_err_trace_exit_unwrap(); + let _ = entry.add_link(&mut annotation).map_err_trace_exit_unwrap(); } if !scmd.is_present("dont-print-name") { diff --git a/bin/core/imag-diagnostics/src/main.rs b/bin/core/imag-diagnostics/src/main.rs index 5aa6844d..70b75ac7 100644 --- a/bin/core/imag-diagnostics/src/main.rs +++ b/bin/core/imag-diagnostics/src/main.rs @@ -55,7 +55,7 @@ use libimagerror::io::ToExitCode; use libimagerror::exit::ExitUnwrap; use libimagstore::store::FileLockEntry; use libimagstore::storeid::StoreId; -use libimagentrylink::linker::InternalLinker; +use libimagentrylink::linker::Linkable; use toml::Value; use toml_query::read::TomlValueReadExt; @@ -76,7 +76,7 @@ struct Diagnostic { pub bytecount_content: usize, pub overall_byte_size: usize, pub verified: bool, - pub num_internal_links: usize, + pub num_links: usize, } impl Diagnostic { @@ -100,7 +100,7 @@ impl Diagnostic { bytecount_content: entry.get_content().as_str().len(), overall_byte_size: entry.to_str()?.as_str().len(), verified: entry.verify().is_ok(), - num_internal_links: entry.get_internal_links().map(Iterator::count).unwrap_or(0), + num_links: entry.links().map(Iterator::count).unwrap_or(0), }) } } @@ -176,15 +176,15 @@ fn main() { let mut max_overall_byte_size : Option<(usize, StoreId)> = None; let mut verified_count = 0; let mut unverified_count = 0; - let mut num_internal_links = 0; - let mut max_internal_links : Option<(usize, StoreId)> = None; + let mut num_links = 0; + let mut max_links : Option<(usize, StoreId)> = None; for diag in diags.iter() { sum_header_sections += diag.header_sections; sum_bytecount_content += diag.bytecount_content; sum_overall_byte_size += diag.overall_byte_size; match max_overall_byte_size { - None => max_overall_byte_size = Some((diag.num_internal_links, diag.id.clone())), + None => max_overall_byte_size = Some((diag.num_links, diag.id.clone())), Some((num, _)) => if num < diag.overall_byte_size { max_overall_byte_size = Some((diag.overall_byte_size, diag.id.clone())); } @@ -199,11 +199,11 @@ fn main() { unverified_count += 1; } - num_internal_links += diag.num_internal_links; - match max_internal_links { - None => max_internal_links = Some((diag.num_internal_links, diag.id.clone())), - Some((num, _)) => if num < diag.num_internal_links { - max_internal_links = Some((diag.num_internal_links, diag.id.clone())); + num_links += diag.num_links; + match max_links { + None => max_links = Some((diag.num_links, diag.id.clone())), + Some((num, _)) => if num < diag.num_links { + max_links = Some((diag.num_links, diag.id.clone())); } } @@ -230,9 +230,9 @@ fn main() { do_write!(out, "Largest Entry ({} bytes): {}", num, path.local_display_string()); } - do_write!(out, "{} average internal link count per entry", num_internal_links / n); + do_write!(out, "{} average internal link count per entry", num_links / n); - if let Some((num, path)) = max_internal_links { + if let Some((num, path)) = max_links { do_write!(out, "Entry with most internal links ({}): {}", num, path.local_display_string()); diff --git a/bin/core/imag-link/src/main.rs b/bin/core/imag-link/src/main.rs index df717015..f671697c 100644 --- a/bin/core/imag-link/src/main.rs +++ b/bin/core/imag-link/src/main.rs @@ -63,7 +63,7 @@ use failure::Error; use failure::err_msg; use libimagentryurl::linker::UrlLinker; -use libimagentrylink::linker::InternalLinker; +use libimagentrylink::linker::Linkable; use libimagentrylink::storecheck::StoreLinkConsistentExt; use libimagerror::trace::{MapErrTrace, trace_error}; use libimagerror::exit::ExitUnwrap; @@ -182,7 +182,7 @@ fn link_from_to<'a, I>(rt: &'a Runtime, from: &'a str, to: I) }, }; let _ = from_entry - .add_internal_link(&mut to_entry) + .add_link(&mut to_entry) .map_err_trace_exit_unwrap(); let _ = rt.report_touched(to_entry.get_location()).unwrap_or_exit(); @@ -222,7 +222,7 @@ fn remove_linking(rt: &Runtime) { Err(e) => trace_error(&e), Ok(Some(mut to_entry)) => { let _ = to_entry - .remove_internal_link(&mut from) + .remove_link(&mut from) .map_err_trace_exit_unwrap(); let _ = rt.report_touched(to_entry.get_location()).unwrap_or_exit(); @@ -296,7 +296,7 @@ fn list_linkings(rt: &Runtime) { .for_each(|id| { match rt.store().get(id.clone()) { Ok(Some(entry)) => { - for (i, link) in entry.get_internal_links().map_err_trace_exit_unwrap().enumerate() { + for (i, link) in entry.links().map_err_trace_exit_unwrap().enumerate() { let link = link .to_str() .map_warn_err(|e| format!("Failed to convert StoreId to string: {:?}", e)) diff --git a/bin/core/imag-mv/src/main.rs b/bin/core/imag-mv/src/main.rs index 9eca7b35..37a1b603 100644 --- a/bin/core/imag-mv/src/main.rs +++ b/bin/core/imag-mv/src/main.rs @@ -56,7 +56,7 @@ use libimagerror::exit::ExitUnwrap; use libimagstore::storeid::StoreId; use libimagstore::store::Store; use libimagstore::store::FileLockEntry; -use libimagentrylink::linker::InternalLinker; +use libimagentrylink::linker::Linkable; use libimagstore::iter::get::StoreIdGetIteratorExtension; fn main() { @@ -93,7 +93,7 @@ fn main() { error!("Funny things happened: Entry moved to destination did not fail, but entry does not exist"); exit(1) }) - .get_internal_links() + .links() .map_err_trace_exit_unwrap() .map(|link| Ok(link.get_store_id().clone()) as Result<_, _>) .into_get_iter(rt.store()) @@ -118,7 +118,7 @@ fn main() { }); for link in linked_entries.iter_mut() { - let _ = entry.remove_internal_link(link).map_err_trace_exit_unwrap(); + let _ = entry.remove_link(link).map_err_trace_exit_unwrap(); } } @@ -151,6 +151,6 @@ fn relink<'a>(store: &'a Store, target: StoreId, linked_entries: &mut Vec BookmarkCollectionStore<'a> for Store { } -pub trait BookmarkCollection : Sized + InternalLinker + UrlLinker { - fn links<'a>(&self, store: &'a Store) -> Result>; +pub trait BookmarkCollection : Sized + Linkable + UrlLinker { + fn get_links<'a>(&self, store: &'a Store) -> Result>; fn link_entries(&self) -> Result>; fn add_link(&mut self, store: &Store, l: Link) -> Result>; fn get_links_matching<'a>(&self, store: &'a Store, r: Regex) -> Result>; @@ -90,13 +90,13 @@ pub trait BookmarkCollection : Sized + InternalLinker + UrlLinker { impl BookmarkCollection for Entry { - fn links<'a>(&self, store: &'a Store) -> Result> { + fn get_links<'a>(&self, store: &'a Store) -> Result> { self.get_urls(store) } fn link_entries(&self) -> Result> { use libimagentryurl::util::is_external_link_storeid; - self.get_internal_links().map(|v| v.filter(|id| is_external_link_storeid(id)).collect()) + self.links().map(|v| v.filter(|id| is_external_link_storeid(id)).collect()) } fn add_link(&mut self, store: &Store, l: Link) -> Result> { diff --git a/lib/domain/libimaghabit/src/habit.rs b/lib/domain/libimaghabit/src/habit.rs index bd203189..ef9a2064 100644 --- a/lib/domain/libimaghabit/src/habit.rs +++ b/lib/domain/libimaghabit/src/habit.rs @@ -33,7 +33,7 @@ use crate::util::IsHabitCheck; use crate::util::get_string_header_from_entry; use crate::instance::IsHabitInstance; -use libimagentrylink::linker::InternalLinker; +use libimagentrylink::linker::Linkable; use libimagstore::store::Store; use libimagstore::store::FileLockEntry; use libimagstore::store::Entry; @@ -129,7 +129,7 @@ impl HabitTemplate for Entry { fn linked_instances(&self) -> Result { let iter = self - .get_internal_links()? + .links()? .map(|link| link.get_store_id().clone()) .filter(IsHabitCheck::is_habit_instance) .map(Ok); @@ -239,7 +239,7 @@ impl HabitTemplate for Entry { let name = self.habit_name()?; let date = date_to_string(date); - for link in self.get_internal_links()? { + for link in self.links()? { let sid = link.get_store_id(); let instance_id = instance_id_for_name_and_datestr(&name, &date)?; @@ -410,7 +410,7 @@ fn postprocess_instance<'a>(mut entry: FileLockEntry<'a>, let _ = hdr.insert("habit.instance.comment", Value::String(comment))?; } - entry.add_internal_link(template)?; + entry.add_link(template)?; Ok(entry) } diff --git a/lib/domain/libimagwiki/src/entry.rs b/lib/domain/libimagwiki/src/entry.rs index 9ced2299..be5bdb0e 100644 --- a/lib/domain/libimagwiki/src/entry.rs +++ b/lib/domain/libimagwiki/src/entry.rs @@ -55,8 +55,8 @@ impl WikiEntry for Entry { /// fn autolink(&mut self, store: &Store) -> Result<()> { let processor = LinkProcessor::default() - .process_internal_links(true) - .create_internal_targets(true) + .process_links(true) + .create_targets(true) .process_urls(true) .process_refs(true); diff --git a/lib/domain/libimagwiki/src/wiki.rs b/lib/domain/libimagwiki/src/wiki.rs index 9cd3d236..55624370 100644 --- a/lib/domain/libimagwiki/src/wiki.rs +++ b/lib/domain/libimagwiki/src/wiki.rs @@ -22,7 +22,7 @@ use std::path::PathBuf; use libimagstore::store::Store; use libimagstore::store::FileLockEntry; use libimagstore::iter::Entries; -use libimagentrylink::linker::InternalLinker; +use libimagentrylink::linker::Linkable; use failure::Fallible as Result; use failure::Error; @@ -78,7 +78,7 @@ impl<'a, 'b> Wiki<'a, 'b> { .ok_or_else(|| err_msg("Missing index page"))?; let mut entry = self.0.create(sid)?; - entry.add_internal_link(&mut index).map(|_| entry) + entry.add_link(&mut index).map(|_| entry) } pub fn retrieve_entry>(&self, entry_name: EN) -> Result> { @@ -89,7 +89,7 @@ impl<'a, 'b> Wiki<'a, 'b> { .ok_or_else(|| err_msg("Missing index page"))?; let mut entry = self.0.retrieve(sid)?; - entry.add_internal_link(&mut index).map(|_| entry) + entry.add_link(&mut index).map(|_| entry) } pub fn all_ids(&self) -> Result> { diff --git a/lib/entry/libimagentryannotation/src/annotateable.rs b/lib/entry/libimagentryannotation/src/annotateable.rs index f89ca631..ee4b8a0f 100644 --- a/lib/entry/libimagentryannotation/src/annotateable.rs +++ b/lib/entry/libimagentryannotation/src/annotateable.rs @@ -24,7 +24,7 @@ use libimagstore::store::Entry; use libimagstore::store::FileLockEntry; use libimagstore::store::Store; use libimagstore::storeid::StoreIdIterator; -use libimagentrylink::linker::InternalLinker; +use libimagentrylink::linker::Linkable; use libimagentryutil::isa::Is; use libimagentryutil::isa::IsKindHeaderPathProvider; @@ -62,7 +62,7 @@ impl Annotateable for Entry { Ok(anno) }) .and_then(|mut anno| { - anno.add_internal_link(self) + anno.add_link(self) .context(err_msg("Linking error")) .map_err(Error::from) .map(|_| anno) @@ -74,7 +74,7 @@ impl Annotateable for Entry { // exist. fn denotate<'a>(&mut self, store: &'a Store, ann_name: &str) -> Result>> { if let Some(mut annotation) = store.get(crate::module_path::new_id(ann_name)?)? { - let _ = self.remove_internal_link(&mut annotation)?; + let _ = self.remove_link(&mut annotation)?; Ok(Some(annotation)) } else { // error: annotation does not exist @@ -84,7 +84,7 @@ impl Annotateable for Entry { /// Get all annotations of an entry fn annotations(&self) -> Result { - self.get_internal_links() + self.links() .map(|it| { it.filter(|link| link.get_store_id().is_in_collection(&["annotation"])) .map(|link| Ok(link.get_store_id().clone())) diff --git a/lib/entry/libimagentrycategory/src/category.rs b/lib/entry/libimagentrycategory/src/category.rs index f33a7ed5..fac4b821 100644 --- a/lib/entry/libimagentrycategory/src/category.rs +++ b/lib/entry/libimagentrycategory/src/category.rs @@ -22,7 +22,7 @@ use libimagentryutil::isa::IsKindHeaderPathProvider; use libimagstore::store::Entry; use libimagstore::store::Store; use libimagstore::storeid::StoreIdIterator; -use libimagentrylink::linker::InternalLinker; +use libimagentrylink::linker::Linkable; use toml_query::read::TomlValueReadTypeExt; @@ -57,7 +57,7 @@ impl Category for Entry { fn get_entries<'a>(&self, store: &'a Store) -> Result> { trace!("Getting linked entries for category '{:?}'", self.get_location()); - let sit = self.get_internal_links()?.map(|l| l.get_store_id().clone()).map(Ok); + let sit = self.links()?.map(|l| l.get_store_id().clone()).map(Ok); let sit = StoreIdIterator::new(Box::new(sit)); let name = self.get_name()?; Ok(CategoryEntryIterator::new(store, sit, name)) diff --git a/lib/entry/libimagentrycategory/src/entry.rs b/lib/entry/libimagentrycategory/src/entry.rs index a9e39da0..1d9166c4 100644 --- a/lib/entry/libimagentrycategory/src/entry.rs +++ b/lib/entry/libimagentrycategory/src/entry.rs @@ -23,7 +23,7 @@ use toml_query::read::TomlValueReadTypeExt; use toml::Value; use libimagstore::store::Entry; -use libimagentrylink::linker::InternalLinker; +use libimagentrylink::linker::Linkable; use libimagerror::errors::ErrorMsg as EM; use failure::Fallible as Result; @@ -68,7 +68,7 @@ impl EntryCategory for Entry { .ok_or_else(|| Error::from(err_msg("Category does not exist")))?; let _ = self.set_category(s)?; - let _ = self.add_internal_link(&mut category)?; + let _ = self.add_link(&mut category)?; Ok(()) } diff --git a/lib/entry/libimagentrycategory/src/store.rs b/lib/entry/libimagentrycategory/src/store.rs index 3f0f7df2..f8bafb23 100644 --- a/lib/entry/libimagentrycategory/src/store.rs +++ b/lib/entry/libimagentrycategory/src/store.rs @@ -84,7 +84,7 @@ impl CategoryStore for Store { /// /// Automatically removes all category settings from entries which are linked to this category. fn delete_category(&self, name: &str) -> Result<()> { - use libimagentrylink::linker::InternalLinker; + use libimagentrylink::linker::Linkable; use crate::category::Category; trace!("Deleting category: '{}'", name); @@ -97,7 +97,7 @@ impl CategoryStore for Store { for entry in category.get_entries(self)? { let mut entry = entry?; - let _ = category.remove_internal_link(&mut entry)?; + let _ = category.remove_link(&mut entry)?; } } diff --git a/lib/entry/libimagentrylink/src/linker.rs b/lib/entry/libimagentrylink/src/linker.rs index a94a5707..e8eaf630 100644 --- a/lib/entry/libimagentrylink/src/linker.rs +++ b/lib/entry/libimagentrylink/src/linker.rs @@ -35,27 +35,27 @@ use crate::link::Link; use toml::Value; -pub trait InternalLinker { +pub trait Linkable { /// Get the internal links from the implementor object - fn get_internal_links(&self) -> Result; + fn links(&self) -> Result; /// Add an internal link to the implementor object - fn add_internal_link(&mut self, link: &mut Entry) -> Result<()>; + fn add_link(&mut self, link: &mut Entry) -> Result<()>; /// Remove an internal link from the implementor object - fn remove_internal_link(&mut self, link: &mut Entry) -> Result<()>; + fn remove_link(&mut self, link: &mut Entry) -> Result<()>; /// Remove _all_ internal links fn unlink(&mut self, store: &Store) -> Result<()>; /// Add internal annotated link - fn add_internal_annotated_link(&mut self, link: &mut Entry, annotation: String) -> Result<()>; + fn add_annotated_link(&mut self, link: &mut Entry, annotation: String) -> Result<()>; } -impl InternalLinker for Entry { +impl Linkable for Entry { - fn get_internal_links(&self) -> Result { + fn links(&self) -> Result { debug!("Getting internal links"); trace!("Getting internal links from header of '{}' = {:?}", self.get_location(), self.get_header()); let res = self @@ -69,13 +69,13 @@ impl InternalLinker for Entry { process_rw_result(res) } - fn add_internal_link(&mut self, link: &mut Entry) -> Result<()> { + fn add_link(&mut self, link: &mut Entry) -> Result<()> { debug!("Adding internal link: {:?}", link); let location = link.get_location().clone().into(); - add_internal_link_with_instance(self, link, location) + add_link_with_instance(self, link, location) } - fn remove_internal_link(&mut self, link: &mut Entry) -> Result<()> { + fn remove_link(&mut self, link: &mut Entry) -> Result<()> { debug!("Removing internal link: {:?}", link); // Cloning because of borrowing @@ -84,13 +84,13 @@ impl InternalLinker for Entry { debug!("Removing internal link from {:?} to {:?}", own_loc, other_loc); - let links = link.get_internal_links()?; + let links = link.links()?; debug!("Rewriting own links for {:?}, without {:?}", other_loc, own_loc); let links = links.filter(|l| !l.eq_store_id(&own_loc)); let _ = rewrite_links(link.get_header_mut(), links)?; - self.get_internal_links() + self.links() .and_then(|links| { debug!("Rewriting own links for {:?}, without {:?}", own_loc, other_loc); let links = links.filter(|l| !l.eq_store_id(&other_loc)); @@ -99,9 +99,9 @@ impl InternalLinker for Entry { } fn unlink(&mut self, store: &Store) -> Result<()> { - for id in self.get_internal_links()?.map(|l| l.get_store_id().clone()) { + for id in self.links()?.map(|l| l.get_store_id().clone()) { match store.get(id).context("Failed to get entry")? { - Some(mut entry) => self.remove_internal_link(&mut entry)?, + Some(mut entry) => self.remove_link(&mut entry)?, None => return Err(err_msg("Link target does not exist")), } } @@ -109,23 +109,23 @@ impl InternalLinker for Entry { Ok(()) } - fn add_internal_annotated_link(&mut self, link: &mut Entry, annotation: String) -> Result<()> { + fn add_annotated_link(&mut self, link: &mut Entry, annotation: String) -> Result<()> { let new_link = Link::Annotated { link: link.get_location().clone(), annotation: annotation, }; - add_internal_link_with_instance(self, link, new_link) + add_link_with_instance(self, link, new_link) } } -fn add_internal_link_with_instance(this: &mut Entry, link: &mut Entry, instance: Link) -> Result<()> { +fn add_link_with_instance(this: &mut Entry, link: &mut Entry, instance: Link) -> Result<()> { debug!("Adding internal link from {:?} to {:?}", this.get_location(), instance); add_foreign_link(link, this.get_location().clone()) .and_then(|_| { - this.get_internal_links() + this.links() .and_then(|links| { let links = links.chain(LinkIter::new(vec![instance])); rewrite_links(this.get_header_mut(), links) @@ -156,7 +156,7 @@ fn rewrite_links>(header: &mut Value, links: I) -> Resu /// This is a helper function which does this. fn add_foreign_link(target: &mut Entry, from: StoreId) -> Result<()> { debug!("Linking back from {:?} to {:?}", target.get_location(), from); - target.get_internal_links() + target.links() .and_then(|links| { let links = links .chain(LinkIter::new(vec![from.into()])) @@ -258,7 +258,7 @@ mod test { use libimagstore::store::Store; - use super::InternalLinker; + use super::Linkable; use super::Link; fn setup_logging() { @@ -274,7 +274,7 @@ mod test { setup_logging(); let store = get_store(); let entry = store.create(PathBuf::from("test_new_entry_no_links")).unwrap(); - let links = entry.get_internal_links(); + let links = entry.links(); assert!(links.is_ok()); let links = links.unwrap(); assert_eq!(links.collect::>().len(), 0); @@ -285,16 +285,16 @@ mod test { setup_logging(); let store = get_store(); let mut e1 = store.create(PathBuf::from("test_link_two_entries1")).unwrap(); - assert!(e1.get_internal_links().is_ok()); + assert!(e1.links().is_ok()); let mut e2 = store.create(PathBuf::from("test_link_two_entries2")).unwrap(); - assert!(e2.get_internal_links().is_ok()); + assert!(e2.links().is_ok()); { - assert!(e1.add_internal_link(&mut e2).is_ok()); + assert!(e1.add_link(&mut e2).is_ok()); - let e1_links = e1.get_internal_links().unwrap().collect::>(); - let e2_links = e2.get_internal_links().unwrap().collect::>(); + let e1_links = e1.links().unwrap().collect::>(); + let e2_links = e2.links().unwrap().collect::>(); debug!("1 has links: {:?}", e1_links); debug!("2 has links: {:?}", e2_links); @@ -307,14 +307,14 @@ mod test { } { - assert!(e1.remove_internal_link(&mut e2).is_ok()); + assert!(e1.remove_link(&mut e2).is_ok()); debug!("{:?}", e2.to_str()); - let e2_links = e2.get_internal_links().unwrap().collect::>(); + let e2_links = e2.links().unwrap().collect::>(); assert_eq!(e2_links.len(), 0, "Expected [], got: {:?}", e2_links); debug!("{:?}", e1.to_str()); - let e1_links = e1.get_internal_links().unwrap().collect::>(); + let e1_links = e1.links().unwrap().collect::>(); assert_eq!(e1_links.len(), 0, "Expected [], got: {:?}", e1_links); } @@ -331,69 +331,69 @@ mod test { let mut e4 = store.retrieve(PathBuf::from("4")).unwrap(); let mut e5 = store.retrieve(PathBuf::from("5")).unwrap(); - assert!(e1.add_internal_link(&mut e2).is_ok()); + assert!(e1.add_link(&mut e2).is_ok()); - assert_eq!(e1.get_internal_links().unwrap().collect::>().len(), 1); - assert_eq!(e2.get_internal_links().unwrap().collect::>().len(), 1); - assert_eq!(e3.get_internal_links().unwrap().collect::>().len(), 0); - assert_eq!(e4.get_internal_links().unwrap().collect::>().len(), 0); - assert_eq!(e5.get_internal_links().unwrap().collect::>().len(), 0); + assert_eq!(e1.links().unwrap().collect::>().len(), 1); + assert_eq!(e2.links().unwrap().collect::>().len(), 1); + assert_eq!(e3.links().unwrap().collect::>().len(), 0); + assert_eq!(e4.links().unwrap().collect::>().len(), 0); + assert_eq!(e5.links().unwrap().collect::>().len(), 0); - assert!(e1.add_internal_link(&mut e3).is_ok()); + assert!(e1.add_link(&mut e3).is_ok()); - assert_eq!(e1.get_internal_links().unwrap().collect::>().len(), 2); - assert_eq!(e2.get_internal_links().unwrap().collect::>().len(), 1); - assert_eq!(e3.get_internal_links().unwrap().collect::>().len(), 1); - assert_eq!(e4.get_internal_links().unwrap().collect::>().len(), 0); - assert_eq!(e5.get_internal_links().unwrap().collect::>().len(), 0); + assert_eq!(e1.links().unwrap().collect::>().len(), 2); + assert_eq!(e2.links().unwrap().collect::>().len(), 1); + assert_eq!(e3.links().unwrap().collect::>().len(), 1); + assert_eq!(e4.links().unwrap().collect::>().len(), 0); + assert_eq!(e5.links().unwrap().collect::>().len(), 0); - assert!(e1.add_internal_link(&mut e4).is_ok()); + assert!(e1.add_link(&mut e4).is_ok()); - assert_eq!(e1.get_internal_links().unwrap().collect::>().len(), 3); - assert_eq!(e2.get_internal_links().unwrap().collect::>().len(), 1); - assert_eq!(e3.get_internal_links().unwrap().collect::>().len(), 1); - assert_eq!(e4.get_internal_links().unwrap().collect::>().len(), 1); - assert_eq!(e5.get_internal_links().unwrap().collect::>().len(), 0); + assert_eq!(e1.links().unwrap().collect::>().len(), 3); + assert_eq!(e2.links().unwrap().collect::>().len(), 1); + assert_eq!(e3.links().unwrap().collect::>().len(), 1); + assert_eq!(e4.links().unwrap().collect::>().len(), 1); + assert_eq!(e5.links().unwrap().collect::>().len(), 0); - assert!(e1.add_internal_link(&mut e5).is_ok()); + assert!(e1.add_link(&mut e5).is_ok()); - assert_eq!(e1.get_internal_links().unwrap().collect::>().len(), 4); - assert_eq!(e2.get_internal_links().unwrap().collect::>().len(), 1); - assert_eq!(e3.get_internal_links().unwrap().collect::>().len(), 1); - assert_eq!(e4.get_internal_links().unwrap().collect::>().len(), 1); - assert_eq!(e5.get_internal_links().unwrap().collect::>().len(), 1); + assert_eq!(e1.links().unwrap().collect::>().len(), 4); + assert_eq!(e2.links().unwrap().collect::>().len(), 1); + assert_eq!(e3.links().unwrap().collect::>().len(), 1); + assert_eq!(e4.links().unwrap().collect::>().len(), 1); + assert_eq!(e5.links().unwrap().collect::>().len(), 1); - assert!(e5.remove_internal_link(&mut e1).is_ok()); + assert!(e5.remove_link(&mut e1).is_ok()); - assert_eq!(e1.get_internal_links().unwrap().collect::>().len(), 3); - assert_eq!(e2.get_internal_links().unwrap().collect::>().len(), 1); - assert_eq!(e3.get_internal_links().unwrap().collect::>().len(), 1); - assert_eq!(e4.get_internal_links().unwrap().collect::>().len(), 1); - assert_eq!(e5.get_internal_links().unwrap().collect::>().len(), 0); + assert_eq!(e1.links().unwrap().collect::>().len(), 3); + assert_eq!(e2.links().unwrap().collect::>().len(), 1); + assert_eq!(e3.links().unwrap().collect::>().len(), 1); + assert_eq!(e4.links().unwrap().collect::>().len(), 1); + assert_eq!(e5.links().unwrap().collect::>().len(), 0); - assert!(e4.remove_internal_link(&mut e1).is_ok()); + assert!(e4.remove_link(&mut e1).is_ok()); - assert_eq!(e1.get_internal_links().unwrap().collect::>().len(), 2); - assert_eq!(e2.get_internal_links().unwrap().collect::>().len(), 1); - assert_eq!(e3.get_internal_links().unwrap().collect::>().len(), 1); - assert_eq!(e4.get_internal_links().unwrap().collect::>().len(), 0); - assert_eq!(e5.get_internal_links().unwrap().collect::>().len(), 0); + assert_eq!(e1.links().unwrap().collect::>().len(), 2); + assert_eq!(e2.links().unwrap().collect::>().len(), 1); + assert_eq!(e3.links().unwrap().collect::>().len(), 1); + assert_eq!(e4.links().unwrap().collect::>().len(), 0); + assert_eq!(e5.links().unwrap().collect::>().len(), 0); - assert!(e3.remove_internal_link(&mut e1).is_ok()); + assert!(e3.remove_link(&mut e1).is_ok()); - assert_eq!(e1.get_internal_links().unwrap().collect::>().len(), 1); - assert_eq!(e2.get_internal_links().unwrap().collect::>().len(), 1); - assert_eq!(e3.get_internal_links().unwrap().collect::>().len(), 0); - assert_eq!(e4.get_internal_links().unwrap().collect::>().len(), 0); - assert_eq!(e5.get_internal_links().unwrap().collect::>().len(), 0); + assert_eq!(e1.links().unwrap().collect::>().len(), 1); + assert_eq!(e2.links().unwrap().collect::>().len(), 1); + assert_eq!(e3.links().unwrap().collect::>().len(), 0); + assert_eq!(e4.links().unwrap().collect::>().len(), 0); + assert_eq!(e5.links().unwrap().collect::>().len(), 0); - assert!(e2.remove_internal_link(&mut e1).is_ok()); + assert!(e2.remove_link(&mut e1).is_ok()); - assert_eq!(e1.get_internal_links().unwrap().collect::>().len(), 0); - assert_eq!(e2.get_internal_links().unwrap().collect::>().len(), 0); - assert_eq!(e3.get_internal_links().unwrap().collect::>().len(), 0); - assert_eq!(e4.get_internal_links().unwrap().collect::>().len(), 0); - assert_eq!(e5.get_internal_links().unwrap().collect::>().len(), 0); + assert_eq!(e1.links().unwrap().collect::>().len(), 0); + assert_eq!(e2.links().unwrap().collect::>().len(), 0); + assert_eq!(e3.links().unwrap().collect::>().len(), 0); + assert_eq!(e4.links().unwrap().collect::>().len(), 0); + assert_eq!(e5.links().unwrap().collect::>().len(), 0); } @@ -405,18 +405,18 @@ mod test { let mut e1 = store.retrieve(PathBuf::from("1")).unwrap(); let mut e2 = store.retrieve(PathBuf::from("2")).unwrap(); - assert_eq!(e1.get_internal_links().unwrap().collect::>().len(), 0); - assert_eq!(e2.get_internal_links().unwrap().collect::>().len(), 0); + assert_eq!(e1.links().unwrap().collect::>().len(), 0); + assert_eq!(e2.links().unwrap().collect::>().len(), 0); - assert!(e1.add_internal_link(&mut e2).is_ok()); + assert!(e1.add_link(&mut e2).is_ok()); - assert_eq!(e1.get_internal_links().unwrap().collect::>().len(), 1); - assert_eq!(e2.get_internal_links().unwrap().collect::>().len(), 1); + assert_eq!(e1.links().unwrap().collect::>().len(), 1); + assert_eq!(e2.links().unwrap().collect::>().len(), 1); - assert!(e1.remove_internal_link(&mut e2).is_ok()); + assert!(e1.remove_link(&mut e2).is_ok()); - assert_eq!(e1.get_internal_links().unwrap().collect::>().len(), 0); - assert_eq!(e2.get_internal_links().unwrap().collect::>().len(), 0); + assert_eq!(e1.links().unwrap().collect::>().len(), 0); + assert_eq!(e2.links().unwrap().collect::>().len(), 0); } #[test] @@ -428,40 +428,40 @@ mod test { let mut e2 = store.retrieve(PathBuf::from("2")).unwrap(); let mut e3 = store.retrieve(PathBuf::from("3")).unwrap(); - assert_eq!(e1.get_internal_links().unwrap().collect::>().len(), 0); - assert_eq!(e2.get_internal_links().unwrap().collect::>().len(), 0); - assert_eq!(e3.get_internal_links().unwrap().collect::>().len(), 0); + assert_eq!(e1.links().unwrap().collect::>().len(), 0); + assert_eq!(e2.links().unwrap().collect::>().len(), 0); + assert_eq!(e3.links().unwrap().collect::>().len(), 0); - assert!(e1.add_internal_link(&mut e2).is_ok()); // 1-2 - assert!(e1.add_internal_link(&mut e3).is_ok()); // 1-2, 1-3 + assert!(e1.add_link(&mut e2).is_ok()); // 1-2 + assert!(e1.add_link(&mut e3).is_ok()); // 1-2, 1-3 - assert_eq!(e1.get_internal_links().unwrap().collect::>().len(), 2); - assert_eq!(e2.get_internal_links().unwrap().collect::>().len(), 1); - assert_eq!(e3.get_internal_links().unwrap().collect::>().len(), 1); + assert_eq!(e1.links().unwrap().collect::>().len(), 2); + assert_eq!(e2.links().unwrap().collect::>().len(), 1); + assert_eq!(e3.links().unwrap().collect::>().len(), 1); - assert!(e2.add_internal_link(&mut e3).is_ok()); // 1-2, 1-3, 2-3 + assert!(e2.add_link(&mut e3).is_ok()); // 1-2, 1-3, 2-3 - assert_eq!(e1.get_internal_links().unwrap().collect::>().len(), 2); - assert_eq!(e2.get_internal_links().unwrap().collect::>().len(), 2); - assert_eq!(e3.get_internal_links().unwrap().collect::>().len(), 2); + assert_eq!(e1.links().unwrap().collect::>().len(), 2); + assert_eq!(e2.links().unwrap().collect::>().len(), 2); + assert_eq!(e3.links().unwrap().collect::>().len(), 2); - assert!(e1.remove_internal_link(&mut e2).is_ok()); // 1-3, 2-3 + assert!(e1.remove_link(&mut e2).is_ok()); // 1-3, 2-3 - assert_eq!(e1.get_internal_links().unwrap().collect::>().len(), 1); - assert_eq!(e2.get_internal_links().unwrap().collect::>().len(), 1); - assert_eq!(e3.get_internal_links().unwrap().collect::>().len(), 2); + assert_eq!(e1.links().unwrap().collect::>().len(), 1); + assert_eq!(e2.links().unwrap().collect::>().len(), 1); + assert_eq!(e3.links().unwrap().collect::>().len(), 2); - assert!(e1.remove_internal_link(&mut e3).is_ok()); // 2-3 + assert!(e1.remove_link(&mut e3).is_ok()); // 2-3 - assert_eq!(e1.get_internal_links().unwrap().collect::>().len(), 0); - assert_eq!(e2.get_internal_links().unwrap().collect::>().len(), 1); - assert_eq!(e3.get_internal_links().unwrap().collect::>().len(), 1); + assert_eq!(e1.links().unwrap().collect::>().len(), 0); + assert_eq!(e2.links().unwrap().collect::>().len(), 1); + assert_eq!(e3.links().unwrap().collect::>().len(), 1); - assert!(e2.remove_internal_link(&mut e3).is_ok()); + assert!(e2.remove_link(&mut e3).is_ok()); - assert_eq!(e1.get_internal_links().unwrap().collect::>().len(), 0); - assert_eq!(e2.get_internal_links().unwrap().collect::>().len(), 0); - assert_eq!(e3.get_internal_links().unwrap().collect::>().len(), 0); + assert_eq!(e1.links().unwrap().collect::>().len(), 0); + assert_eq!(e2.links().unwrap().collect::>().len(), 0); + assert_eq!(e3.links().unwrap().collect::>().len(), 0); } #[test] @@ -471,11 +471,11 @@ mod test { let mut entry1 = store.create(PathBuf::from("test_link_annotating-1")).unwrap(); let mut entry2 = store.create(PathBuf::from("test_link_annotating-2")).unwrap(); - let res = entry1.add_internal_annotated_link(&mut entry2, String::from("annotation")); + let res = entry1.add_annotated_link(&mut entry2, String::from("annotation")); assert!(res.is_ok()); { - for link in entry1.get_internal_links().unwrap() { + for link in entry1.links().unwrap() { match link { Link::Annotated {annotation, ..} => assert_eq!(annotation, "annotation"), _ => assert!(false, "Non-annotated link found"), @@ -484,7 +484,7 @@ mod test { } { - for link in entry2.get_internal_links().unwrap() { + for link in entry2.links().unwrap() { match link { Link::Id {..} => {}, Link::Annotated {..} => assert!(false, "Annotated link found"), diff --git a/lib/entry/libimagentrylink/src/storecheck.rs b/lib/entry/libimagentrylink/src/storecheck.rs index decf4cdd..e0a89499 100644 --- a/lib/entry/libimagentrylink/src/storecheck.rs +++ b/lib/entry/libimagentrylink/src/storecheck.rs @@ -62,7 +62,7 @@ impl StoreLinkConsistentExt for Store { debug!("Checking entry = {:?}", entry.get_location()); let internal_links = entry - .get_internal_links()? + .links()? .into_getter(store); // get the FLEs from the Store let mut linking = Linking::default(); diff --git a/lib/entry/libimagentrymarkdown/src/processor.rs b/lib/entry/libimagentrymarkdown/src/processor.rs index c2626f4d..5b3a67cf 100644 --- a/lib/entry/libimagentrymarkdown/src/processor.rs +++ b/lib/entry/libimagentrymarkdown/src/processor.rs @@ -25,7 +25,7 @@ use failure::Error; use crate::link::extract_links; use libimagentryurl::linker::UrlLinker; -use libimagentrylink::linker::InternalLinker; +use libimagentrylink::linker::Linkable; use libimagentryref::reference::MutRef; use libimagentryref::reference::RefFassade; use libimagentryref::hasher::sha1::Sha1Hasher; @@ -56,8 +56,8 @@ use url::Url; /// There's no LinkProcessor::new() function, please use `LinkProcessor::default()`. /// pub struct LinkProcessor { - process_internal_links: bool, - create_internal_targets: bool, + process_links: bool, + create_targets: bool, process_urls: bool, process_refs: bool } @@ -68,8 +68,8 @@ impl LinkProcessor { /// /// Internal links are links which are simply `dirctory/file`, but not `/directory/file`, as /// beginning an id with `/` is discouraged in imag. - pub fn process_internal_links(mut self, b: bool) -> Self { - self.process_internal_links = b; + pub fn process_links(mut self, b: bool) -> Self { + self.process_links = b; self } @@ -78,8 +78,8 @@ impl LinkProcessor { /// If a link points to a non-existing imag entry, a `false` here will cause the processor to /// return an error from `process()`. A `true` setting will create the entry and then fetch it /// to link it to the processed entry. - pub fn create_internal_targets(mut self, b: bool) -> Self { - self.create_internal_targets = b; + pub fn create_targets(mut self, b: bool) -> Self { + self.create_targets = b; self } @@ -121,14 +121,14 @@ impl LinkProcessor { /// /// # Warning /// - /// When `LinkProcessor::create_internal_targets()` was called to set the setting to true, this + /// When `LinkProcessor::create_targets()` was called to set the setting to true, this /// function returns all errors returned by the Store. /// /// That means: /// - /// * For an internal link, the linked target is created if create_internal_targets() is true, + /// * For an internal link, the linked target is created if create_targets() is true, /// else error - /// * For an external link, if create_internal_targets() is true, libimagentrylink creates the + /// * For an external link, if create_targets() is true, libimagentrylink creates the /// external link entry, else the link is ignored /// * all other cases do not create elements in the store /// @@ -139,19 +139,19 @@ impl LinkProcessor { trace!("Processing {:?}", link); match LinkQualification::qualify(&link.link) { LinkQualification::InternalLink => { - if !self.process_internal_links { + if !self.process_links { continue } let id = StoreId::new(PathBuf::from(&link.link))?; - let mut target = if self.create_internal_targets { + let mut target = if self.create_targets { store.retrieve(id)? } else { store.get(id.clone())? .ok_or_else(|| Error::from(format_err!("Store get error: {}", id)))? }; - let _ = entry.add_internal_link(&mut target)?; + let _ = entry.add_link(&mut target)?; }, LinkQualification::ExternalLink(url) => { if !self.process_urls { @@ -212,7 +212,7 @@ impl LinkProcessor { trace!("Ready processing, linking new ref entry..."); - let _ = entry.add_internal_link(&mut ref_entry)?; + let _ = entry.add_link(&mut ref_entry)?; }, LinkQualification::Undecidable(e) => { // error @@ -271,8 +271,8 @@ impl LinkQualification { impl Default for LinkProcessor { fn default() -> Self { LinkProcessor { - process_internal_links: true, - create_internal_targets: false, + process_links: true, + create_targets: false, process_urls: true, process_refs: false } @@ -286,7 +286,7 @@ mod tests { use std::path::PathBuf; use libimagstore::store::Store; - use libimagentrylink::linker::InternalLinker; + use libimagentrylink::linker::Linkable; fn setup_logging() { let _ = ::env_logger::try_init(); @@ -328,8 +328,8 @@ mod tests { let _ = store.create(PathBuf::from("test-2.2")).unwrap(); let processor = LinkProcessor::default() - .process_internal_links(true) - .create_internal_targets(false) + .process_links(true) + .create_targets(false) .process_urls(false) .process_refs(false); @@ -337,7 +337,7 @@ mod tests { assert!(result.is_ok(), "Should be Ok(()): {:?}", result); { - let base_links = base.get_internal_links(); + let base_links = base.links(); assert!(base_links.is_ok()); let base_links : Vec<_> = base_links.unwrap().collect(); @@ -347,7 +347,7 @@ mod tests { { let link = store.get(PathBuf::from("test-2.2")).unwrap().unwrap(); - let link_links = link.get_internal_links(); + let link_links = link.links(); assert!(link_links.is_ok()); let link_links : Vec<_> = link_links.unwrap().collect(); @@ -368,8 +368,8 @@ mod tests { assert!(update.is_ok()); let processor = LinkProcessor::default() - .process_internal_links(true) - .create_internal_targets(false) + .process_links(true) + .create_targets(false) .process_urls(false) .process_refs(false); @@ -389,8 +389,8 @@ mod tests { assert!(update.is_ok()); let processor = LinkProcessor::default() - .process_internal_links(true) - .create_internal_targets(true) + .process_links(true) + .create_targets(true) .process_urls(false) .process_refs(false); @@ -398,7 +398,7 @@ mod tests { assert!(result.is_ok(), "Should be Ok(()): {:?}", result); { - let base_links = base.get_internal_links(); + let base_links = base.links(); assert!(base_links.is_ok()); let base_links : Vec<_> = base_links.unwrap().collect(); @@ -408,7 +408,7 @@ mod tests { { let link = store.get(PathBuf::from("test-2.2")).unwrap().unwrap(); - let link_links = link.get_internal_links(); + let link_links = link.links(); assert!(link_links.is_ok()); let link_links : Vec<_> = link_links.unwrap().collect(); @@ -429,8 +429,8 @@ mod tests { assert!(update.is_ok()); let processor = LinkProcessor::default() - .process_internal_links(true) - .create_internal_targets(true) + .process_links(true) + .create_targets(true) .process_urls(true) .process_refs(false); @@ -440,7 +440,7 @@ mod tests { // The hash of "http://example.com" processed in the `libimagentrylink` way. let expected_link = "url/external/9c17e047f58f9220a7008d4f18152fee4d111d14"; { - let base_links = base.get_internal_links(); + let base_links = base.links(); assert!(base_links.is_ok()); let base_links : Vec<_> = base_links.unwrap().collect(); @@ -456,7 +456,7 @@ mod tests { { let link = store.get(PathBuf::from(expected_link)).unwrap().unwrap(); - let link_links = link.get_internal_links(); + let link_links = link.links(); assert!(link_links.is_ok()); let link_links : Vec<_> = link_links.unwrap().collect(); @@ -479,8 +479,8 @@ mod tests { assert!(update.is_ok()); let processor = LinkProcessor::default() - .process_internal_links(false) - .create_internal_targets(false) + .process_links(false) + .create_targets(false) .process_urls(false) .process_refs(true); @@ -512,8 +512,8 @@ mod tests { assert!(update.is_ok()); let processor = LinkProcessor::default() - .process_internal_links(false) - .create_internal_targets(false) + .process_links(false) + .create_targets(false) .process_urls(false) .process_refs(true); @@ -545,8 +545,8 @@ mod tests { assert!(update.is_ok()); let processor = LinkProcessor::default() - .process_internal_links(false) - .create_internal_targets(false) + .process_links(false) + .create_targets(false) .process_urls(false) .process_refs(false); @@ -573,8 +573,8 @@ mod tests { assert!(update.is_ok()); let processor = LinkProcessor::default() - .process_internal_links(true) - .create_internal_targets(true) + .process_links(true) + .create_targets(true) .process_urls(false) .process_refs(false); @@ -589,7 +589,7 @@ mod tests { } #[test] - fn test_process_one_existing_file_linked_with_internal_processing_switched_off() { + fn test_process_one_existing_file_linked_with_processing_switched_off() { setup_logging(); let store = get_store(); @@ -603,8 +603,8 @@ mod tests { let _ = store.create(PathBuf::from("test-2.2")).unwrap(); let processor = LinkProcessor::default() - .process_internal_links(false) - .create_internal_targets(false) + .process_links(false) + .create_targets(false) .process_urls(false) .process_refs(false); diff --git a/lib/entry/libimagentryurl/src/iter.rs b/lib/entry/libimagentryurl/src/iter.rs index cfa0ccf5..73c5f135 100644 --- a/lib/entry/libimagentryurl/src/iter.rs +++ b/lib/entry/libimagentryurl/src/iter.rs @@ -79,7 +79,7 @@ impl Iterator for ExternalFilterIter { /// # See also /// /// Also see `OnlyExternalIter` and `NoExternalIter` and the helper traits/functions -/// `OnlyInteralLinks`/`only_internal_links()` and `OnlyExternalLinks`/`only_urls()`. +/// `OnlyInteralLinks`/`only_links()` and `OnlyExternalLinks`/`only_urls()`. pub trait SelectExternal { fn select_urls(self, b: bool) -> ExternalFilterIter; } @@ -130,7 +130,7 @@ impl Iterator for NoExternalIter { pub trait OnlyExternalLinks : Sized { fn only_urls(self) -> OnlyExternalIter ; - fn no_internal_links(self) -> OnlyExternalIter { + fn no_links(self) -> OnlyExternalIter { self.only_urls() } } @@ -142,15 +142,15 @@ impl OnlyExternalLinks for LinkIter { } pub trait OnlyInternalLinks : Sized { - fn only_internal_links(self) -> NoExternalIter; + fn only_links(self) -> NoExternalIter; fn no_urls(self) -> NoExternalIter { - self.only_internal_links() + self.only_links() } } impl OnlyInternalLinks for LinkIter { - fn only_internal_links(self) -> NoExternalIter { + fn only_links(self) -> NoExternalIter { NoExternalIter::new(self) } } diff --git a/lib/entry/libimagentryurl/src/linker.rs b/lib/entry/libimagentryurl/src/linker.rs index fe98ade3..978f7804 100644 --- a/lib/entry/libimagentryurl/src/linker.rs +++ b/lib/entry/libimagentryurl/src/linker.rs @@ -23,7 +23,7 @@ use libimagstore::storeid::StoreId; use libimagstore::store::Store; use libimagstore::store::Entry; use libimagutil::debug_result::DebugResult; -use libimagentrylink::linker::InternalLinker; +use libimagentrylink::linker::Linkable; use failure::Fallible as Result; use toml::Value; @@ -36,7 +36,7 @@ use hex; use crate::iter::UrlIter; -pub trait UrlLinker : InternalLinker { +pub trait UrlLinker : Linkable { /// Get the external links from the implementor object fn get_urls<'a>(&self, store: &'a Store) -> Result>; @@ -64,7 +64,7 @@ impl UrlLinker for Entry { // Iterate through all internal links and filter for FileLockEntries which live in // /link/external/ -> load these files and get the external link from their headers, // put them into the return vector. - self.get_internal_links() + self.links() .map(|iter| { debug!("Getting external links"); iter.only_urls().urls(store) @@ -130,7 +130,7 @@ impl UrlLinker for Entry { } // then add an internal link to the new file or return an error if this fails - let _ = self.add_internal_link(file.deref_mut())?; + let _ = self.add_link(file.deref_mut())?; debug!("Added internal link"); Ok((link_already_exists, file_id))