fluencelabs/jsonpath
1
0
Fork 0
mirror of https://github.com/fluencelabs/jsonpath synced 2025-04-25 01:12:17 +00:00
Code Issues Projects Releases Wiki Activity

토큰 이후 배열이 왔을 때 필터링 되지 않는 문제 수정

Browse Source
This commit is contained in:
freestrings 2019-04-08 12:15:35 +09:00
parent 95c9d0f837
commit d75b93612d
2 changed files with 82 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

130
src/filter/value_filter.rs
View File

@ -6,8 +6,8 @@ use serde_json::Value;
use filter::term::*;
use filter::value_wrapper::*;
use parser::parser::{FilterToken, NodeVisitor, ParseToken};
use ref_value::model::*;
use parser::parser::{ParseToken, FilterToken, NodeVisitor};
trait ArrayIndex {
fn index(&self, v: &RefValueWrapper) -> usize;
@ -56,14 +56,14 @@ pub enum ValueFilterKey {
#[derive(Debug)]
pub struct ValueFilter {
vw: ValueWrapper,
val_wrapper: ValueWrapper,
last_key: Option<ValueFilterKey>,
filter_mode: bool,
}
impl ValueFilter {
pub fn new(v: RefValueWrapper, is_leaves: bool, filter_mode: bool) -> Self {
ValueFilter { vw: ValueWrapper::new(v, is_leaves), last_key: None, filter_mode }
ValueFilter { val_wrapper: ValueWrapper::new(v, is_leaves), last_key: None, filter_mode }
}
fn iter_to_value_vec<'a, I: Iterator<Item=&'a RefValueWrapper>>(iter: I) -> Vec<RefValueWrapper> {
@ -130,11 +130,11 @@ impl ValueFilter {
pub fn step_leaves_all(&mut self) -> &ValueWrapper {
debug!("step_leaves_all");
let mut buf = Vec::new();
Self::collect_all(None, &self.vw.get_val(), &mut buf);
Self::collect_all(None, &self.val_wrapper.get_val(), &mut buf);
trace!("step_leaves_all - {:?}", buf);
self.last_key = Some(ValueFilterKey::All);
self.vw = ValueWrapper::new(RefValue::Array(buf).into(), true);
&self.vw
self.val_wrapper = ValueWrapper::new(RefValue::Array(buf).into(), true);
&self.val_wrapper
}
pub fn step_leaves_str(&mut self, key: &str) -> &ValueWrapper {
@ -144,17 +144,17 @@ impl ValueFilter {
pub fn step_leaves_string(&mut self, key: &String) -> &ValueWrapper {
debug!("step_leaves_string");
let mut buf = Vec::new();
Self::collect_all(Some(key), &self.vw.get_val(), &mut buf);
Self::collect_all(Some(key), &self.val_wrapper.get_val(), &mut buf);
trace!("step_leaves_string - {:?}", buf);
self.last_key = Some(ValueFilterKey::String(key.clone()));
self.vw = ValueWrapper::new(RefValue::Array(buf).into(), true);
&self.vw
self.val_wrapper = ValueWrapper::new(RefValue::Array(buf).into(), true);
&self.val_wrapper
}
pub fn step_in_all(&mut self) -> &ValueWrapper {
debug!("step_in_all");
let vec = match self.vw.get_val().deref() {
let vec = match self.val_wrapper.get_val().deref() {
RefValue::Object(ref map) => {
Self::iter_to_value_vec(map.values())
}
@ -162,25 +162,25 @@ impl ValueFilter {
Self::iter_to_value_vec(list.iter())
}
RefValue::Null => Vec::new(),
_ => vec![self.vw.get_val().clone()]
_ => vec![self.val_wrapper.get_val().clone()]
};
self.last_key = Some(ValueFilterKey::All);
self.vw.replace(RefValue::Array(vec).into());
trace!("step_in_all - {:?}", self.vw.get_val());
&self.vw
self.val_wrapper.replace(RefValue::Array(vec).into());
trace!("step_in_all - {:?}", self.val_wrapper.get_val());
&self.val_wrapper
}
pub fn step_in_num(&mut self, key: &f64) -> &ValueWrapper {
debug!("step_in_num");
trace!("step_in_num - before: leaves {}, filterMode {} - {:?}"
, self.vw.is_leaves()
, self.val_wrapper.is_leaves()
, self.filter_mode
, self.vw.get_val());
, self.val_wrapper.get_val());
let v = if self.vw.is_leaves() {
let v = if self.val_wrapper.is_leaves() {
let filter_mode = self.filter_mode;
match self.vw.get_val().deref() {
match self.val_wrapper.get_val().deref() {
RefValue::Array(ref vec) => {
let mut ret = Vec::new();
for v in vec {
@ -191,16 +191,16 @@ impl ValueFilter {
}
RefValue::Array(ret).into()
}
_ => key.take_value(&self.vw.get_val())
_ => key.take_value(&self.val_wrapper.get_val())
}
} else {
key.take_value(&self.vw.get_val())
key.take_value(&self.val_wrapper.get_val())
};
self.last_key = Some(ValueFilterKey::Num(key.index(&v)));
self.vw.replace(v);
trace!("step_in_num - after: {:?}", self.vw.get_val());
&self.vw
self.val_wrapper.replace(v);
trace!("step_in_num - after: {:?}", self.val_wrapper.get_val());
&self.val_wrapper
}
pub fn step_in_str(&mut self, key: &str) -> &ValueWrapper {
@ -210,13 +210,13 @@ impl ValueFilter {
pub fn step_in_string(&mut self, key: &String) -> &ValueWrapper {
debug!("step_in_string");
trace!("step_in_string - before: {},{},{:?}"
, self.vw.is_leaves()
, self.val_wrapper.is_leaves()
, self.filter_mode
, self.vw.get_val());
, self.val_wrapper.get_val());
let filter_mode = self.filter_mode;
let is_leaves = self.vw.is_leaves();
let val = match self.vw.get_val().deref() {
let is_leaves = self.val_wrapper.is_leaves();
let val = match self.val_wrapper.get_val().deref() {
RefValue::Array(ref vec) if is_leaves => {
let mut buf = Vec::new();
for mut v in vec {
@ -230,6 +230,11 @@ impl ValueFilter {
}
}
buf.append(&mut ret);
} else if v.is_object() {
let nested_wrapper = Self::get_nested_object(v, key, filter_mode);
if !nested_wrapper.is_null() {
buf.push(nested_wrapper.clone());
}
} else {
match v.get(key.clone()) {
Some(v) => buf.push(v.clone()),
@ -251,7 +256,7 @@ impl ValueFilter {
RefValue::Array(ret).into()
}
_ => {
match self.vw.get_val().get(key.clone()) {
match self.val_wrapper.get_val().get(key.clone()) {
Some(v) => v.clone(),
_ => RefValue::Null.into()
}
@ -259,12 +264,12 @@ impl ValueFilter {
};
self.last_key = Some(ValueFilterKey::String(key.clone()));
self.vw.replace(val);
self.val_wrapper.replace(val);
trace!("step_in_string - after: {},{},{:?}"
, self.vw.is_leaves()
, self.val_wrapper.is_leaves()
, self.filter_mode
, self.vw.get_val());
&self.vw
, self.val_wrapper.get_val());
&self.val_wrapper
}
}
@ -279,7 +284,7 @@ impl JsonValueFilter {
pub fn new(json: &str) -> Result<Self, String> {
let json: RefValue = serde_json::from_str(json)
.map_err(|e| e.description().to_string())?;
Ok(JsonValueFilter::new_from_value(json .into()))
Ok(JsonValueFilter::new_from_value(json.into()))
}
pub fn new_from_value(json: RefValueWrapper) -> Self {
@ -303,7 +308,7 @@ impl JsonValueFilter {
if from_current {
self.filter_stack.last()
.map(|vf| {
ValueFilter::new(vf.vw.get_val().clone(), vf.vw.is_leaves(), from_current)
ValueFilter::new(vf.val_wrapper.get_val().clone(), vf.val_wrapper.is_leaves(), from_current)
})
.and_then(|vf| {
Some(self.filter_stack.push(vf))
@ -321,13 +326,13 @@ impl JsonValueFilter {
} else {
match self.filter_stack.last_mut() {
Some(vf) => {
vf.vw.set_leaves(is_leaves);
vf.val_wrapper.set_leaves(is_leaves);
if v.is_null() {
vf.vw.replace(v);
vf.val_wrapper.replace(v);
} else if v.is_array() && v.as_array().unwrap().is_empty() {
vf.vw.replace(RefValue::Null.into());
} else if vf.vw.is_array() {
vf.vw.replace(v);
vf.val_wrapper.replace(RefValue::Null.into());
} else if vf.val_wrapper.is_array() {
vf.val_wrapper.replace(v);
}
}
_ => {}
@ -337,14 +342,14 @@ impl JsonValueFilter {
pub fn into_value(&self) -> Value {
match self.filter_stack.last() {
Some(v) => v.vw.into_value(),
Some(v) => v.val_wrapper.into_value(),
_ => Value::Null
}
}
pub fn take_value(&mut self) -> RefValueWrapper {
match self.filter_stack.last_mut() {
Some(v) => v.vw.get_val().clone(),
Some(v) => v.val_wrapper.get_val().clone(),
_ => RefValue::Null.into()
}
}
@ -353,9 +358,9 @@ impl JsonValueFilter {
self.token_stack.pop();
match self.filter_stack.last_mut() {
Some(ref mut vf) if vf.vw.is_array() && vf.vw.is_leaves() => {
Some(ref mut vf) if vf.val_wrapper.is_array() && vf.val_wrapper.is_leaves() => {
let mut ret = Vec::new();
if let RefValue::Array(val) = vf.vw.get_val().deref() {
if let RefValue::Array(val) = vf.val_wrapper.get_val().deref() {
for mut v in val {
for i in &indices {
let v = i.take_value(v);
@ -365,17 +370,17 @@ impl JsonValueFilter {
}
}
}
vf.vw.replace(RefValue::Array(ret).into());
vf.val_wrapper.replace(RefValue::Array(ret).into());
}
Some(ref mut vf) if vf.vw.is_array() && !vf.vw.is_leaves() => {
Some(ref mut vf) if vf.val_wrapper.is_array() && !vf.val_wrapper.is_leaves() => {
let mut ret = Vec::new();
for i in indices {
let wrapper = i.take_value(&vf.vw.get_val());
let wrapper = i.take_value(&vf.val_wrapper.get_val());
if !wrapper.is_null() {
ret.push(wrapper.clone());
}
}
vf.vw.replace(RefValue::Array(ret).into());
vf.val_wrapper.replace(RefValue::Array(ret).into());
}
_ => {}
}
@ -413,21 +418,21 @@ impl JsonValueFilter {
}
match self.filter_stack.last_mut() {
Some(ref mut vf) if vf.vw.is_array() && vf.vw.is_leaves() => {
Some(ref mut vf) if vf.val_wrapper.is_array() && vf.val_wrapper.is_leaves() => {
let mut buf = Vec::new();
if let RefValue::Array(vec) = vf.vw.get_val().deref() {
if let RefValue::Array(vec) = vf.val_wrapper.get_val().deref() {
for mut v in vec {
let (from, to) = _from_to(from, to, v);
let mut v: Vec<RefValueWrapper> = _range(from, to, v);
buf.append(&mut v);
}
}
vf.vw.replace(RefValue::Array(buf).into());
vf.val_wrapper.replace(RefValue::Array(buf).into());
}
Some(ref mut vf) if vf.vw.is_array() && !vf.vw.is_leaves() => {
let (from, to) = _from_to(from, to, &vf.vw.get_val());
let vec: Vec<RefValueWrapper> = _range(from, to, vf.vw.get_val());
vf.vw.replace(RefValue::Array(vec).into());
Some(ref mut vf) if vf.val_wrapper.is_array() && !vf.val_wrapper.is_leaves() => {
let (from, to) = _from_to(from, to, &vf.val_wrapper.get_val());
let vec: Vec<RefValueWrapper> = _range(from, to, vf.val_wrapper.get_val());
vf.val_wrapper.replace(RefValue::Array(vec).into());
}
_ => {}
}
@ -491,13 +496,13 @@ impl JsonValueFilter {
_ => {
match self.filter_stack.pop() {
Some(mut vf) => {
let is_leaves = vf.vw.is_leaves();
match vf.vw.get_val().deref() {
let is_leaves = vf.val_wrapper.is_leaves();
match vf.val_wrapper.get_val().deref() {
RefValue::Null | RefValue::Bool(false) => {
self.replace_filter_stack(RefValue::Null.into(), is_leaves);
}
_ => {
self.replace_filter_stack(vf.vw.get_val().clone(), is_leaves);
self.replace_filter_stack(vf.val_wrapper.get_val().clone(), is_leaves);
}
}
}
@ -548,8 +553,13 @@ impl NodeVisitor for JsonValueFilter {
self.push_value_filter(ParseToken::Relative == token);
}
ParseToken::In
| ParseToken::Leaves
| ParseToken::Array => {
| ParseToken::Leaves => {
self.token_stack.push(token);
}
ParseToken::Array => {
if let Some(ParseToken::Leaves) = self.token_stack.last() {
self.token_all();
}
self.token_stack.push(token);
}
ParseToken::ArrayEof => {
@ -593,7 +603,7 @@ impl NodeVisitor for JsonValueFilter {
if self.token_stack.is_empty() && self.filter_stack.len() > 1 {
match self.filter_stack.pop() {
Some(vf) => {
self.term_stack.push(TermContext::Json(vf.last_key, vf.vw));
self.term_stack.push(TermContext::Json(vf.last_key, vf.val_wrapper));
}
_ => {}
}

12
tests/filter.rs
View File

@ -201,6 +201,18 @@ fn op_default() {
let jf = do_filter("$..book[?( (@.price == 12.99 || @.category == 'reference') && @.price > 10)].price", "./benches/example.json");
let friends = json!([12.99]);
assert_eq!(friends, jf.into_value());
let ref value = json!([
{ "name": "이름1", "age": 40, "phone": "+33 12341234" },
{ "name": "이름2", "age": 42, "phone": "++44 12341234" }
]);
let mut jf = JsonValueFilter::new_from_value(value.into());
let mut parser = Parser::new("$..[?(@.age > 40)]");
parser.parse(&mut jf).unwrap();
let friends = json!([
{ "name" : "이름2", "age" : 42, "phone" : "++44 12341234" }
]);
assert_eq!(friends, jf.into_value());
}
#[test]