New user command

src/error.rs

@@ -8,7 +8,9 @@ pub enum Error {
     Git(git2::Error),
     JsonDecode(json::DecoderError),
     FolderNotEmpty(String, usize),
-    ArgumentNotFound,
+    InvalidPublicKey(String),
+    LoadProjectError,
+    DuplicateUser(String, String),
     TodoErr,
 }
 
@@ -19,7 +21,9 @@ impl error::Error for Error {
             Error::Git(_) => "Libgit2 error occurred",
             Error::JsonDecode(_) => "Json decoding error occurred",
             Error::FolderNotEmpty(_, _) => "Root folder was not empty",
-            Error::ArgumentNotFound => "Argument not found/matched",
+            Error::InvalidPublicKey(_) => "Invalid public key",
+            Error::LoadProjectError => "Loading project failed",
+            Error::DuplicateUser(_, _) => "User already exists",
             Error::TodoErr => "Todo",
         }
     }
@@ -30,7 +34,9 @@ impl error::Error for Error {
            Error::Git(ref err) => Some(err),
            Error::JsonDecode(ref err) => Some(err),
            Error::FolderNotEmpty(_, _) => None,
-           Error::ArgumentNotFound => None,
+           Error::InvalidPublicKey(_) => None,
+           Error::LoadProjectError => None,
+           Error::DuplicateUser(_, _) => None,
            Error::TodoErr => None,
        }
    }
@@ -47,8 +53,11 @@ impl fmt::Display for Error {
                 "Json decoding error occurred: {}", error::Error::description(err)),
             Error::FolderNotEmpty(ref root, count) => write!(f,
                 "{} was not empty: {} files exist", root, count),
-            Error::ArgumentNotFound => write!(f,
-                "Argument not found. Did you type it correctly?"),
+            Error::InvalidPublicKey(ref key) => write!(f, 
+                "Public key '{}' is invalid", key),
+            Error::LoadProjectError => write!(f, "Loading project failed"),
+            Error::DuplicateUser(ref key, ref user) => write!(f,
+                "Duplicate user '{}' or key '{}'", user, key),
             Error::TodoErr => write!(f, "TodoErr"),
         }
     }

src/init.rs

@@ -1,15 +1,14 @@
 //! This module initializes a project.
 
 use std::fs;
-use std::fs::File;
 use std::io::Write;
-use std::path::{Path, PathBuf};
+use std::path::Path;
 
-use rustc_serialize::json;
 use git2::{Oid, Repository, Signature};
 
+use utils;
 use Error;
-use project_types::Project;
+use Project;
 
 /// Initializes a new project at root. The root must either not exist, or must
 /// be an empty directory. This will
