add ps and early help

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

@@ -0,0 +1,406 @@
+use nu_protocol::{
+    ast::Call,
+    engine::{Command, EvaluationContext},
+    Example, ShellError, Signature, Spanned, SyntaxShape, Value,
+};
+
+use nu_engine::CallExt;
+
+pub struct Help;
+
+impl Command for Help {
+    fn name(&self) -> &str {
+        "help"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("help")
+            .rest(
+                "rest",
+                SyntaxShape::String,
+                "the name of command to get help on",
+            )
+            .named(
+                "find",
+                SyntaxShape::String,
+                "string to find in command usage",
+                Some('f'),
+            )
+    }
+
+    fn usage(&self) -> &str {
+        "Display help information about commands."
+    }
+
+    fn run(
+        &self,
+        context: &EvaluationContext,
+        call: &Call,
+        _input: Value,
+    ) -> Result<Value, ShellError> {
+        help(context, call)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "show all commands and sub-commands",
+                example: "help commands",
+                result: None,
+            },
+            Example {
+                description: "generate documentation",
+                example: "help generate_docs",
+                result: None,
+            },
+            Example {
+                description: "show help for single command",
+                example: "help match",
+                result: None,
+            },
+            Example {
+                description: "show help for single sub-command",
+                example: "help str lpad",
+                result: None,
+            },
+            Example {
+                description: "search for string in command usage",
+                example: "help --find char",
+                result: None,
+            },
+        ]
+    }
+}
+
+fn help(context: &EvaluationContext, call: &Call) -> Result<Value, ShellError> {
+    let span = call.head;
+    let find: Option<Spanned<String>> = call.get_flag(context, "find")?;
+    let rest: Vec<Spanned<String>> = call.rest(context, 0)?;
+
+    let full_commands = context.get_commands_info();
+
+    if let Some(f) = find {
+        let search_string = f.item;
+        let mut found_cmds_vec = Vec::new();
+
+        for cmd in full_commands {
+            let mut cols = vec![];
+            let mut vals = vec![];
+
+            let key = cmd.name.clone();
+            let c = cmd.usage.clone();
+            let e = cmd.extra_usage.clone();
+            if key.to_lowercase().contains(&search_string)
+                || c.to_lowercase().contains(&search_string)
+                || e.to_lowercase().contains(&search_string)
+            {
+                cols.push("name".into());
+                vals.push(Value::String { val: key, span });
+
+                cols.push("usage".into());
+                vals.push(Value::String { val: c, span });
+
+                cols.push("extra_usage".into());
+                vals.push(Value::String { val: e, span });
+
+                found_cmds_vec.push(Value::Record { cols, vals, span });
+            }
+        }
+
+        return Ok(Value::List {
+            vals: found_cmds_vec,
+            span,
+        });
+    }
+
+    if !rest.is_empty() {
+        let mut found_cmds_vec = Vec::new();
+
+        if rest[0].item == "commands" {
+            for cmd in full_commands {
+                let mut cols = vec![];
+                let mut vals = vec![];
+
+                let key = cmd.name.clone();
+                let c = cmd.usage.clone();
+                let e = cmd.extra_usage.clone();
+
+                cols.push("name".into());
+                vals.push(Value::String { val: key, span });
+
+                cols.push("usage".into());
+                vals.push(Value::String { val: c, span });
+
+                cols.push("extra_usage".into());
+                vals.push(Value::String { val: e, span });
+
+                found_cmds_vec.push(Value::Record { cols, vals, span });
+            }
+        } else {
+            let mut name = String::new();
+
+            for r in rest {
+                if !name.is_empty() {
+                    name.push(' ');
+                }
+                name.push_str(&r.item);
+            }
+
+            for cmd in full_commands {
+                let mut cols = vec![];
+                let mut vals = vec![];
+
+                let key = cmd.name.clone();
+                let c = cmd.usage.clone();
+                let e = cmd.extra_usage.clone();
+
+                if key.starts_with(&name) {
+                    cols.push("name".into());
+                    vals.push(Value::String { val: key, span });
+
+                    cols.push("usage".into());
+                    vals.push(Value::String { val: c, span });
+
+                    cols.push("extra_usage".into());
+                    vals.push(Value::String { val: e, span });
+
+                    found_cmds_vec.push(Value::Record { cols, vals, span });
+                }
+            }
+        }
+        Ok(Value::List {
+            vals: found_cmds_vec,
+            span,
+        })
+
+        // FIXME: the fancy help stuff needs to be reimplemented
+        /*
+        if rest[0].item == "commands" {
+            let mut sorted_names = scope.get_command_names();
+            sorted_names.sort();
+
+            let (mut subcommand_names, command_names) = sorted_names
+                .into_iter()
+                // private only commands shouldn't be displayed
+                .filter(|cmd_name| {
+                    scope
+                        .get_command(cmd_name)
+                        .filter(|command| !command.is_private())
+                        .is_some()
+                })
+                .partition::<Vec<_>, _>(|cmd_name| cmd_name.contains(' '));
+
+            fn process_name(
+                dict: &mut TaggedDictBuilder,
+                cmd_name: &str,
+                scope: Scope,
+                rest: Vec<Tagged<String>>,
+                name: Tag,
+            ) -> Result<(), ShellError> {
+                let document_tag = rest[0].tag.clone();
+                let value = command_dict(
+                    scope.get_command(cmd_name).ok_or_else(|| {
+                        ShellError::labeled_error(
+                            format!("Could not load {}", cmd_name),
+                            "could not load command",
+                            document_tag,
+                        )
+                    })?,
+                    name,
+                );
+
+                dict.insert_untagged("name", cmd_name);
+                dict.insert_untagged(
+                    "description",
+                    value
+                        .get_data_by_key("usage".spanned_unknown())
+                        .ok_or_else(|| {
+                            ShellError::labeled_error(
+                                "Expected a usage key",
+                                "expected a 'usage' key",
+                                &value.tag,
+                            )
+                        })?
+                        .as_string()?,
+                );
+
+                Ok(())
+            }
+
+            fn make_subcommands_table(
+                subcommand_names: &mut Vec<String>,
+                cmd_name: &str,
+                scope: Scope,
+                rest: Vec<Tagged<String>>,
+                name: Tag,
+            ) -> Result<Value, ShellError> {
+                let (matching, not_matching) =
+                    subcommand_names.drain(..).partition(|subcommand_name| {
+                        subcommand_name.starts_with(&format!("{} ", cmd_name))
+                    });
+                *subcommand_names = not_matching;
+                Ok(if !matching.is_empty() {
+                    UntaggedValue::table(
+                        &(matching
+                            .into_iter()
+                            .map(|cmd_name: String| -> Result<_, ShellError> {
+                                let mut short_desc = TaggedDictBuilder::new(name.clone());
+                                process_name(
+                                    &mut short_desc,
+                                    &cmd_name,
+                                    scope.clone(),
+                                    rest.clone(),
+                                    name.clone(),
+                                )?;
+                                Ok(short_desc.into_value())
+                            })
+                            .collect::<Result<Vec<_>, _>>()?[..]),
+                    )
+                    .into_value(name)
+                } else {
+                    UntaggedValue::nothing().into_value(name)
+                })
+            }
+
+            let iterator =
+                command_names
+                    .into_iter()
+                    .map(move |cmd_name| -> Result<_, ShellError> {
+                        let mut short_desc = TaggedDictBuilder::new(name.clone());
+                        process_name(
+                            &mut short_desc,
+                            &cmd_name,
+                            scope.clone(),
+                            rest.clone(),
+                            name.clone(),
+                        )?;
+                        short_desc.insert_value(
+                            "subcommands",
+                            make_subcommands_table(
+                                &mut subcommand_names,
+                                &cmd_name,
+                                scope.clone(),
+                                rest.clone(),
+                                name.clone(),
+                            )?,
+                        );
+                        ReturnSuccess::value(short_desc.into_value())
+                    });
+
+            Ok(iterator.into_action_stream())
+        } else if rest[0].item == "generate_docs" {
+            Ok(ActionStream::one(ReturnSuccess::value(generate_docs(
+                &scope,
+            ))))
+        } else if rest.len() == 2 {
+            // Check for a subcommand
+            let command_name = format!("{} {}", rest[0].item, rest[1].item);
+            if let Some(command) = scope.get_command(&command_name) {
+                Ok(ActionStream::one(ReturnSuccess::value(
+                    UntaggedValue::string(get_full_help(command.stream_command(), &scope))
+                        .into_value(Tag::unknown()),
+                )))
+            } else {
+                Ok(ActionStream::empty())
+            }
+        } else if let Some(command) = scope.get_command(&rest[0].item) {
+            Ok(ActionStream::one(ReturnSuccess::value(
+                UntaggedValue::string(get_full_help(command.stream_command(), &scope))
+                    .into_value(Tag::unknown()),
+            )))
+        } else {
+            Err(ShellError::labeled_error(
+                "Can't find command (use 'help commands' for full list)",
+                "can't find command",
+                rest[0].tag.span,
+            ))
+        }
+        */
+    } else {
+        let msg = r#"Welcome to Nushell.
+
+Here are some tips to help you get started.
+  * help commands - list all available commands
+  * help <command name> - display help about a particular command
+
+Nushell works on the idea of a "pipeline". Pipelines are commands connected with the '|' character.
+Each stage in the pipeline works together to load, parse, and display information to you.
+
+[Examples]
+
+List the files in the current directory, sorted by size:
+    ls | sort-by size
+
+Get information about the current system:
+    sys | get host
+
+Get the processes on your system actively using CPU:
+    ps | where cpu > 0
+
+You can also learn more at https://www.nushell.sh/book/"#;
+
+        Ok(Value::String {
+            val: msg.into(),
+            span,
+        })
+    }
+}
+
+/*
+fn for_spec(name: &str, ty: &str, required: bool, tag: impl Into<Tag>) -> Value {
+    let tag = tag.into();
+
+    let mut spec = TaggedDictBuilder::new(tag);
+
+    spec.insert_untagged("name", UntaggedValue::string(name));
+    spec.insert_untagged("type", UntaggedValue::string(ty));
+    spec.insert_untagged(
+        "required",
+        UntaggedValue::string(if required { "yes" } else { "no" }),
+    );
+
+    spec.into_value()
+}
+
+pub fn signature_dict(signature: Signature, tag: impl Into<Tag>) -> Value {
+    let tag = tag.into();
+    let mut sig = TaggedListBuilder::new(&tag);
+
+    for arg in &signature.positional {
+        let is_required = matches!(arg.0, PositionalType::Mandatory(_, _));
+
+        sig.push_value(for_spec(arg.0.name(), "argument", is_required, &tag));
+    }
+
+    if signature.rest_positional.is_some() {
+        let is_required = false;
+        sig.push_value(for_spec("rest", "argument", is_required, &tag));
+    }
+
+    for (name, ty) in &signature.named {
+        match ty.0 {
+            NamedType::Mandatory(_, _) => sig.push_value(for_spec(name, "flag", true, &tag)),
+            NamedType::Optional(_, _) => sig.push_value(for_spec(name, "flag", false, &tag)),
+            NamedType::Switch(_) => sig.push_value(for_spec(name, "switch", false, &tag)),
+        }
+    }
+
+    sig.into_value()
+}
+
+fn command_dict(command: Command, tag: impl Into<Tag>) -> Value {
+    let tag = tag.into();
+
+    let mut cmd_dict = TaggedDictBuilder::new(&tag);
+
+    cmd_dict.insert_untagged("name", UntaggedValue::string(command.name()));
+
+    cmd_dict.insert_untagged("type", UntaggedValue::string("Command"));
+
+    cmd_dict.insert_value("signature", signature_dict(command.signature(), tag));
+    cmd_dict.insert_untagged("usage", UntaggedValue::string(command.usage()));
+
+    cmd_dict.into_value()
+}
+
+*/

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

