Merge pull request #978 from matthiasbeyer/libimagstore/fixes

Libimagstore/fixes

libimagstore/src/file_abstraction/stdio/mapper/json.rs

@@ -33,7 +33,7 @@ use storeid::StoreId;
 
 use libimagerror::into::IntoError;
 
-#[derive(Deserialize, Serialize)]
+#[derive(Debug, Deserialize, Serialize)]
 struct BackendEntry {
     header: serde_json::Value,
     content: String,
@@ -53,7 +53,7 @@ impl BackendEntry {
 
 }
 
-#[derive(Deserialize, Serialize)]
+#[derive(Debug, Deserialize, Serialize)]
 struct Document {
     version: String,
     store: HashMap<PathBuf, BackendEntry>,
@@ -72,9 +72,13 @@ impl JsonMapper {
 impl Mapper for JsonMapper {
     fn read_to_fs<R: Read>(&self, r: &mut R, hm: &mut HashMap<PathBuf, Entry>)   -> Result<()> {
         let mut document = {
+            debug!("Reading Document");
             let mut s = String::new();
             try!(r.read_to_string(&mut s).map_err_into(SEK::IoError));
+            debug!("Document = {:?}", s);
+            debug!("Parsing Document");
             let doc : Document = try!(serde_json::from_str(&s).map_err_into(SEK::IoError));
+            debug!("Document = {:?}", doc);
             doc
         };
 
@@ -84,6 +88,10 @@ impl Mapper for JsonMapper {
                 // safe because cargo does not compile if crate version is not valid
                 let crate_version = ::semver::Version::parse(version!()).unwrap();
 
+                debug!("Document version vs. own version: {doc_vers} > {crate_vers}",
+                       doc_vers = doc_vers,
+                       crate_vers = crate_version);
+
                 if doc_vers > crate_version {
                     Err(SEK::VersionError.into_error())
                 } else {
@@ -92,9 +100,11 @@ impl Mapper for JsonMapper {
             }));
 
         for (key, val) in document.store.drain() {
+            debug!("(key, value) ({:?}, {:?})", key, val);
             let res = val
                 .to_string()
                 .and_then(|vals| {
+                    debug!("value string = {:?}", vals);
                     StoreId::new_baseless(key.clone())
                         .and_then(|id| Entry::from_str(id, &vals))
                         .map(|entry| hm.insert(key, entry))
@@ -153,6 +163,18 @@ mod test {
 
     use super::*;
 
+    #[test]
+    fn test_empty_json_to_fs() {
+        let json = r#"{"version":"0.3.0","store":{}}"#;
+        let mut json = Cursor::new(String::from(json).into_bytes());
+        let mapper   = JsonMapper::new();
+        let mut hm   = HashMap::new();
+
+        let io_res  = mapper.read_to_fs(&mut json, &mut hm);
+        assert!(io_res.is_ok());
+        assert!(hm.is_empty());
+    }
+
     #[test]
     fn test_json_to_fs() {
         let json = r#"

libimagstore/src/store.rs

@@ -105,21 +105,26 @@ impl Iterator for Walk {
     type Item = StoreObject;
 
     fn next(&mut self) -> Option<Self::Item> {
+
         while let Some(something) = self.dirwalker.next() {
+            debug!("[Walk] Processing next item: {:?}", something);
             match something {
                 Ok(next) => if next.file_type().is_dir() {
-                                return Some(StoreObject::Collection(next.path().to_path_buf()))
-                            } else if next.file_type().is_file() {
-                                let n   = next.path().to_path_buf();
-                                let sid = match StoreId::new(Some(self.store_path.clone()), n) {
-                                    Err(e) => {
-                                        trace_error(&e);
-                                        continue;
-                                    },
-                                    Ok(o) => o,
-                                };
-                                return Some(StoreObject::Id(sid))
-                            },
+                    debug!("Found directory...");
+                    return Some(StoreObject::Collection(next.path().to_path_buf()))
+                } else /* if next.file_type().is_file() */ {
+                    debug!("Found file...");
+                    let n   = next.path().to_path_buf();
+                    let sid = match StoreId::from_full_path(&self.store_path, n) {
+                        Err(e) => {
+                            debug!("Could not construct StoreId object from it");
+                            trace_error(&e);
+                            continue;
+                        },
+                        Ok(o) => o,
+                    };
+                    return Some(StoreObject::Id(sid))
+                },
                 Err(e) => {
                     warn!("Error in Walker");
                     debug!("{:?}", e);

libimagstore/src/storeid.rs

@@ -67,6 +67,7 @@ impl StoreId {
     }
 
     pub fn new_baseless(id: PathBuf) -> Result<StoreId> {
+        debug!("Trying to get a new baseless id from: {:?}", id);
         if id.is_absolute() {
             Err(SEK::StoreIdLocalPartAbsoluteError.into_error())
         } else {