Finish remove the last traces of per-item (#1685)

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

@@ -207,7 +207,7 @@ pub struct RunnableContext {
 }
 
 impl RunnableContext {
-    pub fn get_command(&self, name: &str) -> Option<Arc<Command>> {
+    pub fn get_command(&self, name: &str) -> Option<Command> {
         self.registry.get_command(name)
     }
 }
@@ -370,146 +370,54 @@ pub trait WholeStreamCommand: Send + Sync {
     }
 }
 
-pub trait PerItemCommand: Send + Sync {
-    fn name(&self) -> &str;
-
-    fn signature(&self) -> Signature {
-        Signature::new(self.name()).desc(self.usage()).filter()
-    }
-
-    fn usage(&self) -> &str;
-
-    fn run(
-        &self,
-        call_info: &CallInfo,
-        registry: &CommandRegistry,
-        raw_args: &RawCommandArgs,
-        input: Value,
-    ) -> Result<OutputStream, ShellError>;
-
-    fn is_binary(&self) -> bool {
-        false
-    }
-}
-
-pub enum Command {
-    WholeStream(Arc<dyn WholeStreamCommand>),
-    PerItem(Arc<dyn PerItemCommand>),
-}
+#[derive(Clone)]
+pub struct Command(Arc<dyn WholeStreamCommand>);
 
 impl PrettyDebugWithSource for Command {
     fn pretty_debug(&self, source: &str) -> DebugDocBuilder {
-        match self {
-            Command::WholeStream(command) => b::typed(
+        b::typed(
             "whole stream command",
-                b::description(command.name())
+            b::description(self.name())
                 + b::space()
                 + b::equals()
                 + b::space()
-                    + command.signature().pretty_debug(source),
-            ),
-            Command::PerItem(command) => b::typed(
-                "per item command",
-                b::description(command.name())
-                    + b::space()
-                    + b::equals()
-                    + b::space()
-                    + command.signature().pretty_debug(source),
-            ),
-        }
+                + self.signature().pretty_debug(source),
+        )
     }
 }
 
 impl std::fmt::Debug for Command {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Command::WholeStream(command) => write!(f, "WholeStream({})", command.name()),
-            Command::PerItem(command) => write!(f, "PerItem({})", command.name()),
-        }
+        write!(f, "Command({})", self.name())
     }
 }
 
 impl Command {
     pub fn name(&self) -> &str {
-        match self {
-            Command::WholeStream(command) => command.name(),
-            Command::PerItem(command) => command.name(),
-        }
+        self.0.name()
     }
 
     pub fn signature(&self) -> Signature {
-        match self {
-            Command::WholeStream(command) => command.signature(),
-            Command::PerItem(command) => command.signature(),
-        }
+        self.0.signature()
     }
 
     pub fn usage(&self) -> &str {
-        match self {
-            Command::WholeStream(command) => command.usage(),
-            Command::PerItem(command) => command.usage(),
-        }
+        self.0.usage()
     }
 
     pub fn run(&self, args: CommandArgs, registry: &CommandRegistry) -> OutputStream {
         if args.call_info.switch_present("help") {
             get_help(self.name(), self.usage(), self.signature()).into()
         } else {
-            match self {
-                Command::WholeStream(command) => match command.run(args, registry) {
+            match self.0.run(args, registry) {
                 Ok(stream) => stream,
                 Err(err) => OutputStream::one(Err(err)),
-                },
-                Command::PerItem(command) => {
-                    self.run_helper(command.clone(), args, registry.clone())
             }
         }
     }
-    }
-
-    fn run_helper(
-        &self,
-        command: Arc<dyn PerItemCommand>,
-        args: CommandArgs,
-        registry: CommandRegistry,
-    ) -> OutputStream {
-        let raw_args = RawCommandArgs {
-            host: args.host,
-            ctrl_c: args.ctrl_c,
-            shell_manager: args.shell_manager,
-            call_info: args.call_info,
-        };
-
-        let out = args
-            .input
-            .map(move |x| {
-                let call_info = UnevaluatedCallInfo {
-                    args: raw_args.call_info.args.clone(),
-                    name_tag: raw_args.call_info.name_tag.clone(),
-                    scope: raw_args.call_info.scope.clone().set_it(x.clone()),
-                }
-                .evaluate(&registry);
-
-                match call_info {
-                    Ok(call_info) => match command.run(&call_info, &registry, &raw_args, x) {
-                        Ok(o) => o,
-                        Err(e) => {
-                            futures::stream::iter(vec![ReturnValue::Err(e)]).to_output_stream()
-                        }
-                    },
-                    Err(e) => futures::stream::iter(vec![ReturnValue::Err(e)]).to_output_stream(),
-                }
-            })
-            .flatten();
-
-        out.to_output_stream()
-    }
 
     pub fn is_binary(&self) -> bool {
-        match self {
-            Command::WholeStream(command) => command.is_binary(),
-            Command::PerItem(command) => command.is_binary(),
-        }
+        self.0.is_binary()
     }
 }
 
@@ -571,6 +479,6 @@ impl WholeStreamCommand for FnFilterCommand {
     }
 }
 
