[Ninan] Add cloen command

Author: leoOrion

src/clone.rs

@@ -0,0 +1,78 @@
+use std::path::Path;
+
+use clap::{App, Arg, SubCommand};
+use colored::*;
+use git2::build::RepoBuilder;
+use git2::Error as GitError;
+use serde::{Deserialize, Serialize};
+
+use crate::git::GitAction;
+use crate::input_args::InputArgs;
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct GitRepo {
+    #[serde(alias = "remoteURL")]
+    #[serde(rename = "remoteURL")]
+    remote_url: String,
+    #[serde(alias = "localPath")]
+    #[serde(rename = "localPath")]
+    local_path: String,
+}
+
+pub fn sub_command<'a, 'b>() -> App<'a, 'b> {
+    SubCommand::with_name("clone")
+        .arg(Arg::with_name("local_path")
+            .short("l")
+            .takes_value(true)
+            .default_value(".")
+            .help("path at which to create the local repo. Defaults to '.'"))
+        .arg(Arg::with_name("repo_url")
+            .short("r")
+            .takes_value(true)
+            .multiple(true)
+            .help("the remote git repo url"))
+}
+
+// gg clone -r url1 -r url2 -l local_root_path
+// In addition to arguments passed, also check conf file. If 2 entries conflict from file and passed entry, use the passed entry to resolve the conflict.
+// Arguments can have only one local path at which to clone. If user wishes multiple paths, they have to use a config file.
+// Todo: test conflicting entries from arguments and file.
+pub fn clone(args: InputArgs, mut clone_repos: Vec<GitRepo>) {
+    let matches = args.get_matches();
+
+    let remote_urls: Vec<&str> = matches.values_of("repo_url").expect("failed getting remote_urls from user").collect();
+    let local_path = matches.value_of("local_path").expect("failed parsing local path from arguments");
+
+    let mut remotes_from_args: Vec<GitRepo> = vec![];
+    for remote in remote_urls {
+        let repo = GitRepo {
+            remote_url: remote.to_string(),
+            local_path: local_path.to_string(),
+        };
+        remotes_from_args.push(repo);
+    }
+
+    remotes_from_args.append(&mut clone_repos);
+
+    for remote in remotes_from_args {
+        let mut clone = GitClone { remote_url: remote.remote_url.as_str(), local_path: Path::new(remote.local_path.as_str()) };
+        clone.git_action().expect(format!("Failed to clone repo {}, ", remote.remote_url).as_str());
+    }
+}
+
+pub struct GitClone<'a> {
+    pub remote_url: &'a str,
+    pub local_path: &'a Path,
+}
+
+// Todo: Add spinner to show progress.
+impl<'a> GitAction for GitClone<'a> {
+    fn git_action(&mut self) -> Result<(), GitError> {
+        RepoBuilder::new()
+            .clone(self.remote_url, self.local_path)?;
+        println!("{} - {} {} {:#?}", "Remote repo".green(), self.remote_url.blue(), "cloned locally at".green(),
+                 self.local_path.as_os_str());
+
+        Ok(())
+    }
+}

src/conf.rs

@@ -1,32 +1,54 @@
 use std::error::Error;
 use std::fs;
 use std::path::Path;
-use serde::{Deserialize, Serialize};
 
 use regex::Regex;
+use serde::{Deserialize, Serialize};
 
+use crate::clone::GitRepo;
+
+// Todo: This will never be serialized. Try removing Serialize.
 #[derive(Debug, Serialize, Deserialize)]
 pub struct GGConf {
     #[serde(alias = "skipDirectories")]
     #[serde(rename = "skipDirectories")]
     filter_list: Vec<String>,
     #[serde(skip)]
     pub filter_list_regex: Vec<Regex>,
+    #[serde(alias = "cloneRepos")]
+    #[serde(rename = "cloneRepos")]
+    // Todo: Add validations on this field. It should not allow empty key/values.
+    pub clone_repos: Vec<GitRepo>,
+}
+
+impl GGConf {
+    pub fn default() -> GGConf {
+        GGConf {
+            filter_list: vec![],
+            filter_list_regex: vec![],
+            clone_repos: vec![],
+        }
+    }
 }
 
 pub fn read_conf_file(conf_file: &str) -> Result<GGConf, Box<dyn Error>> {
     if Path::new(conf_file).exists() {
         let file = fs::File::open(conf_file)?;
-        let config: GGConf = serde_yaml::from_reader(file)?;
-        let updated_conf = create_filter_list(config)?;
-        return Ok(updated_conf);
+        let mut config: GGConf = serde_yaml::from_reader(file)?;
+        update_conf_file(&mut config)?;
+        return Ok(config);
     }
-    let default = GGConf { filter_list: vec![], filter_list_regex: vec![] };
-    let updated_conf = create_filter_list(default)?;
-    Ok(updated_conf)
+    let mut default = GGConf::default();
+    update_conf_file(&mut default)?;
+    Ok(default)
+}
+
+fn update_conf_file(conf: &mut GGConf) -> Result<&mut GGConf, Box<dyn Error>> {
+    create_filter_list(conf)?;
+    Ok(conf)
 }
 
