Merge pull request #48 from jonathandturner/master

Add row/col split and fix units parsing

src/cli.rs

@@ -52,7 +52,8 @@ pub async fn cli() -> Result<(), Box<Error>> {
             command("from-json", from_json::from_json),
             command("open", open::open),
             command("column", column::column),
-            command("split", split::split),
+            command("column-split", col_split::col_split),
+            command("row-split", row_split::row_split),
             command("reject", reject::reject),
             command("select", select::select),
             command("to-array", to_array::to_array),

src/commands.rs

@@ -12,7 +12,8 @@ crate mod select;
 crate mod size;
 crate mod skip;
 crate mod sort_by;
-crate mod split;
+crate mod col_split;
+crate mod row_split;
 crate mod take;
 crate mod to_array;
 crate mod to_json;

src/commands/col_split.rs

@@ -5,7 +5,7 @@ use log::debug;
 
 // TODO: "Amount remaining" wrapper
 
-pub fn split(args: CommandArgs) -> Result<OutputStream, ShellError> {
+pub fn col_split(args: CommandArgs) -> Result<OutputStream, ShellError> {
     //let splitter = args.args[0].as_string()?;
     let input = args.input;
     let args = args.args;
@@ -13,7 +13,7 @@ pub fn split(args: CommandArgs) -> Result<OutputStream, ShellError> {
     Ok(input
         .map(move |v| match v {
             Value::Primitive(Primitive::String(s)) => {
-                let splitter = args[0].as_string().unwrap();
+                let splitter = args[0].as_string().unwrap().replace("\\n", "\n");
                 debug!("splitting with {:?}", splitter);
                 let split_result: Vec<_> = s.split(&splitter).filter(|s| s.trim() != "").collect();
 

src/commands/row_split.rs

@@ -0,0 +1,37 @@
+use crate::errors::ShellError;
+use crate::object::{Primitive, Value};
+use crate::prelude::*;
+use log::debug;
+
+// TODO: "Amount remaining" wrapper
+
+pub fn row_split(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    //let splitter = args.args[0].as_string()?;
+    let input = args.input;
+    let args = args.args;
+
+    let stream = input
+        .map(move |v| match v {
+            Value::Primitive(Primitive::String(s)) => {
+                let splitter = args[0].as_string().unwrap().replace("\\n", "\n");
+                debug!("splitting with {:?}", splitter);
+                let split_result: Vec<_> = s.split(&splitter).filter(|s| s.trim() != "").collect();
+
+                debug!("split result = {:?}", split_result);
+
+                let mut result = VecDeque::new();
+                for s in split_result {
+                    result.push_back(ReturnValue::Value(Value::Primitive(Primitive::String(s.to_string()))));
+                }
+                result
+            }
+            _ => {
+                let mut result = VecDeque::new();
+                //result.push_back(ReturnValue::Value(Value::Object(crate::object::Dictionary::default())));
+                result
+            }
+        })
+        .flatten();
+
+    Ok(stream.boxed())
+}

src/parser/lexer.rs

@@ -23,7 +23,7 @@ crate enum TopToken {
     DQString,
 
     #[regex = "-?[0-9]+[A-Za-z]+"]
-    Size,
+    UnitsNum,
 
     #[regex = r"\$"]
     #[callback = "start_variable"]
@@ -88,7 +88,7 @@ impl TopToken {
             Num => Token::Num,
             SQString => Token::SQString,
             DQString => Token::DQString,
-            Size => Token::Size,
+            UnitsNum => Token::UnitsNum,
             Dollar => Token::Dollar,
             Bare => Token::Bare,
             Pipe => Token::Pipe,
@@ -344,7 +344,7 @@ pub enum Token {
     Num,
     SQString,
     DQString,
-    Size,
+    UnitsNum,
     Dollar,
     Bare,
     Pipe,

src/parser/parser.lalrpop

@@ -4,6 +4,7 @@ use std::str::FromStr;
 use crate::parser::ast::*;
 use crate::prelude::*;
 use crate::parser::lexer::{SpannedToken, Token};
+use byte_unit::Byte;
 
 grammar<'input>;
 
@@ -21,7 +22,7 @@ Command: ParsedCommand = {
 Leaf: Expression = {
     <String> => Expression::Leaf(Leaf::String(<>)),
     <Int> => Expression::Leaf(Leaf::Int(<>)),
-    //<Size> => Expression::Leaf(Leaf::Int(<>)),
+    <UnitsNum> => Expression::Leaf(Leaf::Int(<>)),
     <Variable> => Expression::VariableReference(<>),
 }
 
@@ -100,6 +101,10 @@ Int: i64 = {
     <"num"> => i64::from_str(<>.as_slice()).unwrap()
 }
 
+UnitsNum: i64 = {
+    <"unitsnum"> => Byte::from_string(<>.as_slice()).unwrap().get_bytes() as i64
+}
+
 extern {
     type Location = usize;
     type Error = ShellError;
@@ -126,6 +131,6 @@ extern {
         "bare" => SpannedToken { token: Token::Bare, .. },
         "dqstring" => SpannedToken { token: Token::DQString, .. },
         "sqstring" => SpannedToken { token: Token::SQString, .. },
-        "size" => SpannedToken { token: Token::Size, .. },
+        "unitsnum" => SpannedToken { token: Token::UnitsNum, .. },
     }
 }