[from|to]csv additions/refactoring.

Introduced flag to tell `from-to` / `to-csv` whether we want headers parsed and/or written.

src/commands/from_csv.rs

@@ -5,26 +5,32 @@ use csv::ReaderBuilder;
 
 pub struct FromCSV;
 
-impl WholeStreamCommand for FromCSV {
-    fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        from_csv(args, registry)
-    }
+#[derive(Deserialize)]
+pub struct FromCSVArgs {
+    headerless: bool,
+}
 
+impl WholeStreamCommand for FromCSV {
     fn name(&self) -> &str {
         "from-csv"
     }
 
     fn signature(&self) -> Signature {
-        Signature::build("from-csv")
+        Signature::build("from-csv").switch("headerless")
+    }
+
+    fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        args.process(registry, from_csv)?.run()
     }
 }
 
 pub fn from_csv_string_to_value(
     s: String,
+    headerless: bool,
     tag: impl Into<Tag>,
 ) -> Result<Tagged<Value>, csv::Error> {
     let mut reader = ReaderBuilder::new()
@@ -39,8 +45,12 @@ pub fn from_csv_string_to_value(
     if let Some(result) = iter.next() {
         let line = result?;
 
-        for item in line.iter() {
-            fields.push_back(item.to_string());
+        for (idx, item) in line.iter().enumerate() {
+            if headerless {
+                fields.push_back(format!("Column{}", idx + 1));
+            } else {
+                fields.push_back(item.to_string());
+            }
         }
     }
 
@@ -66,10 +76,13 @@ pub fn from_csv_string_to_value(
     Ok(Tagged::from_item(Value::List(rows), tag))
 }
 
-fn from_csv(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStream, ShellError> {
-    let args = args.evaluate_once(registry)?;
-    let span = args.name_span();
-    let input = args.input;
+fn from_csv(
+    FromCSVArgs {
+        headerless: skip_headers,
+    }: FromCSVArgs,
+    RunnableContext { input, name, .. }: RunnableContext,
+) -> Result<OutputStream, ShellError> {
+    let name_span = name;
 
     let stream = async_stream_block! {
         let values: Vec<Tagged<Value>> = input.values.collect().await;
@@ -88,7 +101,7 @@ fn from_csv(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStrea
                 _ => yield Err(ShellError::labeled_error_with_secondary(
                     "Expected a string from pipeline",
                     "requires string input",
-                    span,
+                    name_span,
                     "value originates from here",
                     value_tag.span,
                 )),
@@ -96,7 +109,7 @@ fn from_csv(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStrea
             }
         }
 
-        match from_csv_string_to_value(concat_string, span) {
+        match from_csv_string_to_value(concat_string, skip_headers, name_span) {
             Ok(x) => match x {
                 Tagged { item: Value::List(list), .. } => {
                     for l in list {
@@ -109,7 +122,7 @@ fn from_csv(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStrea
                 yield Err(ShellError::labeled_error_with_secondary(
                     "Could not parse as CSV",
                     "input cannot be parsed as CSV",
-                    span,
+                    name_span,
                     "value originates from here",
                     last_tag.span,
                 ))

src/commands/open.rs

@@ -428,6 +428,7 @@ pub fn parse_string_as_value(
     match extension {
         Some(x) if x == "csv" => crate::commands::from_csv::from_csv_string_to_value(
             contents,
+            false,
             contents_tag,
         )
         .map_err(move |_| {

src/commands/to_csv.rs

@@ -5,21 +5,26 @@ use csv::WriterBuilder;
 
 pub struct ToCSV;
 
-impl WholeStreamCommand for ToCSV {
-    fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        to_csv(args, registry)
-    }
+#[derive(Deserialize)]
+pub struct ToCSVArgs {
+    headerless: bool,
+}
 
+impl WholeStreamCommand for ToCSV {
     fn name(&self) -> &str {
         "to-csv"
     }
 
     fn signature(&self) -> Signature {
-        Signature::build("to-csv")
+        Signature::build("to-csv").switch("headerless")
+    }
+
+    fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        args.process(registry, to_csv)?.run()
     }
 }
 
@@ -27,6 +32,9 @@ pub fn value_to_csv_value(v: &Value) -> Value {
     match v {
         Value::Primitive(Primitive::String(s)) => Value::Primitive(Primitive::String(s.clone())),
         Value::Primitive(Primitive::Nothing) => Value::Primitive(Primitive::Nothing),
+        Value::Primitive(Primitive::Boolean(b)) => Value::Primitive(Primitive::Boolean(b.clone())),
+        Value::Primitive(Primitive::Bytes(b)) => Value::Primitive(Primitive::Bytes(b.clone())),
+        Value::Primitive(Primitive::Date(d)) => Value::Primitive(Primitive::Date(d.clone())),
         Value::Object(o) => Value::Object(o.clone()),
         Value::List(l) => Value::List(l.clone()),
         Value::Block(_) => Value::Primitive(Primitive::Nothing),
@@ -34,9 +42,20 @@ pub fn value_to_csv_value(v: &Value) -> Value {
     }
 }
 
+fn to_string_helper(v: &Value) -> Result<String, Box<dyn std::error::Error>> {
+    match v {
+        Value::Primitive(Primitive::Date(d)) => Ok(d.to_string()),
+        Value::Primitive(Primitive::Bytes(b)) => Ok(format!("{}", *b as u64)),
+        Value::Primitive(Primitive::Boolean(_)) => Ok(v.as_string()?),
+        Value::List(_) => return Ok(String::from("[list list]")),
+        Value::Object(_) => return Ok(String::from("[object]")),
+        Value::Primitive(Primitive::String(s)) => return Ok(s.to_string()),
+        _ => return Err("Bad input".into()),
+    }
+}
+
 pub fn to_string(v: &Value) -> Result<String, Box<dyn std::error::Error>> {
     match v {
-        Value::List(_l) => return Ok(String::from("[list list]")),
         Value::Object(o) => {
             let mut wtr = WriterBuilder::new().from_writer(vec![]);
             let mut fields: VecDeque<String> = VecDeque::new();
@@ -44,7 +63,7 @@ pub fn to_string(v: &Value) -> Result<String, Box<dyn std::error::Error>> {
 
             for (k, v) in o.entries.iter() {
                 fields.push_back(k.clone());
-                values.push_back(to_string(&v)?);
+                values.push_back(to_string_helper(&v)?);
             }
 
             wtr.write_record(fields).expect("can not write.");
@@ -52,22 +71,31 @@ pub fn to_string(v: &Value) -> Result<String, Box<dyn std::error::Error>> {
 
             return Ok(String::from_utf8(wtr.into_inner()?)?);
         }
-        Value::Primitive(Primitive::String(s)) => return Ok(s.to_string()),
-        _ => return Err("Bad input".into()),
+        _ => return to_string_helper(&v),
     }
 }
 
-fn to_csv(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStream, ShellError> {
-    let args = args.evaluate_once(registry)?;
-    let name_span = args.name_span();
-    let out = args.input;
+fn to_csv(
+    ToCSVArgs { headerless }: ToCSVArgs,
+    RunnableContext { input, name, .. }: RunnableContext,
+) -> Result<OutputStream, ShellError> {
+    let name_span = name;
+    let out = input;
 
     Ok(out
         .values
         .map(move |a| match to_string(&value_to_csv_value(&a.item)) {
-            Ok(x) => ReturnSuccess::value(
-                Value::Primitive(Primitive::String(x)).simple_spanned(name_span),
-            ),
+            Ok(x) => {
+                let converted = if headerless {
+                    x.lines().skip(1).collect()
+                } else {
+                    x
+                };
+
+                ReturnSuccess::value(
+                    Value::Primitive(Primitive::String(converted)).simple_spanned(name_span),
+                )
+            }
             _ => Err(ShellError::labeled_error_with_secondary(
                 "Expected an object with CSV-compatible structure from pipeline",
                 "requires CSV-compatible input",