From 0ebc5b3769e50c3463bdc39af0160c7db0d3f00b Mon Sep 17 00:00:00 2001
From: Jan Allersma <janallersma@gmail.com>
Date: Jan 03 2019 17:34:18 +0000
Subject: Git integration.


* Fix `add` command.
* Fix `hide` command.
* Format 'help' message correctly.

---

diff --git a/src/backend/add.rs b/src/backend/add.rs
index 9fe9717..d94694a 100644
--- a/src/backend/add.rs
+++ b/src/backend/add.rs
@@ -3,11 +3,12 @@ extern crate serde_json;
 use std::result::Result;
 use std::path::PathBuf;
 
-pub fn add<I>(args: &mut I) -> Result<String, String> where I: Iterator<Item=String> {
+pub fn add(args: &Vec<String>) -> Result<String, String> {
+    let mut it = args.iter().peekable();
     let dep_dir: PathBuf;
 
-    let dep_name = match args.next() {
-        Some(name) => name,
+    let dep_name: String = match it.next() {
+        Some(arg) => (*arg).clone(),
         None => return Err(String::from("Missing dependency name!"))
     };
 
@@ -23,10 +24,10 @@ pub fn add<I>(args: &mut I) -> Result<String, String> where I: Iterator<Item=Str
         return Err(String::from("Dependency already exists."))
     }
 
-    let mut args: String = args.into_iter().map(|arg| arg + " ").collect();
+    let mut args_s: String = it.map(|arg| arg.clone() + " ").collect();
 
-    match args.pop() {
-        Some(_) => update_module(dep_name, args),
+    match args_s.pop() {
+        Some(_) => update_module(dep_name, args_s),
         None => update_module(dep_name, String::new())
     }
 }
diff --git a/src/backend/filesystem.rs b/src/backend/filesystem.rs
index e7d35ba..3a5e3b9 100644
--- a/src/backend/filesystem.rs
+++ b/src/backend/filesystem.rs
@@ -1,7 +1,7 @@
 use std::{path, env, fs};
 use std::io::{Result, Error, ErrorKind};
 
-fn get_root (mut path: path::PathBuf) -> Option<path::PathBuf> {
+fn get_root(mut path: path::PathBuf) -> Option<path::PathBuf> {
     loop {
         let mut config = path.clone();
         config.push("beheer.json");
diff --git a/src/backend/git/exe.rs b/src/backend/git/exe.rs
new file mode 100644
index 0000000..3102c93
--- /dev/null
+++ b/src/backend/git/exe.rs
@@ -0,0 +1,73 @@
+use backend;
+use backend::system::OS;
+use backend::deptree::Node;
+use std::process::{Command, Stdio};
+use std::path::PathBuf;
+
+pub fn exe_rec(args: Vec<String>) -> Result<(), String> {
+    let tree: Node;
+    let mut dependency: &Node;
+
+    match backend::filesystem::get_current_project_root() {
+        Some(path) => {
+            match backend::deptree::print(&OS::current(), path) {
+                Ok(node) => {
+                    tree = node;
+                    dependency = &tree;
+                },
+                Err(e) => return Err(e)
+            }
+        }
+        None => return Err(String::from("Not in a project (sub)directory."))
+    }
+
+    loop {
+        match to_shell(&dependency.path, args.clone()) {
+            Ok(msg) => {
+                println!("{}", msg);
+                println!("Module {}: {}\n", dependency.name, "Git command successfully executed!");
+            },
+            Err(e) => return Err(e)
+        }
+
+        match dependency.depends_on.iter().next() {
+            Some(dep) => dependency = dep,
+            None => break
+        }
+    }
+    Ok(())
+}
+
+pub fn exe(path: &PathBuf, args: Vec<String>) -> Result<(), String> {
+    match to_shell(path, args) {
+        Ok(msg) => {
+            println!("{}", msg);
+            println!("Git command successfully executed!");
+            Ok(())
+        },
+        Err(e) => Err(e)
+    }
+}
+
+fn to_shell<I>(path: &PathBuf, args: I) -> Result<String, String> where I: IntoIterator<Item=String> {
+    let out = Command::new("git")
+        .current_dir(path)
+        .args(args)
+        .stdin(Stdio::inherit())
+        .stdout(Stdio::inherit())
+        .output();
+
+    match out {
+        Ok(response) => {
+            match response.status.success() {
+                true => Ok(String::from_utf8_lossy(&response.stdout).to_string()),
+                false => Err(String::from_utf8_lossy(&response.stderr).to_string())
+            }
+        },
+        Err(e) => {
+            let mut error = String::from("Git (sub)command failed: command invalid. Details: ");
+            error.push_str(&e.to_string());
+            Err(error)
+        }
+    }
+}
diff --git a/src/backend/git/ignore.rs b/src/backend/git/ignore.rs
index 2b17844..8f135f3 100644
--- a/src/backend/git/ignore.rs
+++ b/src/backend/git/ignore.rs
@@ -1,4 +1,4 @@
-use std::io::Write;
+use std::io::{ErrorKind, Write};
 use std::path::PathBuf;
 use std::fs::OpenOptions;
 
@@ -8,7 +8,7 @@ pub fn add(path: &mut PathBuf, item: &mut String) -> Result<(), String> {
 
     let file_options = OpenOptions::new()
         .append(true)
-        .open(path);
+        .open(&path);
 
     match file_options {
         Ok(mut file) => {
@@ -17,6 +17,16 @@ pub fn add(path: &mut PathBuf, item: &mut String) -> Result<(), String> {
                     Err(e) => Err(e.to_string())
                 }
         },
-        Err(e) => Err(e.to_string())
+        Err(e) => {
+            match e.kind() {
+                ErrorKind::NotFound => {
+                    let mut error = String::from(path.to_str().unwrap());
+                    error.push_str(" not found");
+                    Err(error)
+                },
+                ErrorKind::PermissionDenied => Err(String::from("gitignore file unreadable: permission denied.")),
+                _ => Err(e.to_string())
+            }
+        }
     }
 }
diff --git a/src/backend/git/mod.rs b/src/backend/git/mod.rs
index bf699b5..07c06c2 100644
--- a/src/backend/git/mod.rs
+++ b/src/backend/git/mod.rs
@@ -1,3 +1,30 @@
-mod rec;
 pub mod status;
 pub mod ignore;
+mod exe;
+
+pub fn to_shell<I>(args: &mut I) where I: Iterator<Item=String> {
+    match args.next() {
+        Some(ref arg) if arg == "rec" => match exe::exe_rec(args.collect()) {
+            Ok(_) => {},
+            Err(e) => println!("Executing recursive git command failed. Details: {}", e)
+        },
+        Some(git) => {
+            let path = match super::filesystem::get_current_project_root() {
+                Some(result) => result,
+                None => {
+                    println!("Executing git command failed. Details: {}", "Not in a project (sub)directory.");
+                    return;
+                }
+            };
+
+            let mut args: Vec<String> = args.collect();
+            args.insert(0, git);
+
+            match exe::exe(&path, args) {
+                Ok(_) => {},
+                Err(e) => println!("Executing git command failed. Details: {}", e)
+            }
+        },
+        None => {}
+    }
+}
diff --git a/src/backend/git/rec.rs b/src/backend/git/rec.rs
deleted file mode 100644
index 27ff93a..0000000
--- a/src/backend/git/rec.rs
+++ /dev/null
@@ -1 +0,0 @@
-extern crate git2;
diff --git a/src/backend/project.rs b/src/backend/project.rs
index 83054f2..7540211 100644
--- a/src/backend/project.rs
+++ b/src/backend/project.rs
@@ -95,14 +95,43 @@ pub fn delete<I>(path: &mut I) -> Result<String, String> where I: Iterator<Item=
     }
 }
 
-pub fn ignore<I>(args: &mut I) -> Result<(), String> where I: Iterator<Item=String> {
-    let mut path = match args.next() {
-        Some(arg) => arg,
+pub fn add(args: &Vec<String>) -> Result<String, String> {
+    let mut path: String = match args.get(0) {
+        Some(arg) => arg.clone(),
         None => return Err(String::from("Missing path as argument."))
     };
 
-    match env::current_dir() {
-        Ok(mut dir) => super::git::ignore::add(&mut dir, &mut path),
+    match super::filesystem::get_current_module_root() {
+        Some(dir) => {
+            match super::git::ignore::add(&mut dir.clone(), &mut path) {
+                Ok(_) => {},
+                Err(e) => return Err(e)
+            }
+
+            match super::add::add(args) {
+                Ok(msg) => println!("{}", msg),
+                Err(e) => return Err(e)
+            }
+
+            match super::config::get_json(dir) {
+                Ok(json) => {
+                    super::dep::check(json)
+                },
+                Err(e) => return Err(e)
+            }
+        },
+        None => Err(String::from("Not in a project (sub)directory."))
+    }
+}
+
+pub fn ignore(args: &Vec<String>) -> Result<(), String> {
+    let mut entry: String = args.get(0).unwrap().clone();
+
+    match super::filesystem::get_current_dep_root() {
+        Ok(mut dir) => {
+            dir.push(&entry);
+            super::git::ignore::add(&mut dir, &mut entry) // entry moet "beheer.json" worden.
+        },
         Err(e) => Err(e.to_string())
     }
 }
@@ -128,7 +157,7 @@ pub fn help() {
     println!("$ beheer [FLAG] [COMMAND [ARGUMENTS]]");
     println!("");
 
-    println!("--help -h\t\tShow this message");
+    println!("--help -h\t\t\t\tShow this message");
     println!("");
 
     println!("init [DIRECTORY]\t\t  Initialize new project in specified directory. Defaults to current directory.");
diff --git a/src/parser.rs b/src/parser.rs
index cca6685..9d1a6ea 100644
--- a/src/parser.rs
+++ b/src/parser.rs
@@ -43,21 +43,22 @@ fn parse<I>(args: &mut I, open_shell: bool) -> bool where I: Iterator<Item=Strin
                 }
             }
             else if argument == "add" {
-                match backend::add::add(args) {
+                match backend::project::add(&args.collect()) {
                     Ok(msg) => println!("{}", msg),
                     Err(e) => println!("Could not add dependency: {}", e)
                 }
             }
             else if argument == "hide" {
-                let result = match backend::project::ignore(args) {
-                    Ok(_) => backend::add::add(args),
-                    Err(e) => Err(e)
-                };
-
-                match result {
+                let args: Vec<String> = args.collect();
+                match backend::project::add(&args) {
                     Ok(msg) => println!("{}", msg),
                     Err(e) => println!("Could not add dependency: {}", e)
                 }
+
+                match backend::project::ignore(&args) {
+                    Ok(_) => println!("DONE! Dependency hidden."),
+                    Err(e) => println!("Could not hide dependency: {}", e)
+                }
             }
             else if argument == "delete" {
                 match backend::project::delete(args) {
@@ -71,6 +72,9 @@ fn parse<I>(args: &mut I, open_shell: bool) -> bool where I: Iterator<Item=Strin
                     Err(e) => println!("Could not deduce dependency tree: {}", e)
                 }
             }
+            else if argument == "git" {
+                backend::git::to_shell(args);
+            }
             else {
                 return false;
             }