array 인자

.gitignore

@@ -1,4 +1,5 @@
 .idea/*
+.vscode
 !.idea/runConfigurations/
 /target/
 Cargo.lock

.idea/runConfigurations/filter_return_type___trace.xml

@@ -1,7 +1,7 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="filter_filter - trace" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
+  <configuration default="false" name="filter_return_type - trace" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
     <option name="channel" value="DEFAULT" />
-    <option name="command" value="test --package rs-jsonpath --lib jsonpath::json_filter::tests::filter -- --exact" />
+    <option name="command" value="test --package rs-jsonpath --lib jsonpath::json_filter::tests::return_type -- --exact" />
     <option name="allFeatures" value="false" />
     <option name="nocapture" value="true" />
     <option name="backtrace" value="NO" />

benches/data_obj.json

@@ -44,8 +44,7 @@
   },
   "friends": [
     {
-      "id": 0,
+      "id": 0
-      "name": "Millicent Norman"
     },
     {
       "id": 1,

src/jsonpath/mod.rs

@@ -2,4 +2,3 @@ mod path_reader;
 mod tokenizer;
 mod parser;
 mod json_filter;
-mod utils;

src/jsonpath/parser.rs

@@ -5,12 +5,35 @@ use super::tokenizer::{
     PreloadedTokenizer,
     TokenError,
 };
-use super::utils;
 
 const DUMMY: usize = 0;
 
 type Result<T> = result::Result<T, String>;
 
+mod utils {
+    use std::result;
+
+    pub fn vec_to_int<F>(vec: &Vec<char>, msg_handler: F) -> result::Result<isize, String>
+        where F: Fn() -> String {
+        match vec.iter().map(|c| *c).collect::<String>().as_str().parse::<isize>() {
+            Ok(n) => Ok(n),
+            _ => Err(msg_handler())
+        }
+    }
+
+    pub fn vec_to_float<F>(vec: &Vec<char>, msg_handler: F) -> result::Result<f64, String>
+        where F: Fn() -> String {
+        match vec.iter().map(|c| *c).collect::<String>().as_str().parse::<f64>() {
+            Ok(n) => Ok(n),
+            _ => Err(msg_handler())
+        }
+    }
+
+    pub fn vec_to_string(vec: &Vec<char>) -> String {
+        vec.iter().map(|c| *c).collect::<String>()
+    }
+}
+
 #[derive(Debug, PartialEq)]
 pub enum ParseToken {
     // '$'
@@ -649,9 +672,9 @@ pub trait NodeVisitor {
             }
             ParseToken::Filter(_) => {
                 node.left.map(|n| self.visit(*n));
-                self.clean_filter_context();
+                self.end_term();
                 node.right.map(|n| self.visit(*n));
-                self.clean_filter_context();
+                self.end_term();
                 self.visit_token(node.token);
             }
             _ => {}
@@ -659,7 +682,7 @@ pub trait NodeVisitor {
     }
 
     fn visit_token(&mut self, token: ParseToken);
-    fn clean_filter_context(&mut self) {}
+    fn end_term(&mut self) {}
 }
 
 #[cfg(test)]

src/jsonpath/tokenizer.rs

@@ -291,27 +291,21 @@ impl<'a> PreloadedTokenizer<'a> {
     pub fn new(input: &'a str) -> Self {
         let mut tokenizer = Tokenizer::new(input);
         let mut tokens = vec![];
-        let mut err = TokenError::Eof;
-        let mut err_pos = 0;
         loop {
             match tokenizer.next_token() {
                 Ok(t) => {
                     tokens.insert(0, (tokenizer.current_pos(), t));
                 }
                 Err(e) => {
-                    err = e;
+                    return PreloadedTokenizer {
-                    err_pos = tokenizer.current_pos();
-                    break;
-                }
-            }
-        }
-
-        PreloadedTokenizer {
                         origin_input: input.clone(),
-            err,
+                        err: e,
-            err_pos,
+                        err_pos: tokenizer.current_pos(),
                         tokens,
                         curr_pos: None,
+                    };
+                }
+            }
         }
     }
 

src/jsonpath/utils.rs

@@ -1,21 +0,0 @@
-use std::result;
-
-pub fn vec_to_int<F>(vec: &Vec<char>, msg_handler: F) -> result::Result<isize, String>
-    where F: Fn() -> String {
-    match vec.iter().map(|c| *c).collect::<String>().as_str().parse::<isize>() {
-        Ok(n) => Ok(n),
-        _ => Err(msg_handler())
-    }
-}
-
-pub fn vec_to_float<F>(vec: &Vec<char>, msg_handler: F) -> result::Result<f64, String>
-    where F: Fn() -> String {
-    match vec.iter().map(|c| *c).collect::<String>().as_str().parse::<f64>() {
-        Ok(n) => Ok(n),
-        _ => Err(msg_handler())
-    }
-}
-
-pub fn vec_to_string(vec: &Vec<char>) -> String {
-    vec.iter().map(|c| *c).collect::<String>()
-}