Add implementation

imag-link/src/main.rs

@@ -9,13 +9,139 @@ extern crate libimagrt;
 extern crate libimagstore;
 extern crate libimagutil;
 
+use std::process::exit;
+use std::ops::Deref;
+use std::error::Error;
+
+use libimagrt::runtime::Runtime;
+use libimagstore::error::StoreError;
+use libimagstore::store::Entry;
+use libimagstore::store::FileLockEntry;
 use libimagstore::store::Store;
+use libimagutil::trace::trace_error;
 
 mod ui;
 
 use ui::build_ui;
 
 fn main() {
-    println!("Hello, world!");
+    let name = "imag-link";
+    let version = &version!()[..];
+    let about = "Link entries";
+    let ui = build_ui(Runtime::get_default_cli_builder(name, version, about));
+    let rt = {
+        let rt = Runtime::new(ui);
+        if rt.is_ok() {
+            rt.unwrap()
+        } else {
+            println!("Could not set up Runtime");
+            println!("{:?}", rt.err().unwrap());
+            exit(1);
+        }
+    };
+
+    rt.init_logger();
+
+    debug!("Hello. Logging was just enabled");
+    debug!("I already set up the Runtime object and build the commandline interface parser.");
+    debug!("Lets get rollin' ...");
+
+    rt.cli()
+        .subcommand_name()
+        .map(|name| {
+            match name {
+                "internal" => handle_internal_linking(&rt),
+                "external" => { unimplemented!() },
+                _ => {
+                    warn!("No commandline call");
+                    exit(1);
+                },
+            }
+        });
+}
+
+fn handle_internal_linking(rt: &Runtime) {
+    use libimaglink::internal::InternalLinker;
+    use libimagutil::trace::trace_error;
+
+    let mut from = {
+        let mut from = get_from_entry(&rt);
+        if from.is_none() {
+            warn!("No 'from' entry");
+            exit(1);
+        }
+        from.unwrap()
+    };
+    debug!("Link from = {:?}", from.deref());
+
+    let mut to = {
+        let mut to = get_to_entries(&rt);
+        if to.is_none() {
+            warn!("No 'to' entry");
+            exit(1);
+        }
+        to.unwrap()
+    };
+    debug!("Link to = {:?}", to.iter().map(|f| f.deref()).collect::<Vec<&Entry>>());
+
+    match rt.cli().subcommand_matches("internal").unwrap().subcommand_name() {
+        Some("add") => {
+            for mut to_entry in to {
+                if let Err(e) = to_entry.add_internal_link(&mut from) {
+                    trace_error(&e);
+                    exit(1);
+                }
+            }
+        },
+
+        Some("remove") => {
+            for mut to_entry in to {
+                if let Err(e) = to_entry.remove_internal_link(&mut from) {
+                    trace_error(&e);
+                    exit(1);
+                }
+            }
+        },
+
+        _ => unreachable!(),
+        // as the get_from_entry()/get_to_entries() would have errored
+    }
+}
+
+fn get_from_entry<'a>(rt: &'a Runtime) -> Option<FileLockEntry<'a>> {
+    rt.cli()
+        .subcommand_matches("internal")
+        .unwrap() // safe, we know there is an "internal" subcommand"
+        .value_of("from")
+        .and_then(|from_name| {
+            match get_entry_by_name(rt, from_name) {
+                Err(e) => { trace_error(&e); None },
+                Ok(e) => Some(e),
+            }
+
+        })
+}
+
+fn get_to_entries<'a>(rt: &'a Runtime) -> Option<Vec<FileLockEntry<'a>>> {
+    rt.cli()
+        .subcommand_matches("internal")
+        .unwrap() // safe, we know there is an "internal" subcommand"
+        .values_of("to")
+        .map(|values| {
+            let mut v = vec![];
+            for entry in values.map(|v| get_entry_by_name(rt, v)) {
+                match entry {
+                    Err(e) => trace_error(&e),
+                    Ok(e) => v.push(e),
+                }
+            }
+            v
+        })
+}
+
+fn get_entry_by_name<'a>(rt: &'a Runtime, name: &str) -> Result<FileLockEntry<'a>, StoreError> {
+    use libimagstore::storeid::build_entry_path;
+    build_entry_path(rt.store(), name)
+        .and_then(|path| rt.store().retrieve(path))
 }