nu-cli refactor moving commands into their own crate nu-command (#2910)

* move commands, futures.rs, script.rs, utils

* move over maybe_print_errors

* add nu_command crate references to nu_cli

* in commands.rs open up to pub mod from pub(crate)

* nu-cli, nu-command, and nu tests are now passing

* cargo fmt

* clean up nu-cli/src/prelude.rs

* code cleanup

* for some reason lex.rs was not formatted, may be causing my error

* remove mod completion from lib.rs which was not being used along with quickcheck macros

* add in allow unused imports

* comment out one failing external test; comment out one failing internal test

* revert commenting out failing tests; something else might be going on; someone with a windows machine should check and see what is going on with these failing windows tests

* Update Cargo.toml

Extend the optional features to nu-command

Co-authored-by: Jonathan Turner <jonathandturner@users.noreply.github.com>

crates/nu-command/src/commands/keep/command.rs

@@ -0,0 +1,79 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{Signature, SyntaxShape, UntaggedValue};
+use nu_source::Tagged;
+
+pub struct Command;
+
+#[derive(Deserialize)]
+pub struct Arguments {
+    rows: Option<Tagged<usize>>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Command {
+    fn name(&self) -> &str {
+        "keep"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("keep").optional(
+            "rows",
+            SyntaxShape::Int,
+            "Starting from the front, the number of rows to keep",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Keep the number of rows only"
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        keep(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Keep the first row",
+                example: "echo [1 2 3] | keep",
+                result: Some(vec![UntaggedValue::int(1).into()]),
+            },
+            Example {
+                description: "Keep the first four rows",
+                example: "echo [1 2 3 4 5] | keep 4",
+                result: Some(vec![
+                    UntaggedValue::int(1).into(),
+                    UntaggedValue::int(2).into(),
+                    UntaggedValue::int(3).into(),
+                    UntaggedValue::int(4).into(),
+                ]),
+            },
+        ]
+    }
+}
+
+async fn keep(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let (Arguments { rows }, input) = args.process().await?;
+    let rows_desired = if let Some(quantity) = rows {
+        *quantity
+    } else {
+        1
+    };
+
+    Ok(input.take(rows_desired).to_output_stream())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Command;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Command {})?)
+    }
+}

crates/nu-command/src/commands/keep/mod.rs

@@ -0,0 +1,7 @@
+mod command;
+mod until;
+mod while_;
+
+pub use command::Command as Keep;
+pub use until::SubCommand as KeepUntil;
+pub use while_::SubCommand as KeepWhile;

crates/nu-command/src/commands/keep/until.rs

@@ -0,0 +1,114 @@
+use crate::prelude::*;
+use log::trace;
+use nu_engine::evaluate_baseline_expr;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_parser::ParserScope;
+use nu_protocol::{hir::ClassifiedCommand, Signature, SyntaxShape, UntaggedValue, Value};
+
+pub struct SubCommand;
+
+#[async_trait]
+impl WholeStreamCommand for SubCommand {
+    fn name(&self) -> &str {
+        "keep until"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("keep until")
+            .required(
+                "condition",
+                SyntaxShape::RowCondition,
+                "The condition that must be met to stop keeping rows",
+            )
+            .filter()
+    }
+
+    fn usage(&self) -> &str {
+        "Keeps rows until the condition matches."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        let ctx = Arc::new(EvaluationContext::from_args(&args));
+
+        let call_info = args.evaluate_once().await?;
+
+        let block = call_info.args.expect_nth(0)?.clone();
+
+        let (condition, captured) = match block {
+            Value {
+                value: UntaggedValue::Block(captured_block),
+                tag,
+            } => {
+                if captured_block.block.block.len() != 1 {
+                    return Err(ShellError::labeled_error(
+                        "Expected a condition",
+                        "expected a condition",
+                        tag,
+                    ));
+                }
+                match captured_block.block.block[0].pipelines.get(0) {
+                    Some(item) => match item.list.get(0) {
+                        Some(ClassifiedCommand::Expr(expr)) => {
+                            (Arc::new(expr.clone()), captured_block.captured.clone())
+                        }
+                        _ => {
+                            return Err(ShellError::labeled_error(
+                                "Expected a condition",
+                                "expected a condition",
+                                tag,
+                            ));
+                        }
+                    },
+                    None => {
+                        return Err(ShellError::labeled_error(
+                            "Expected a condition",
+                            "expected a condition",
+                            tag,
+                        ));
+                    }
+                }
+            }
+            Value { tag, .. } => {
+                return Err(ShellError::labeled_error(
+                    "Expected a condition",
+                    "expected a condition",
+                    tag,
+                ));
+            }
+        };
+
+        Ok(call_info
+            .input
+            .take_while(move |item| {
+                let condition = condition.clone();
+                let ctx = ctx.clone();
+                ctx.scope.enter_scope();
+                ctx.scope.add_vars(&captured.entries);
+                ctx.scope.add_var("$it", item.clone());
+                trace!("ITEM = {:?}", item);
+
+                async move {
+                    let result = evaluate_baseline_expr(&*condition, &*ctx).await;
+                    ctx.scope.exit_scope();
+                    trace!("RESULT = {:?}", result);
+
+                    !matches!(result, Ok(ref v) if v.is_true())
+                }
+            })
+            .to_output_stream())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::ShellError;
+    use super::SubCommand;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(SubCommand {})?)
+    }
+}

