Adding primitive file utilities

4 files changed, 87 insertions, 49 deletions

diff --git a/lockchain-files/examples/create.rs b/lockchain-files/examples/create.rs
index 67279a9..27d4ff9 100644
--- a/lockchain-files/examples/create.rs
+++ b/lockchain-files/examples/create.rs
@@ -8,18 +8,19 @@ use lcc::{EncryptedBody, Generator, Payload, Record, VaultType};
 use std::env;
 
 fn main() {
-    if env::args().len() == 3 {
-        let path = env::args().nth(1).unwrap();
-        let name = env::args().nth(2).unwrap();
-
-        let mut vault: FileVault<EncryptedBody> = Generator::new()
-            .path(name, path)
-            .user_type(VaultType::SoloUser {
-                username: "spacekookie".into(),
-                secret: "foobar3264".into(),
-            }).finalise()
-            .unwrap();
-        vault.sync();
+
+    // if env::args().len() == 3 {
+    //     let path = env::args().nth(1).unwrap();
+    //     let name = env::args().nth(2).unwrap();
+
+    //     let mut vault: FileVault<EncryptedBody> = Generator::new()
+    //         .path(name, path)
+    //         .user_type(VaultType::SoloUser {
+    //             username: "spacekookie".into(),
+    //             secret: "foobar3264".into(),
+    //         }).finalise()
+    //         .unwrap();
+    //     vault.sync();
 
     // let vault: FileVault<EncryptedBody> = FileVault::new(&name, &path);
 
@@ -40,7 +41,7 @@ fn main() {
     // vault.meta_push_domain(users);
     // vault.meta_push_domain(registry);
     // vault.sync();
-    } else {
-        eprintln!("Usage: create <path> <name> [FLAGS] (there are no flags)")
-    }
+    // } else {
+    //     eprintln!("Usage: create <path> <name> [FLAGS] (there are no flags)")
+    // }
 }
diff --git a/lockchain-files/src/fs/mod.rs b/lockchain-files/src/fs/mod.rs
index 6a6d898..eed860d 100644
--- a/lockchain-files/src/fs/mod.rs
+++ b/lockchain-files/src/fs/mod.rs
@@ -22,7 +22,7 @@ use std::{
 use utils::FileToString;
 use FileVault;
 
-mod primitive;
+pub mod primitive;
 use self::primitive::*;
 
 #[derive(Debug)]
@@ -78,10 +78,11 @@ impl Filesystem {
 
     /// Retrieve a single record from the cached vault
     pub fn pull<T: AutoEncoder>(&self, types: FileType, id: &str) -> Result<T, Box<Error>> {
-        Ok(T::decode(
-            &File::open(self.root.join(&format!("{}.{}", id, file_ending!(types))))?
-                .get_string()?,
-        )?)
+        // Ok(T::decode(
+        //     &File::open(self.root.join(&format!("{}.{}", id, file_ending!(types))))?
+        //         .get_string()?,
+        // )?)
+        unimplemented!()
     }
 
     pub fn sync_vault<T: Body>(&self, vault: &FileVault<T>) -> Result<(), io::Error> {
@@ -96,28 +97,29 @@ impl Filesystem {
     where
         T: AutoEncoder,
     {
-        data.into_iter()
-            .map(|(k, v)| (k, v.encode().ok()))
-            .map(|(k, v)| {
-                (
-                    match types {
-                        FileType::Record => self.root.join("records"),
-                        FileType::Metadata => self.root.join("metadata"),
-                        _ => self.root.join("."),
-                    }.join(format!("{}.{}", k, file_ending!(types))),
-                    v,
-                )
-            }).filter(|(_, v)| v.is_some())
-            .map(|(k, v)| (k, v.unwrap()))
-            .map(|(path, data): (PathBuf, String)| {
-                (OO::new().create(true).write(true).open(path), data)
-            }).filter(|(path, _)| path.is_ok())
-            .map(|(file, data)| (file.unwrap(), data))
-            .for_each(|(mut file, data)| {
-                file.write_all(data.as_bytes())
-                    .expect("Failed to write file!")
-            });
+        unimplemented!()
+        // data.into_iter()
+        //     .map(|(k, v)| (k, v.encode().ok()))
+        //     .map(|(k, v)| {
+        //         (
+        //             match types {
+        //                 FileType::Record => self.root.join("records"),
+        //                 FileType::Metadata => self.root.join("metadata"),
+        //                 _ => self.root.join("."),
+        //             }.join(format!("{}.{}", k, file_ending!(types))),
+        //             v,
+        //         )
+        //     }).filter(|(_, v)| v.is_some())
+        //     .map(|(k, v)| (k, v.unwrap()))
+        //     .map(|(path, data): (PathBuf, String)| {
+        //         (OO::new().create(true).write(true).open(path), data)
+        //     }).filter(|(path, _)| path.is_ok())
+        //     .map(|(file, data)| (file.unwrap(), data))
+        //     .for_each(|(mut file, data)| {
+        //         file.write_all(data.as_bytes())
+        //             .expect("Failed to write file!")
+        //     });
 
-        Ok(())
+        // Ok(())
     }
 }
diff --git a/lockchain-files/src/fs/primitive.rs b/lockchain-files/src/fs/primitive.rs
index 3723232..c5e13a3 100644
--- a/lockchain-files/src/fs/primitive.rs
+++ b/lockchain-files/src/fs/primitive.rs
@@ -2,6 +2,10 @@
 
 #![allow(dead_code)]
 
+use std::fs::OpenOptions;
+use std::io::{Read, Result, Write};
+use std::path::PathBuf;
+
 /// A set of files that exist inside a `FileVault`
 pub enum FileType {
     /// A data record file
@@ -20,15 +24,46 @@ pub enum FileType {
 macro_rules! file_ending {
     ($type:expr) => {
         match $type {
-            FileType::Record => "record",
-            FileType::Metadata => "meta",
-            FileType::Checksum => "sum",
-            FileType::Config => "cfg"
+            &FileType::Record => "record",
+            &FileType::Metadata => "meta",
+            &FileType::Checksum => "sum",
+            &FileType::Config => "cfg",
             _ => "dat",
         }
     };
 }
 
-pub fn write_file(tt: FileType) {}
+#[inline]
+fn type_path(tt: FileType, root: &PathBuf) -> PathBuf {
+    use self::FileType::*;
+    let mut path = root.clone();
+    match tt {
+        Record => path.push("records"),
+        Metadata => path.push("metadata"),
+        Checksum => path.push("checksums"),
+        _ => path.push("."),
+    };
+
+    path
+}
+
+pub fn write_file(tt: FileType, root: PathBuf, name: &str, contents: Vec<u8>) -> Result<()> {
+    let file_name = format!("{}.{}", name, file_ending!(&tt));
+    let mut path = type_path(tt, &root);
+    path.push(file_name);
 
-pub fn read_file() {}
+    let mut file = OpenOptions::new().write(true).create(true).open(path)?;
+    file.write_all(&contents)?;
+
+    Ok(())
+}
+
+pub(crate) fn read_file(tt: FileType, root: PathBuf, name: &str) -> Result<Vec<u8>> {
+    let file_name = format!("{}.{}", name, file_ending!(&tt));
+    let mut path = type_path(tt, &root);
+    path.push(file_name);
+
+    let mut file = OpenOptions::new().read(true).create(false).open(path)?;
+    let mut buffer = Vec::<u8>::new();
+    file.read_to_end(&mut buffer).map(|_| buffer)
+}
diff --git a/lockchain-files/src/lib.rs b/lockchain-files/src/lib.rs
index 611d260..1c88964 100644
--- a/lockchain-files/src/lib.rs
+++ b/lockchain-files/src/lib.rs
@@ -25,7 +25,7 @@ use std::default::Default;
 
 mod config;
 mod create;
-mod fs;
+pub mod fs;
 mod load;
 mod userstore;
 mod utils;