Implement formats function using function generalization

Remove initial formats from parser
mitghi · Mar 12, 2023 · 3dd784f · 3dd784f
1 parent 3d7d91f
commit 3dd784f
Show file tree

Hide file tree

Showing 5 changed files with 161 additions and 92 deletions.
diff --git a/src/context.rs b/src/context.rs
@@ -1,7 +1,6 @@
 //! Module containing types and functionalities for
 //! evaluating jetro paths.
 
-use crate::fmt as jetrofmt;
 use crate::parser;
 #[allow(unused_imports)]
 use serde::{Deserialize, Serialize};
@@ -207,7 +206,6 @@ pub enum Filter {
     Child(String),
     Descendant(String),
     Pick(Vec<PickFilterInner>),
-    Format(FormatOp),
     ArrayIndex(usize),
     ArrayFrom(usize),
     ArrayTo(usize),
@@ -231,7 +229,6 @@ struct StackItem<'a> {
 struct Context<'a> {
     root: Rc<Value>,
     stack: Rc<RefCell<Vec<StackItem<'a>>>>,
-    formater: Box<dyn jetrofmt::KeyFormater>,
     registry: Box<dyn crate::func::Registry>,
     pub results: Rc<RefCell<Vec<Rc<Value>>>>,
 }
@@ -257,15 +254,17 @@ pub enum FuncArg {
 pub struct Func {
     pub name: String,
     pub args: Vec<FuncArg>,
+    pub alias: Option<String>,
+    pub should_deref: bool,
 }
 
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
             Error::EmptyQuery => write!(f, "query is empty"),
-            Error::Parse(ref msg) => write!(f, "error while parsing query: {}", &msg),
-            Error::Eval(ref msg) => write!(f, "error while evaluating query: {}", &msg),
-            Error::FuncEval(ref msg) => write!(f, "error while evaluating function: {}", &msg),
+            Error::Parse(ref msg) => write!(f, "parse: {}", &msg),
+            Error::Eval(ref msg) => write!(f, "eval: {}", &msg),
+            Error::FuncEval(ref msg) => write!(f, "func_eval: {}", &msg),
         }
     }
 }
@@ -386,6 +385,8 @@ impl Func {
         Self {
             name: String::new(),
             args: Vec::new(),
+            alias: None,
+            should_deref: false,
         }
     }
 }
