Port help and start porting split

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

@@ -1,3 +1,5 @@
 mod build_string;
+mod split;
 
 pub use build_string::BuildString;
+pub use split::*;

crates/nu-command/src/strings/split/chars.rs

@@ -0,0 +1,157 @@
+use nu_protocol::{
+    ast::Call,
+    engine::{Command, EvaluationContext},
+    Example, IntoValueStream, ShellError, Signature, Span, Type, Value,
+};
+
+pub struct SubCommand;
+
+impl Command for SubCommand {
+    fn name(&self) -> &str {
+        "split chars"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("split chars")
+    }
+
+    fn usage(&self) -> &str {
+        "splits a string's characters into separate rows"
+    }
+
+    fn run(
+        &self,
+        _context: &EvaluationContext,
+        call: &Call,
+        input: Value,
+    ) -> Result<nu_protocol::Value, nu_protocol::ShellError> {
+        split_chars(call, input)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Split the string's characters into separate rows",
+            example: "echo 'hello' | split chars",
+            result: Some(vec![
+                Value::String {
+                    val: "h".into(),
+                    span: Span::unknown(),
+                },
+                Value::String {
+                    val: "e".into(),
+                    span: Span::unknown(),
+                },
+                Value::String {
+                    val: "l".into(),
+                    span: Span::unknown(),
+                },
+                Value::String {
+                    val: "l".into(),
+                    span: Span::unknown(),
+                },
+                Value::String {
+                    val: "o".into(),
+                    span: Span::unknown(),
+                },
+            ]),
+        }]
+    }
+}
+
+fn split_chars(call: &Call, input: Value) -> Result<nu_protocol::Value, nu_protocol::ShellError> {
+    let name = call.head;
+
+    Ok(match input {
+        Value::List { vals, span } => Value::List {
+            vals: vals
+                .iter()
+                .flat_map(move |v| {
+                    if let Ok(s) = v.as_string() {
+                        let v_span = v.span();
+                        s.chars()
+                            .collect::<Vec<_>>()
+                            .into_iter()
+                            .map(move |x| Value::String {
+                                val: x.to_string(),
+                                span: v_span,
+                            })
+                            .collect()
+                    } else {
+                        vec![Value::Error {
+                            error: ShellError::PipelineMismatch {
+                                expected: Type::String,
+                                expected_span: name,
+                                origin: v.span(),
+                            },
+                        }]
+                    }
+                })
+                .collect(),
+            span,
+        },
+        Value::Stream { stream, span } => Value::Stream {
+            stream: stream
+                .flat_map(move |v| {
+                    if let Ok(s) = v.as_string() {
+                        let v_span = v.span();
+                        s.chars()
+                            .collect::<Vec<_>>()
+                            .into_iter()
+                            .map(move |x| Value::String {
+                                val: x.to_string(),
+                                span: v_span,
+                            })
+                            .collect()
+                    } else {
+                        vec![Value::Error {
+                            error: ShellError::PipelineMismatch {
+                                expected: Type::String,
+                                expected_span: name,
+                                origin: v.span(),
+                            },
+                        }]
+                    }
+                })
+                .into_value_stream(),
+            span,
+        },
+        v => {
+            let v_span = v.span();
+            if let Ok(s) = v.as_string() {
+                Value::List {
+                    vals: s
+                        .chars()
+                        .collect::<Vec<_>>()
+                        .into_iter()
+                        .map(move |x| Value::String {
+                            val: x.to_string(),
+                            span: v_span,
+                        })
+                        .collect(),
+                    span: v_span,
+                }
+            } else {
+                Value::Error {
+                    error: ShellError::PipelineMismatch {
+                        expected: Type::String,
+                        expected_span: name,
+                        origin: v.span(),
+                    },
+                }
+            }
+        }
+    })
+}
+
+// #[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;
+
+//         test_examples(SubCommand {})
+//     }
+// }

crates/nu-command/src/strings/split/command.rs

@@ -0,0 +1,48 @@
+use nu_engine::get_full_help;
+use nu_protocol::{
+    ast::Call,
+    engine::{Command, EvaluationContext},
+    Signature, Value,
+};
+
+#[derive(Clone)]
+pub struct SplitCommand;
+
+impl Command for SplitCommand {
+    fn name(&self) -> &str {
+        "split"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("split")
+    }
+
+    fn usage(&self) -> &str {
+        "Split contents across desired subcommand (like row, column) via the separator."
+    }
+
+    fn run(
+        &self,
+        context: &EvaluationContext,
+        call: &Call,
+        _input: Value,
+    ) -> Result<nu_protocol::Value, nu_protocol::ShellError> {
+        Ok(Value::String {
+            val: get_full_help(&SplitCommand.signature(), &SplitCommand.examples(), context),
+            span: call.head,
+        })
+    }
+}
+
+// #[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;
+
+//         test_examples(Command {})
+//     }
+// }

crates/nu-command/src/strings/split/mod.rs

@@ -0,0 +1,9 @@
+pub mod chars;
+// pub mod column;
+pub mod command;
+// pub mod row;
+
+pub use chars::SubCommand as SplitChars;
+// pub use column::SubCommand as SplitColumn;
+pub use command::SplitCommand as Split;
+// pub use row::SubCommand as SplitRow;