Remove unused help shell. Slight cleanup and improvement. (#3258)

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

@@ -89,24 +89,7 @@ async fn enter(raw_args: CommandArgs) -> Result<OutputStream, ShellError> {
     let location_string = location.display().to_string();
     let location_clone = location_string.clone();
 
-    if location_string.starts_with("help") {
-        let spec = location_string.split(':').collect::<Vec<&str>>();
-
-        if spec.len() == 2 {
-            let (_, command) = (spec[0], spec[1]);
-
-            if scope.has_command(command) {
-                return Ok(OutputStream::one(ReturnSuccess::action(
-                    CommandAction::EnterHelpShell(
-                        UntaggedValue::string(command).into_value(Tag::unknown()),
-                    ),
-                )));
-            }
-        }
-        Ok(OutputStream::one(ReturnSuccess::action(
-            CommandAction::EnterHelpShell(UntaggedValue::nothing().into_value(Tag::unknown())),
-        )))
-    } else if location.is_dir() {
+    if location.is_dir() {
         Ok(OutputStream::one(ReturnSuccess::action(
             CommandAction::EnterShell(location_clone),
         )))

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

@@ -1,9 +1,13 @@
 use crate::prelude::*;
-use nu_engine::command_dict;
+use crate::TaggedListBuilder;
 use nu_engine::documentation::generate_docs;
-use nu_engine::WholeStreamCommand;
+use nu_engine::{Command, WholeStreamCommand};
 use nu_errors::ShellError;
-use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, TaggedDictBuilder, UntaggedValue, Value};
+use nu_protocol::{
+    NamedType, PositionalType, ReturnSuccess, Signature, SyntaxShape, TaggedDictBuilder,
+    UntaggedValue, Value,
+};
+use nu_source::Tag;
 use nu_source::{SpannedItem, Tagged};
 use nu_value_ext::ValueExt;
 
@@ -208,6 +212,62 @@ You can also learn more at https://www.nushell.sh/book/"#;
     }
 }
 
+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.iter() {
+        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.iter() {
+        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()
+}
+
 #[cfg(test)]
 mod tests {
     use super::Help;

crates/nu-command/src/commands/str_/to_integer.rs

@@ -1,10 +1,9 @@
 use crate::prelude::*;
+use crate::utils::arguments::arguments;
 use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
 use nu_protocol::ShellTypeName;
-use nu_protocol::{
-    ColumnPath, Primitive, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value,
-};
+use nu_protocol::{Primitive, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
 use nu_source::{Tag, Tagged};
 use nu_value_ext::ValueExt;
 
@@ -13,7 +12,7 @@ use num_traits::Num;
 
 #[derive(Deserialize)]
 struct Arguments {
-    rest: Vec<ColumnPath>,
+    rest: Vec<Value>,
     radix: Option<Tagged<u32>>,
 }
 
@@ -29,7 +28,7 @@ impl WholeStreamCommand for SubCommand {
         Signature::build("str to-int")
             .named("radix", SyntaxShape::Number, "radix of integer", Some('r'))
             .rest(
-                SyntaxShape::ColumnPath,
+                SyntaxShape::Any,
                 "optionally convert text into integer by column paths",
             )
     }
@@ -69,12 +68,11 @@ impl WholeStreamCommand for SubCommand {
 }
 
 async fn operate(args: CommandArgs) -> Result<OutputStream, ShellError> {
-    let (Arguments { rest, radix }, input) = args.process().await?;
+    let (Arguments { mut rest, radix }, input) = args.process().await?;
+    let (column_paths, _) = arguments(&mut rest)?;
 
     let radix = radix.map(|r| r.item).unwrap_or(10);
 
-    let column_paths: Vec<ColumnPath> = rest;
-
     Ok(input
         .map(move |v| {
             if column_paths.is_empty() {