@@ -660,7 +661,6 @@ impl<'a> Context<'a> {
         let results: Rc<RefCell<Vec<Rc<Value>>>> = Rc::new(RefCell::new(Vec::new()));
         let stack: Rc<RefCell<Vec<StackItem<'a>>>> = Rc::new(RefCell::new(Vec::new()));
         let rv: Rc<Value> = Rc::new(value);
-        let formater: Box<dyn jetrofmt::KeyFormater> = jetrofmt::default();
         let registry: Box<dyn crate::func::Registry> = crate::func::default_registry();
         stack
             .borrow_mut()
@@ -669,7 +669,6 @@ impl<'a> Context<'a> {
         Self {
             root: rv.clone(),
             stack,
-            formater,
             registry,
             results,
         }
@@ -934,15 +933,6 @@ impl<'a> Context<'a> {
                         _ => {}
                     },
 
-                    (Filter::Format(ref target_format), Some(tail)) => {
-                        match self.formater.eval(&target_format, &current.value) {
-                            Some(output) => {
-                                push_to_stack_or_produce!(self.results, self.stack, tail, output);
-                            }
-                            _ => {}
-                        };
-                    }
-
                     (Filter::ArrayIndex(ref index), Some(tail)) => match *current.value {
                         Value::Array(ref array) => {
                             if *index < array.len() {

diff --git a/src/fmt.rs b/src/fmt.rs
@@ -9,7 +9,7 @@ pub(crate) trait KeyFormater {
     fn eval(&self, target_format: &FormatOp, value: &Value) -> Option<Value>;
 }
 
-struct FormatImpl;
+pub(crate) struct FormatImpl;
 
 impl FormatImpl {
     fn format(&self, format: &str, value: &Value, keys: &Vec<String>) -> Option<String> {
@@ -60,7 +60,7 @@ impl KeyFormater for FormatImpl {
     }
 }
 
-pub(crate) fn default() -> Box<impl KeyFormater> {
+pub(crate) fn default_formater() -> Box<impl KeyFormater> {
     Box::new(FormatImpl)
 }
 

diff --git a/src/func.rs b/src/func.rs
@@ -1,6 +1,6 @@
 //! Module func provides abstraction for jetro functions.
 
-use crate::context::{Error, Func};
+use crate::context::{Error, Func, FuncArg};
 use serde_json::Value;
 use std::collections::BTreeMap;
 
@@ -62,10 +62,60 @@ impl Callable for Reverse {
     }
 }
 
+struct Formats;
+
+impl Formats {
+    fn ensure_str(&mut self, value: &Value) -> Result<(), Error> {
+        match &value {
+            Value::String(_) => Ok(()),
+            _ => Err(Error::FuncEval("invalid type, expected string".to_string())),
+        }
+    }
+}
+
+impl Callable for Formats {
+    fn call(&mut self, func: &Func, value: &Value) -> Result<Value, Error> {
+        if func.args.len() < 2 {
+            return Err(Error::FuncEval("deficit number of arguments".to_string()));
+        }
+        let format = match func.args.get(0).unwrap() {
+            FuncArg::Key(some_key) => some_key,
+            _ => {
+                return Err(Error::FuncEval("invalid type, expected string".to_string()));
+            }
+        };
+        let mut args: Vec<String> = vec![];
+        for v in func.args[1..].iter() {
+            match &v {
+                FuncArg::Key(some_key) => {
+                    args.push(some_key.clone());
+                }
+                _ => {
+                    return Err(Error::FuncEval("invalid type, expected string".to_string()));
+                }
+            };
+        }
+
+        let formater: Box<dyn crate::fmt::KeyFormater> = crate::fmt::default_formater();
+        match formater.eval(
+            &crate::context::FormatOp::FormatString {
+                format: format.to_string(),
+                arguments: args,
+                alias: func.alias.clone().unwrap(),
+            },
+            &value,
+        ) {
+            Some(output) => Ok(output),
+            _ => Err(Error::FuncEval("format failed".to_string())),
+        }
+    }
+}
+
 impl Default for FuncRegistry {
     fn default() -> Self {
         let mut output = FuncRegistry::new();
         output.register("reverse", Box::new(Reverse));
+        output.register("formats", Box::new(Formats));
         output
     }
 }

diff --git a/src/grammar.pest b/src/grammar.pest
@@ -51,8 +51,8 @@ pick = {
     ((",") ~ (" ")* ~ (literal_keyed | (sub_expression_keyed | sub_expression_keyed_reversed) ))* ~
     (" ")* ~ ")"
 }
-sub_expression = { path ~ (formatsFn | lenFn | allFn | pickFn | sumFn | filterFn | child | any_child | grouped_any | descendant_child | array_index | slice | array_to | array_from | fn)* }
-sub_expression_reversed = { reverse_path ~ (formatsFn | lenFn | allFn | pickFn | sumFn | filterFn | grouped_any | child | any_child | descendant_child | array_index | slice | array_to | array_from | fn)* }
+sub_expression = { path ~ (lenFn | allFn | pickFn | sumFn | filterFn | child | any_child | grouped_any | descendant_child | array_index | slice | array_to | array_from | fn)* }
+sub_expression_reversed = { reverse_path ~ (lenFn | allFn | pickFn | sumFn | filterFn | grouped_any | child | any_child | descendant_child | array_index | slice | array_to | array_from | fn)* }
 sub_expression_keyed = { sub_expression ~ as? }
 sub_expression_keyed_reversed = { sub_expression_reversed ~ as? }
 
@@ -65,8 +65,6 @@ lenFn = { slash ~ len }
 sumFn = { slash ~ sum }
 squashFn = { slash ~ squash }
 pickFn = { slash ~ pick }
-formats = { sharp ~ "formats" ~ whitespace ~ lparen ~ literal ~ ((",")* ~ whitespace ~ literal)+ ~ whitespace ~ rparen ~ whitespace ~ (as | asDeref)}
-formatsFn = { slash ~ formats }
 fnLit = { literal }
 fnExpr = { sub_expression }
 fnCall = { sharp ~ ident ~ whitespace ~ lparen ~ ((filterStmtCollection|fnLit|fnExpr ) ~ whitespace ~ ((",")* ~ whitespace ~ (filterStmtCollection|fnLit|fnExpr))*)? ~ whitespace ~ rparen ~ whitespace ~ (as | asDeref)? }
@@ -79,6 +77,6 @@ filterFn = { slash ~ filter }
 
 expression = {
     (path|reverse_path) ~
-    (formatsFn | lenFn | allFn | pickFn | sumFn | filterFn | grouped_any | child | any_child | descendant_child | array_index | slice | array_to | array_from | fn)* ~
+    (lenFn | allFn | pickFn | sumFn | filterFn | grouped_any | child | any_child | descendant_child | array_index | slice | array_to | array_from | fn)* ~
     EOI
 }