Deprecate 'str collect'

crates/nu-command/src/default_context.rs

@@ -195,7 +195,7 @@ pub fn create_default_context() -> EngineState {
             Str,
             StrCamelCase,
             StrCapitalize,
-            StrCollect,
+            StrCollectDeprecated,
             StrContains,
             StrDistance,
             StrDowncase,

crates/nu-command/src/strings/str_/collect.rs

@@ -1,106 +1,34 @@
-use nu_engine::CallExt;
 use nu_protocol::ast::Call;
 use nu_protocol::engine::{Command, EngineState, Stack};
-use nu_protocol::{
-    Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Span, SyntaxShape,
-    Value,
-};
+use nu_protocol::{Category, PipelineData, Signature};
 
 #[derive(Clone)]
-pub struct StrCollect;
+pub struct StrCollectDeprecated;
 
-impl Command for StrCollect {
+impl Command for StrCollectDeprecated {
     fn name(&self) -> &str {
         "str collect"
     }
 
     fn signature(&self) -> Signature {
-        Signature::build("str collect")
-            .optional(
-                "separator",
-                SyntaxShape::String,
-                "optional separator to use when creating string",
-            )
-            .category(Category::Strings)
+        Signature::build(self.name()).category(Category::Deprecated)
     }
 
     fn usage(&self) -> &str {
-        "Concatenate multiple strings into a single string, with an optional separator between each"
-    }
-
-    fn search_terms(&self) -> Vec<&str> {
-        vec!["join", "concatenate"]
+        "Deprecated command"
     }
 
     fn run(
         &self,
-        engine_state: &EngineState,
-        stack: &mut Stack,
+        _engine_state: &EngineState,
+        _stack: &mut Stack,
         call: &Call,
-        input: PipelineData,
-    ) -> Result<PipelineData, ShellError> {
-        let separator: Option<String> = call.opt(engine_state, stack, 0)?;
-
-        let config = engine_state.get_config();
-
-        // let output = input.collect_string(&separator.unwrap_or_default(), &config)?;
-        // Hmm, not sure what we actually want. If you don't use debug_string, Date comes out as human readable
-        // which feels funny
-        let mut strings: Vec<String> = vec![];
-
-        for value in input {
-            match value {
-                Value::Error { error } => {
-                    return Err(error);
-                }
-                value => {
-                    strings.push(value.debug_string("\n", config));
-                }
-            }
-        }
-
-        let output = if let Some(separator) = separator {
-            strings.join(&separator)
-        } else {
-            strings.join("")
-        };
-
-        Ok(Value::String {
-            val: output,
-            span: call.head,
-        }
-        .into_pipeline_data())
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![
-            Example {
-                description: "Create a string from input",
-                example: "['nu', 'shell'] | str collect",
-                result: Some(Value::String {
-                    val: "nushell".to_string(),
-                    span: Span::test_data(),
-                }),
-            },
-            Example {
-                description: "Create a string from input with a separator",
-                example: "['nu', 'shell'] | str collect '-'",
-                result: Some(Value::String {
-                    val: "nu-shell".to_string(),
-                    span: Span::test_data(),
-                }),
-            },
-        ]
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    #[test]
-    fn test_examples() {
-        use crate::test_examples;
-
-        test_examples(StrCollect {})
+        _input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        Err(nu_protocol::ShellError::DeprecatedCommand(
+            self.name().to_string(),
+            "str join".to_string(),
+            call.head,
+        ))
     }
 }