@@ -1,6 +1,7 @@
 mod alias;
 mod def;
 mod do_;
+mod help;
 mod if_;
 mod let_;
 mod module;
@@ -9,6 +10,7 @@ mod use_;
 pub use alias::Alias;
 pub use def::Def;
 pub use do_::Do;
+pub use help::Help;
 pub use if_::If;
 pub use let_::Let;
 pub use module::Module;

crates/nu-command/src/default_context.rs

@@ -2,12 +2,12 @@ use std::{cell::RefCell, rc::Rc};
 
 use nu_protocol::{
     engine::{EngineState, StateWorkingSet},
-    Signature, SyntaxShape,
+    Signature,
 };
 
 use crate::{
     Alias, Benchmark, BuildString, Def, Do, Each, External, For, From, FromJson, Git, GitCheckout,
-    If, Length, Let, LetEnv, Lines, ListGitBranches, Ls, Module, Sys, Table, Use, Where,
+    Help, If, Length, Let, LetEnv, Lines, ListGitBranches, Ls, Module, Ps, Sys, Table, Use, Where,
 };
 
 pub fn create_default_context() -> Rc<RefCell<EngineState>> {
@@ -16,10 +16,6 @@ pub fn create_default_context() -> Rc<RefCell<EngineState>> {
         let engine_state = engine_state.borrow();
         let mut working_set = StateWorkingSet::new(&*engine_state);
 
-        let sig =
-            Signature::build("where").required("cond", SyntaxShape::RowCondition, "condition");
-        working_set.add_decl(sig.predeclare());
-
         working_set.add_decl(Box::new(Alias));
         working_set.add_decl(Box::new(Benchmark));
         working_set.add_decl(Box::new(BuildString));
@@ -30,6 +26,7 @@ pub fn create_default_context() -> Rc<RefCell<EngineState>> {
         working_set.add_decl(Box::new(For));
         working_set.add_decl(Box::new(From));
         working_set.add_decl(Box::new(FromJson));
+        working_set.add_decl(Box::new(Help));
         working_set.add_decl(Box::new(If));
         working_set.add_decl(Box::new(Length));
         working_set.add_decl(Box::new(Let));
@@ -37,6 +34,7 @@ pub fn create_default_context() -> Rc<RefCell<EngineState>> {
         working_set.add_decl(Box::new(Lines));
         working_set.add_decl(Box::new(Ls));
         working_set.add_decl(Box::new(Module));
+        working_set.add_decl(Box::new(Ps));
         working_set.add_decl(Box::new(Sys));
         working_set.add_decl(Box::new(Table));
         working_set.add_decl(Box::new(Use));

crates/nu-command/src/filters/for_.rs

@@ -1,7 +1,7 @@
 use nu_engine::{eval_block, eval_expression};
 use nu_protocol::ast::Call;
 use nu_protocol::engine::{Command, EvaluationContext};
-use nu_protocol::{IntoValueStream, Signature, SyntaxShape, Value};
+use nu_protocol::{Example, IntoValueStream, Signature, Span, SyntaxShape, Value};
 
 pub struct For;
 
@@ -91,4 +91,42 @@ impl Command for For {
             _ => Ok(Value::nothing()),
         }
     }
+
+    fn examples(&self) -> Vec<Example> {
+        let span = Span::unknown();
+        vec![
+            Example {
+                description: "Echo the square of each integer",
+                example: "for x in [1 2 3] { $x * $x }",
+                result: Some(vec![
+                    Value::Int { val: 1, span },
+                    Value::Int { val: 4, span },
+                    Value::Int { val: 9, span },
+                ]),
+            },
+            Example {
+                description: "Work with elements of a range",
+                example: "for $x in 1..3 { $x }",
+                result: Some(vec![
+                    Value::Int { val: 1, span },
+                    Value::Int { val: 2, span },
+                    Value::Int { val: 3, span },
+                ]),
+            },
+            Example {
+                description: "Number each item and echo a message",
+                example: "for $it in ['bob' 'fred'] --numbered { $\"($it.index) is ($it.item)\" }",
+                result: Some(vec![
+                    Value::String {
+                        val: "0 is bob".into(),
+                        span,
+                    },
+                    Value::String {
+                        val: "0 is fred".into(),
+                        span,
+                    },
+                ]),
+            },
+        ]
+    }
 }

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

@@ -1,7 +1,9 @@
 mod benchmark;
+mod ps;
 mod run_external;
 mod sys;
 
 pub use benchmark::Benchmark;
+pub use ps::Ps;
 pub use run_external::{External, ExternalCommand};
 pub use sys::Sys;

crates/nu-command/src/system/ps.rs

@@ -0,0 +1,128 @@
+use nu_protocol::{
+    ast::Call,
+    engine::{Command, EvaluationContext},
+    Example, ShellError, Signature, Value,
+};
+use sysinfo::{ProcessExt, System, SystemExt};
+
+pub struct Ps;
+
+impl Command for Ps {
+    fn name(&self) -> &str {
+        "ps"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("ps")
+            .desc("View information about system processes.")
+            .switch(
+                "long",
+                "list all available columns for each entry",
+                Some('l'),
+            )
+            .filter()
+    }
+
+    fn usage(&self) -> &str {
+        "View information about system processes."
+    }
+
+    fn run(
+        &self,
+        _context: &EvaluationContext,
+        call: &Call,
+        _input: Value,
+    ) -> Result<nu_protocol::Value, nu_protocol::ShellError> {
+        run_ps(call)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "List the system processes",
+            example: "ps",
+            result: None,
+        }]
+    }
+}
+
+fn run_ps(call: &Call) -> Result<Value, ShellError> {
+    let span = call.head;
+    let long = call.has_flag("long");
+    let mut sys = System::new_all();
+    sys.refresh_all();
+
+    let mut output = vec![];
+
+    let result: Vec<_> = sys.processes().iter().map(|x| *x.0).collect();
+
+    for pid in result {
+        if let Some(result) = sys.process(pid) {
+            let mut cols = vec![];
+            let mut vals = vec![];
+
+            cols.push("pid".into());
+            vals.push(Value::Int {
+                val: pid as i64,
+                span,
+            });
+
+            cols.push("name".into());
+            vals.push(Value::String {
+                val: result.name().into(),
+                span,
+            });
+
+            cols.push("status".into());
+            vals.push(Value::String {
+                val: format!("{:?}", result.status()),
+                span,
+            });
+
+            cols.push("cpu".into());
+            vals.push(Value::Float {
+                val: result.cpu_usage() as f64,
+                span,
+            });
+
+            cols.push("mem".into());
+            vals.push(Value::Filesize {
+                val: result.memory() * 1000,
+                span,
+            });
+
+            cols.push("virtual".into());
+            vals.push(Value::Filesize {
+                val: result.virtual_memory() * 1000,
+                span,
+            });
+
+            if long {
+                cols.push("parent".into());
+                if let Some(parent) = result.parent() {
+                    vals.push(Value::Int {
+                        val: parent as i64,
+                        span,
+                    });
+                } else {
+                    vals.push(Value::Nothing { span });
+                }
+
+                cols.push("exe".into());
+                vals.push(Value::String {
+                    val: result.exe().to_string_lossy().to_string(),
+                    span,
+                });
+
+                cols.push("command".into());
+                vals.push(Value::String {
+                    val: result.cmd().join(" "),
+                    span,
+                });
+            }
+
+            output.push(Value::Record { cols, vals, span });
+        }
+    }
+
+    Ok(Value::List { vals: output, span })
+}

crates/nu-command/src/system/sys.rs

@@ -1,7 +1,7 @@
 use nu_protocol::{
     ast::Call,
     engine::{Command, EvaluationContext},
-    ShellError, Signature, Span, Value,
+    Example, ShellError, Signature, Span, Value,
 };
 use sysinfo::{ComponentExt, DiskExt, NetworkExt, ProcessorExt, System, SystemExt, UserExt};
 
@@ -31,13 +31,13 @@ impl Command for Sys {
         run_sys(call)
     }
 
-    // fn examples(&self) -> Vec<Example> {
-    //     vec![Example {
-    //         description: "Show info about the system",
-    //         example: "sys",
-    //         result: None,
-    //     }]
-    // }
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Show info about the system",
+            example: "sys",
+            result: None,
+        }]
+    }
 }
 
 fn run_sys(call: &Call) -> Result<Value, ShellError> {