crates/nu-command/src/commands/keep/while_.rs

@@ -0,0 +1,113 @@
+use crate::prelude::*;
+use log::trace;
+use nu_engine::evaluate_baseline_expr;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{hir::ClassifiedCommand, Signature, SyntaxShape, UntaggedValue, Value};
+
+pub struct SubCommand;
+
+#[async_trait]
+impl WholeStreamCommand for SubCommand {
+    fn name(&self) -> &str {
+        "keep while"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("keep while")
+            .required(
+                "condition",
+                SyntaxShape::RowCondition,
+                "The condition that must be met to keep rows",
+            )
+            .filter()
+    }
+
+    fn usage(&self) -> &str {
+        "Keeps rows while the condition matches."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        let ctx = Arc::new(EvaluationContext::from_args(&args));
+        let call_info = args.evaluate_once().await?;
+
+        let block = call_info.args.expect_nth(0)?.clone();
+
+        let (condition, captured) = match block {
+            Value {
+                value: UntaggedValue::Block(captured_block),
+                tag,
+            } => {
+                if captured_block.block.block.len() != 1 {
+                    return Err(ShellError::labeled_error(
+                        "Expected a condition",
+                        "expected a condition",
+                        tag,
+                    ));
+                }
+                match captured_block.block.block[0].pipelines.get(0) {
+                    Some(item) => match item.list.get(0) {
+                        Some(ClassifiedCommand::Expr(expr)) => {
+                            (Arc::new(expr.clone()), captured_block.captured.clone())
+                        }
+                        _ => {
+                            return Err(ShellError::labeled_error(
+                                "Expected a condition",
+                                "expected a condition",
+                                tag,
+                            ));
+                        }
+                    },
+                    None => {
+                        return Err(ShellError::labeled_error(
+                            "Expected a condition",
+                            "expected a condition",
+                            tag,
+                        ));
+                    }
+                }
+            }
+            Value { tag, .. } => {
+                return Err(ShellError::labeled_error(
+                    "Expected a condition",
+                    "expected a condition",
+                    tag,
+                ));
+            }
+        };
+
+        Ok(call_info
+            .input
+            .take_while(move |item| {
+                let condition = condition.clone();
+                let ctx = ctx.clone();
+
+                ctx.scope.enter_scope();
+                ctx.scope.add_var("$it", item.clone());
+                ctx.scope.add_vars(&captured.entries);
+                trace!("ITEM = {:?}", item);
+
+                async move {
+                    let result = evaluate_baseline_expr(&*condition, &*ctx).await;
+                    ctx.scope.exit_scope();
+                    trace!("RESULT = {:?}", result);
+
+                    matches!(result, Ok(ref v) if v.is_true())
+                }
+            })
+            .to_output_stream())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::ShellError;
+    use super::SubCommand;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(SubCommand {})?)
+    }
+}