moved commands

crates/nu-command/src/core_commands/alias.rs

@@ -0,0 +1,34 @@
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EvaluationContext};
+use nu_protocol::{Signature, SyntaxShape, Value};
+
+pub struct Alias;
+
+impl Command for Alias {
+    fn name(&self) -> &str {
+        "alias"
+    }
+
+    fn usage(&self) -> &str {
+        "Alias a command (with optional flags) to a new name"
+    }
+
+    fn signature(&self) -> nu_protocol::Signature {
+        Signature::build("alias")
+            .required("name", SyntaxShape::String, "name of the alias")
+            .required(
+                "initial_value",
+                SyntaxShape::Keyword(b"=".to_vec(), Box::new(SyntaxShape::Expression)),
+                "equals sign followed by value",
+            )
+    }
+
+    fn run(
+        &self,
+        _context: &EvaluationContext,
+        call: &Call,
+        _input: Value,
+    ) -> Result<nu_protocol::Value, nu_protocol::ShellError> {
+        Ok(Value::Nothing { span: call.head })
+    }
+}

crates/nu-command/src/core_commands/def.rs

@@ -0,0 +1,35 @@
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EvaluationContext};
+use nu_protocol::{Signature, SyntaxShape, Value};
+
+pub struct Def;
+
+impl Command for Def {
+    fn name(&self) -> &str {
+        "def"
+    }
+
+    fn usage(&self) -> &str {
+        "Define a custom command"
+    }
+
+    fn signature(&self) -> nu_protocol::Signature {
+        Signature::build("def")
+            .required("def_name", SyntaxShape::String, "definition name")
+            .required("params", SyntaxShape::Signature, "parameters")
+            .required(
+                "block",
+                SyntaxShape::Block(Some(vec![])),
+                "body of the definition",
+            )
+    }
+
+    fn run(
+        &self,
+        _context: &EvaluationContext,
+        call: &Call,
+        _input: Value,
+    ) -> Result<nu_protocol::Value, nu_protocol::ShellError> {
+        Ok(Value::Nothing { span: call.head })
+    }
+}

crates/nu-command/src/core_commands/do_.rs

@@ -0,0 +1,44 @@
+use nu_engine::{eval_block, eval_expression};
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EvaluationContext};
+use nu_protocol::{Signature, SyntaxShape, Value};
+
+pub struct Do;
+
+impl Command for Do {
+    fn name(&self) -> &str {
+        "do"
+    }
+
+    fn usage(&self) -> &str {
+        "Run a block"
+    }
+
+    fn signature(&self) -> nu_protocol::Signature {
+        Signature::build("do").required(
+            "block",
+            SyntaxShape::Block(Some(vec![])),
+            "the block to run",
+        )
+    }
+
+    fn run(
+        &self,
+        context: &EvaluationContext,
+        call: &Call,
+        input: Value,
+    ) -> Result<nu_protocol::Value, nu_protocol::ShellError> {
+        let block = &call.positional[0];
+
+        let out = eval_expression(context, block)?;
+
+        match out {
+            Value::Block { val: block_id, .. } => {
+                let engine_state = context.engine_state.borrow();
+                let block = engine_state.get_block(block_id);
+                eval_block(context, block, input)
+            }
+            _ => Ok(Value::nothing()),
+        }
+    }
+}

crates/nu-command/src/core_commands/if_.rs

@@ -0,0 +1,67 @@
+use nu_engine::{eval_block, eval_expression};
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EvaluationContext};
+use nu_protocol::{ShellError, Signature, SyntaxShape, Value};
+
+pub struct If;
+
+impl Command for If {
+    fn name(&self) -> &str {
+        "if"
+    }
+
+    fn usage(&self) -> &str {
+        "Conditionally run a block."
+    }
+
+    fn signature(&self) -> nu_protocol::Signature {
+        Signature::build("if")
+            .required("cond", SyntaxShape::Expression, "condition")
+            .required("then_block", SyntaxShape::Block(Some(vec![])), "then block")
+            .optional(
+                "else",
+                SyntaxShape::Keyword(b"else".to_vec(), Box::new(SyntaxShape::Expression)),
+                "optional else followed by else block",
+            )
+    }
+
+    fn run(
+        &self,
+        context: &EvaluationContext,
+        call: &Call,
+        input: Value,
+    ) -> Result<nu_protocol::Value, nu_protocol::ShellError> {
+        let cond = &call.positional[0];
+        let then_block = call.positional[1]
+            .as_block()
+            .expect("internal error: expected block");
+        let else_case = call.positional.get(2);
+
+        let result = eval_expression(context, cond)?;
+        match result {
+            Value::Bool { val, span } => {
+                let engine_state = context.engine_state.borrow();
+                if val {
+                    let block = engine_state.get_block(then_block);
+                    let state = context.enter_scope();
+                    eval_block(&state, block, input)
+                } else if let Some(else_case) = else_case {
+                    if let Some(else_expr) = else_case.as_keyword() {
+                        if let Some(block_id) = else_expr.as_block() {
+                            let block = engine_state.get_block(block_id);
+                            let state = context.enter_scope();
+                            eval_block(&state, block, input)
+                        } else {
+                            eval_expression(context, else_expr)
+                        }
+                    } else {
+                        eval_expression(context, else_case)
+                    }
+                } else {
+                    Ok(Value::Nothing { span })
+                }
+            }
+            _ => Err(ShellError::CantConvert("bool".into(), result.span())),
+        }
+    }
+}