-fn create_filter_list(conf: GGConf) -> Result<GGConf, Box<dyn Error>> {
+fn create_filter_list(conf: &mut GGConf) -> Result<&mut GGConf, Box<dyn Error>> {
     let mut filter_list = Vec::new();
     let mut filters = conf.filter_list.clone();
     let defaults: Vec<String> = [".idea", ".DS_Store"].iter().map(|&s| s.into()).collect();
@@ -39,6 +61,7 @@ fn create_filter_list(conf: GGConf) -> Result<GGConf, Box<dyn Error>> {
         filter_list.push(re);
     });
 
-    let updated_conf = GGConf { filter_list: conf.filter_list, filter_list_regex: filter_list };
-    Ok(updated_conf)
+    conf.filter_list = filters;
+    conf.filter_list_regex = filter_list;
+    Ok(conf)
 }

src/create.rs

@@ -1,16 +1,14 @@
 use std::{env, process};
 use std::collections::HashMap;
 use std::error::Error;
-use std::path::Path;
 
 use clap::{App, Arg, SubCommand};
 use colored::*;
-use git2::build::RepoBuilder;
-use git2::Error as GitError;
 use reqwest::{Client, RequestBuilder};
 
 use crate::git::GitAction;
 use crate::input_args::InputArgs;
+use crate::clone::GitClone;
 
 pub fn sub_command<'a, 'b>() -> App<'a, 'b> {
     SubCommand::with_name("create")
@@ -117,19 +115,3 @@ fn create_remote(token: String, platform: &str, repo_name: &str) -> Result<Strin
     };
     remote_repo.create()
 }
-
-pub struct GitClone<'a> {
-    remote_url: &'a str,
-    local_path: &'a Path,
-}
-
-impl<'a> GitAction for GitClone<'a> {
-    fn git_action(&mut self) -> Result<(), GitError> {
-        RepoBuilder::new()
-            .clone(self.remote_url, self.local_path)?;
-        println!("{} {} {} {:#?}", "Created repo at".green(), self.remote_url.green(), "and cloned locally at".green(),
-                 self.local_path.as_os_str());
-
-        Ok(())
-    }
-}

src/input_args.rs

@@ -9,6 +9,7 @@ pub enum InputCommand {
     Status,
     Create,
     Fetch,
+    Clone,
     Error,
 }
 
@@ -18,6 +19,7 @@ impl InputCommand {
             InputCommand::Status => "status",
             InputCommand::Create => "create",
             InputCommand::Fetch => "fetch",
+            InputCommand::Clone => "clone",
             _ => "unknown command"
         }
     }
@@ -47,6 +49,11 @@ impl<'a> InputArgs<'a> {
                 input_command: InputCommand::Fetch,
                 arg_matches: matches.to_owned(),
             }
+        } else if subcommand_name == InputCommand::Clone.as_str() {
+            InputArgs {
+                input_command: InputCommand::Clone,
+                arg_matches: matches.to_owned(),
+            }
         } else {
             InputArgs {
                 input_command: InputCommand::Error,

src/main.rs

@@ -18,6 +18,7 @@ mod fetch;
 mod git;
 mod dir;
 mod conf;
+mod clone;
 
 fn main() {
     let app = App::new("Git Governance")
@@ -30,7 +31,8 @@ fn main() {
             .help("config file to use. Defaults to .ggConf"))
         .subcommand(status::sub_command())
         .subcommand(create::sub_command())
-        .subcommand(fetch::sub_command());
+        .subcommand(fetch::sub_command())
+        .subcommand(clone::sub_command());
 
 
     let global_matches = app.get_matches();
@@ -45,6 +47,7 @@ fn main() {
     match args.input_command() {
         input_args::InputCommand::Status => status::status(args, conf.filter_list_regex),
         input_args::InputCommand::Create => create::create(args),
+        input_args::InputCommand::Clone => clone::clone(args, conf.clone_repos),
         input_args::InputCommand::Fetch => fetch::fetch(args, conf.filter_list_regex),
         input_args::InputCommand::Error => {}
     }