Very early proof-of-concept git branch completion

crates/nu-command/src/default_context.rs

@@ -6,8 +6,8 @@ use nu_protocol::{
 };
 
 use crate::{
-    where_::Where, Alias, Benchmark, BuildString, Def, Do, Each, For, If, Length, Let, LetEnv, Ls,
-    Table,
+    where_::Where, Alias, Benchmark, BuildString, Def, Do, Each, For, Git, GitCheckout, If, Length,
+    Let, LetEnv, ListGitBranches, Ls, Table,
 };
 
 pub fn create_default_context() -> Rc<RefCell<EngineState>> {
@@ -48,6 +48,11 @@ pub fn create_default_context() -> Rc<RefCell<EngineState>> {
 
         working_set.add_decl(Box::new(Table));
 
+        // This is a WIP proof of concept
+        working_set.add_decl(Box::new(ListGitBranches));
+        working_set.add_decl(Box::new(Git));
+        working_set.add_decl(Box::new(GitCheckout));
+
         let sig = Signature::build("exit");
         working_set.add_decl(sig.predeclare());
         let sig = Signature::build("vars");

crates/nu-command/src/git.rs

@@ -0,0 +1,51 @@
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EvaluationContext};
+use nu_protocol::{Signature, Value};
+
+pub struct Git;
+
+impl Command for Git {
+    fn name(&self) -> &str {
+        "git"
+    }
+
+    fn usage(&self) -> &str {
+        "Run a block"
+    }
+
+    fn signature(&self) -> nu_protocol::Signature {
+        Signature::build("git")
+    }
+
+    fn run(
+        &self,
+        _context: &EvaluationContext,
+        call: &Call,
+        _input: Value,
+    ) -> Result<nu_protocol::Value, nu_protocol::ShellError> {
+        use std::process::Command as ProcessCommand;
+        use std::process::Stdio;
+
+        let proc = ProcessCommand::new("git").stdout(Stdio::piped()).spawn();
+
+        match proc {
+            Ok(child) => {
+                match child.wait_with_output() {
+                    Ok(val) => {
+                        let result = val.stdout;
+
+                        Ok(Value::string(&String::from_utf8_lossy(&result), call.head))
+                    }
+                    Err(_err) => {
+                        // FIXME
+                        Ok(Value::nothing())
+                    }
+                }
+            }
+            Err(_err) => {
+                // FIXME
+                Ok(Value::nothing())
+            }
+        }
+    }
+}

crates/nu-command/src/git_checkout.rs

@@ -0,0 +1,66 @@
+use nu_engine::eval_expression;
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EvaluationContext};
+use nu_protocol::{Signature, SyntaxShape, Value};
+
+pub struct GitCheckout;
+
+impl Command for GitCheckout {
+    fn name(&self) -> &str {
+        "git checkout"
+    }
+
+    fn usage(&self) -> &str {
+        "Checkout a git revision"
+    }
+
+    fn signature(&self) -> nu_protocol::Signature {
+        Signature::build("git checkout").required(
+            "branch",
+            SyntaxShape::Custom(Box::new(SyntaxShape::String), "list-git-branches".into()),
+            "the branch to checkout",
+        )
+    }
+
+    fn run(
+        &self,
+        context: &EvaluationContext,
+        call: &Call,
+        _input: Value,
+    ) -> Result<nu_protocol::Value, nu_protocol::ShellError> {
+        use std::process::Command as ProcessCommand;
+        use std::process::Stdio;
+
+        let block = &call.positional[0];
+
+        let out = eval_expression(context, block)?;
+
+        let out = out.as_string()?;
+
+        let proc = ProcessCommand::new("git")
+            .arg("checkout")
+            .arg(out)
+            .stdout(Stdio::piped())
+            .spawn();
+
+        match proc {
+            Ok(child) => {
+                match child.wait_with_output() {
+                    Ok(val) => {
+                        let result = val.stdout;
+
+                        Ok(Value::string(&String::from_utf8_lossy(&result), call.head))
+                    }
+                    Err(_err) => {
+                        // FIXME
+                        Ok(Value::nothing())
+                    }
+                }
+            }
+            Err(_err) => {
+                // FIXME
+                Ok(Value::nothing())
+            }
+        }
+    }
+}

crates/nu-command/src/lib.rs

@@ -6,10 +6,13 @@ mod default_context;
 mod do_;
 mod each;
 mod for_;
+mod git;
+mod git_checkout;
 mod if_;
 mod length;
 mod let_;
 mod let_env;
+mod list_git_branches;
 mod ls;
 mod table;
 mod where_;
@@ -22,9 +25,12 @@ pub use default_context::create_default_context;
 pub use do_::Do;
 pub use each::Each;
 pub use for_::For;
+pub use git::Git;
+pub use git_checkout::GitCheckout;
 pub use if_::If;
 pub use length::Length;
 pub use let_::Let;
 pub use let_env::LetEnv;
+pub use list_git_branches::ListGitBranches;
 pub use ls::Ls;
 pub use table::Table;

crates/nu-command/src/list_git_branches.rs

@@ -0,0 +1,69 @@
+// Note: this is a temporary command that later will be converted into a pipeline
+
+use std::process::Command as ProcessCommand;
+use std::process::Stdio;
+
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EvaluationContext};
+use nu_protocol::{Signature, Value};
+
+pub struct ListGitBranches;
+
+//NOTE: this is not a real implementation :D. It's just a simple one to test with until we port the real one.
+impl Command for ListGitBranches {
+    fn name(&self) -> &str {
+        "list-git-branches"
+    }
+
+    fn usage(&self) -> &str {
+        "List the git branches of the current directory."
+    }
+
+    fn signature(&self) -> nu_protocol::Signature {
+        Signature::build("list-git-branches")
+    }
+
+    fn run(
+        &self,
+        _context: &EvaluationContext,
+        call: &Call,
+        _input: Value,
+    ) -> Result<nu_protocol::Value, nu_protocol::ShellError> {
+        let list_branches = ProcessCommand::new("git")
+            .arg("branch")
+            .stdout(Stdio::piped())
+            .spawn();
+
+        if let Ok(child) = list_branches {
+            if let Ok(output) = child.wait_with_output() {
+                let val = output.stdout;
+
+                let s = String::from_utf8_lossy(&val).to_string();
+
+                let lines: Vec<_> = s
+                    .lines()
+                    .filter_map(|x| {
+                        if x.starts_with("* ") {
+                            None
+                        } else {
+                            Some(x.trim())
+                        }
+                    })
+                    .map(|x| Value::String {
+                        val: x.into(),
+                        span: call.head,
+                    })
+                    .collect();
+
+                Ok(Value::List {
+                    vals: lines,
+                    span: call.head,
+                })
+            } else {
+                Ok(Value::Nothing { span: call.head })
+            }
+        } else {
+            Ok(Value::Nothing { span: call.head })
+        }
+    }
+}