crates/nu-command/src/core_commands/let_.rs

@@ -0,0 +1,50 @@
+use nu_engine::eval_expression;
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EvaluationContext};
+use nu_protocol::{Signature, SyntaxShape, Value};
+
+pub struct Let;
+
+impl Command for Let {
+    fn name(&self) -> &str {
+        "let"
+    }
+
+    fn usage(&self) -> &str {
+        "Create a variable and give it a value."
+    }
+
+    fn signature(&self) -> nu_protocol::Signature {
+        Signature::build("let")
+            .required("var_name", SyntaxShape::VarWithOptType, "variable name")
+            .required(
+                "initial_value",
+                SyntaxShape::Keyword(b"=".to_vec(), Box::new(SyntaxShape::Expression)),
+                "equals sign followed by value",
+            )
+    }
+
+    fn run(
+        &self,
+        context: &EvaluationContext,
+        call: &Call,
+        _input: Value,
+    ) -> Result<nu_protocol::Value, nu_protocol::ShellError> {
+        let var_id = call.positional[0]
+            .as_var()
+            .expect("internal error: missing variable");
+
+        let keyword_expr = call.positional[1]
+            .as_keyword()
+            .expect("internal error: missing keyword");
+
+        let rhs = eval_expression(context, keyword_expr)?;
+
+        //println!("Adding: {:?} to {}", rhs, var_id);
+
+        context.add_var(var_id, rhs);
+        Ok(Value::Nothing {
+            span: call.positional[0].span,
+        })
+    }
+}

crates/nu-command/src/core_commands/mod.rs

@@ -0,0 +1,15 @@
+mod alias;
+mod def;
+mod do_;
+mod if_;
+mod let_;
+mod module;
+mod use_;
+
+pub use alias::Alias;
+pub use def::Def;
+pub use do_::Do;
+pub use if_::If;
+pub use let_::Let;
+pub use module::Module;
+pub use use_::Use;

crates/nu-command/src/core_commands/module.rs

@@ -0,0 +1,34 @@
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EvaluationContext};
+use nu_protocol::{Signature, SyntaxShape, Value};
+
+pub struct Module;
+
+impl Command for Module {
+    fn name(&self) -> &str {
+        "module"
+    }
+
+    fn usage(&self) -> &str {
+        "Define a custom module"
+    }
+
+    fn signature(&self) -> nu_protocol::Signature {
+        Signature::build("module")
+            .required("module_name", SyntaxShape::String, "module name")
+            .required(
+                "block",
+                SyntaxShape::Block(Some(vec![])),
+                "body of the module",
+            )
+    }
+
+    fn run(
+        &self,
+        _context: &EvaluationContext,
+        call: &Call,
+        _input: Value,
+    ) -> Result<nu_protocol::Value, nu_protocol::ShellError> {
+        Ok(Value::Nothing { span: call.head })
+    }
+}

crates/nu-command/src/core_commands/use_.rs

@@ -0,0 +1,28 @@
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EvaluationContext};
+use nu_protocol::{Signature, SyntaxShape, Value};
+
+pub struct Use;
+
+impl Command for Use {
+    fn name(&self) -> &str {
+        "use"
+    }
+
+    fn usage(&self) -> &str {
+        "Use definitions from a module"
+    }
+
+    fn signature(&self) -> nu_protocol::Signature {
+        Signature::build("use").required("module_name", SyntaxShape::String, "module name")
+    }
+
+    fn run(
+        &self,
+        _context: &EvaluationContext,
+        call: &Call,
+        _input: Value,
+    ) -> Result<nu_protocol::Value, nu_protocol::ShellError> {
+        Ok(Value::Nothing { span: call.head })
+    }
+}