@@ -57,17 +56,8 @@ fn folder_not_empty(root: &Path, count: usize) -> Error {
 ///
 /// Impure.
 fn make_protonfile(root: &Path) -> Result<(), Error> {
-    // Create content
     let project = Project::empty();
-    let pretty_json = json::as_pretty_json(&project);
-
-    // Make path
-    let mut path = PathBuf::from(root);
-    path.push("Protonfile.json");
-
-    File::create(&path)
-        .and_then(|mut protonfile| write!(protonfile, "{}\n", pretty_json))
-        .map_err(Error::Io)
+    utils::write_protonfile(&project, Some(root))
 }
 
 /// Initializes a git repository at root.

src/lib.rs

@@ -1,11 +1,14 @@
 extern crate git2;
 extern crate rustc_serialize;
 
+pub mod utils;
 mod init;
+mod user;
 mod project_types;
 mod error;
 
 // Re-exports
 pub use error::*;
 pub use init::*;
+pub use user::*;
 pub use project_types::*;

src/main.rs

@@ -16,7 +16,7 @@ Command-line interface for Proton
 
 Usage:
   ./proton init <folder>
-  ./proton new-user <folder> <public-key> <name>
+  ./proton new-user <name> <public-key>
   ./proton (-h | --help)
 
 Options:
@@ -33,7 +33,6 @@ struct Args {
 }
 
 fn main() {
-
 	let args: Args = Docopt::new(USAGE)
 		.and_then(|d| d.decode())
 		.unwrap_or_else(|e| e.exit());
@@ -61,11 +60,8 @@ fn run_init(args: Args) -> Result<(), Error> {
 }
 
 fn run_new_user(args: Args) -> Result<(), Error> {
-	let folder = args.arg_folder.unwrap();
 	let public_key = args.arg_public_key.unwrap();
 	let public_key_path = Path::new(&public_key);
 	let name = args.arg_name.unwrap();
-	println!("{}, {}, {}", folder, public_key, name);
-	Ok(())
-	//proton_cli::add_user(folder, public_key_path, name)
+	proton_cli::new_user(&public_key_path, name)
 }

src/project_types.rs

@@ -1,24 +1,83 @@
+
+use Error;
+
 /// Structure to represent a Proton Project.
 /// This is what will be written to a Protonfile at the project root.
-#[derive(Debug, RustcEncodable, RustcDecodable)]
+#[derive(Clone, Debug, PartialEq, Eq, RustcEncodable, RustcDecodable)]
 pub struct Project {
     pub name: String,
+    pub users: Vec<User>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, RustcEncodable, RustcDecodable)]
+pub struct User {
+    pub name: String,
+    pub public_key: String,
 }
 
 impl Project {
     /// Creates an empty project
     pub fn empty() -> Project {
         Project {
             name: "New Project".to_owned(),
+            users: Vec::new(),
         }
     }
-}
 
-impl PartialEq for Project {
-    fn eq(&self, other: &Project) -> bool {
-        self.name == other.name
+    /// Finds a user with the given public key
+    /// Returns the user if found, else None
+    fn find_user_by_public_key(&self, pub_key: &str) -> Option<&User> {
+        for u in &self.users {
+            if u.public_key == pub_key {
+                return Some(u);
+            }
+        }
+        None::<&User>
+    }
+
+    /// Finds a user with the given name
+    /// Returns the user if found, else None
+    fn find_user_by_name(&self, name: &str) -> Option<&User> {
+        for u in &self.users {
+            if u.name == name {
+                return Some(u);
+            }
+        }
+        None::<&User>
+    }
+
+    /// Finds a user in the users vector
+    /// Returns true if found, else false
+    pub fn user_exists(&self, user: &User) -> bool {
+        for u in &self.users {
+            if user == u {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /// Adds a user to the project
+    pub fn add_user(&self, name: &str, pub_key: &str) -> Result<Project, Error> {
+
+        let user = User {
+            name: name.to_string(),
+            public_key: pub_key.to_string(),
+        };
+
+        if self.find_user_by_name(name).is_some() ||
+           self.find_user_by_public_key(pub_key).is_some() {
+
+            Err(self.duplicate_user(pub_key, name))
+        } else {
+            let mut new_project = self.clone();
+            new_project.users.push(user);
+            Ok(new_project)
+        }
+    }
+
+    fn duplicate_user(&self, pub_key: &str, name: &str) -> Error {
+        Error::DuplicateUser(pub_key.to_string(), name.to_string())
     }
-}
 
-impl Eq for Project {
 }

src/user.rs

@@ -0,0 +1,22 @@
+//! This module manages project users
+
+use std::path::Path;
+
+use Error;
+use utils;
+
+
+/// Creates a new user for the project in the current directory.
+/// Assumes the current directory contains a Protonfile.json file.
+///
+/// 1. Read the new user's public key from the file path given
+/// 2. Add the user's name and public key to the protonfile
+///
+/// Impure.
+pub fn new_user<P: AsRef<Path>>(public_key_path: P, name: String) -> Result<(), Error> {
+    let pub_key = try!(utils::file_as_string(public_key_path));
+    let project = try!(utils::read_protonfile(None::<P>));
+    let new_project = try!(project.add_user(&name, &pub_key));
+    utils::write_protonfile(&new_project, None::<P>)
+}
+

src/utils.rs

@@ -0,0 +1,52 @@
+use std::fs::File;
+use std::io::{Read, Write};
+use std::path::{Path, PathBuf};
+
+use rustc_serialize::json;
+
+use project_types::Project;
+use error::Error;
+
+
+/// Reads a Project from a Protonfile.
+/// Wraps any errors in proton_cli::Error
+/// Assumes Protonfile.json resides in the current directory
+/// unless a path to the Protonfile is given
+pub fn read_protonfile<P: AsRef<Path>>(pf_path: Option<P>) -> Result<Project, Error> {
+    let protonfile_path = build_protonfile_path(pf_path);
+    let protonfile = try!(file_as_string(&protonfile_path));
+    json::decode(&protonfile).map_err(Error::JsonDecode)
+}
+
+/// Saves a Project to a Protonfile.
+/// Assumes the Protonfile is in the current directory
+/// unless a path to the Protonfile is given
+pub fn write_protonfile<P: AsRef<Path>>(project: &Project, pf_path: Option<P>) -> Result<(), Error> {
+    let pretty_json = json::as_pretty_json(&project);
+    let protonfile_path = build_protonfile_path(pf_path);
+    File::create(&protonfile_path)
+        .and_then(|mut protonfile| write!(protonfile, "{}\n", pretty_json))
+        .map_err(Error::Io)
+}
+
+/// Reads a file as a string.
+/// Wraps Read::read_to_string errors in proton_cli::Error
+pub fn file_as_string<P: AsRef<Path>>(path: P) -> Result<String, Error> {
+    File::open(path)
+        .and_then(|mut file| {
+            let mut string = String::new();
+            file.read_to_string(&mut string)
+                .and_then(|_| Ok(string.trim().to_string()))           
+        })
+        .map_err(Error::Io)
+}
+
+fn build_protonfile_path<P: AsRef<Path>>(path_opt: Option<P>) -> PathBuf {
+    let mut protonfile_path = PathBuf::new();
+    let _ = match path_opt {
+        Some(path) => protonfile_path.push(path),
+        None => (),
+    };
+    protonfile_path.push("Protonfile.json");
+    protonfile_path
+}