-pub fn whole_stream_command(command: impl WholeStreamCommand + 'static) -> Arc<Command> {
-    Arc::new(Command::WholeStream(Arc::new(command)))
+pub fn whole_stream_command(command: impl WholeStreamCommand + 'static) -> Command {
+    Command(Arc::new(command))
 }

crates/nu-cli/src/context.rs

@@ -16,7 +16,7 @@ use std::sync::Arc;
 
 #[derive(Debug, Clone, Default)]
 pub struct CommandRegistry {
-    registry: Arc<Mutex<IndexMap<String, Arc<Command>>>>,
+    registry: Arc<Mutex<IndexMap<String, Command>>>,
 }
 
 impl SignatureRegistry for CommandRegistry {
@@ -42,13 +42,13 @@ impl CommandRegistry {
 }
 
 impl CommandRegistry {
-    pub(crate) fn get_command(&self, name: &str) -> Option<Arc<Command>> {
+    pub(crate) fn get_command(&self, name: &str) -> Option<Command> {
         let registry = self.registry.lock();
 
         registry.get(name).cloned()
     }
 
-    pub(crate) fn expect_command(&self, name: &str) -> Result<Arc<Command>, ShellError> {
+    pub(crate) fn expect_command(&self, name: &str) -> Result<Command, ShellError> {
         self.get_command(name).ok_or_else(|| {
             ShellError::untagged_runtime_error(format!("Could not load command: {}", name))
         })
@@ -60,7 +60,7 @@ impl CommandRegistry {
         registry.contains_key(name)
     }
 
-    pub(crate) fn insert(&mut self, name: impl Into<String>, command: Arc<Command>) {
+    pub(crate) fn insert(&mut self, name: impl Into<String>, command: Command) {
         let mut registry = self.registry.lock();
         registry.insert(name.into(), command);
     }
@@ -209,23 +209,23 @@ impl Context {
         block(&mut *errors)
     }
 
-    pub fn add_commands(&mut self, commands: Vec<Arc<Command>>) {
+    pub fn add_commands(&mut self, commands: Vec<Command>) {
         for command in commands {
             self.registry.insert(command.name().to_string(), command);
         }
     }
 
-    pub(crate) fn get_command(&self, name: &str) -> Option<Arc<Command>> {
+    pub(crate) fn get_command(&self, name: &str) -> Option<Command> {
         self.registry.get_command(name)
     }
 
-    pub(crate) fn expect_command(&self, name: &str) -> Result<Arc<Command>, ShellError> {
+    pub(crate) fn expect_command(&self, name: &str) -> Result<Command, ShellError> {
         self.registry.expect_command(name)
     }
 
     pub(crate) fn run_command(
         &mut self,
-        command: Arc<Command>,
+        command: Command,
         name_tag: Tag,
         args: hir::Call,
         scope: &Scope,

crates/nu-cli/src/data/command.rs

@@ -2,22 +2,15 @@ use crate::commands::command::Command;
 use crate::data::TaggedListBuilder;
 use crate::prelude::*;
 use nu_protocol::{NamedType, PositionalType, Signature, TaggedDictBuilder, UntaggedValue, Value};
-use std::ops::Deref;
 
-pub(crate) fn command_dict(command: Arc<Command>, tag: impl Into<Tag>) -> Value {
+pub(crate) 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(match command.deref() {
-            Command::WholeStream(_) => "Command",
-            Command::PerItem(_) => "Filter",
-        }),
-    );
+    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()));