fluencelabs/jsonpath
1
0
Fork 0
mirror of https://github.com/fluencelabs/jsonpath synced 2025-04-25 09:22:19 +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::term::*;
use filter::value_wrapper::*; use filter::value_wrapper::*;
use parser::parser::{FilterToken, NodeVisitor, ParseToken};
use ref_value::model::*; use ref_value::model::*;
use parser::parser::{ParseToken, FilterToken, NodeVisitor};
trait ArrayIndex { trait ArrayIndex {
fn index(&self, v: &RefValueWrapper) -> usize; fn index(&self, v: &RefValueWrapper) -> usize;
@ -56,14 +56,14 @@ pub enum ValueFilterKey {
#[derive(Debug)] #[derive(Debug)]
pub struct ValueFilter { pub struct ValueFilter {
vw: ValueWrapper, val_wrapper: ValueWrapper,
last_key: Option<ValueFilterKey>, last_key: Option<ValueFilterKey>,
filter_mode: bool, filter_mode: bool,
} }
impl ValueFilter { impl ValueFilter {
pub fn new(v: RefValueWrapper, is_leaves: bool, filter_mode: bool) -> Self { 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> { 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 { pub fn step_leaves_all(&mut self) -> &ValueWrapper {
debug!("step_leaves_all"); debug!("step_leaves_all");
let mut buf = Vec::new(); 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); trace!("step_leaves_all - {:?}", buf);
self.last_key = Some(ValueFilterKey::All); self.last_key = Some(ValueFilterKey::All);
self.vw = ValueWrapper::new(RefValue::Array(buf).into(), true); self.val_wrapper = ValueWrapper::new(RefValue::Array(buf).into(), true);
&self.vw &self.val_wrapper
} }
pub fn step_leaves_str(&mut self, key: &str) -> &ValueWrapper { 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 { pub fn step_leaves_string(&mut self, key: &String) -> &ValueWrapper {
debug!("step_leaves_string"); debug!("step_leaves_string");
let mut buf = Vec::new(); 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); trace!("step_leaves_string - {:?}", buf);
self.last_key = Some(ValueFilterKey::String(key.clone())); self.last_key = Some(ValueFilterKey::String(key.clone()));
self.vw = ValueWrapper::new(RefValue::Array(buf).into(), true); self.val_wrapper = ValueWrapper::new(RefValue::Array(buf).into(), true);
&self.vw &self.val_wrapper
} }
pub fn step_in_all(&mut self) -> &ValueWrapper { pub fn step_in_all(&mut self) -> &ValueWrapper {
debug!("step_in_all"); 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) => { RefValue::Object(ref map) => {
Self::iter_to_value_vec(map.values()) Self::iter_to_value_vec(map.values())
} }
@ -162,25 +162,25 @@ impl ValueFilter {
Self::iter_to_value_vec(list.iter()) Self::iter_to_value_vec(list.iter())
} }
RefValue::Null => Vec::new(), RefValue::Null => Vec::new(),
_ => vec![self.vw.get_val().clone()] _ => vec![self.val_wrapper.get_val().clone()]
}; };
self.last_key = Some(ValueFilterKey::All); self.last_key = Some(ValueFilterKey::All);
self.vw.replace(RefValue::Array(vec).into()); self.val_wrapper.replace(RefValue::Array(vec).into());
trace!("step_in_all - {:?}", self.vw.get_val()); trace!("step_in_all - {:?}", self.val_wrapper.get_val());
&self.vw &self.val_wrapper
} }
pub fn step_in_num(&mut self, key: &f64) -> &ValueWrapper { pub fn step_in_num(&mut self, key: &f64) -> &ValueWrapper {
debug!("step_in_num"); debug!("step_in_num");
trace!("step_in_num - before: leaves {}, filterMode {} - {:?}" trace!("step_in_num - before: leaves {}, filterMode {} - {:?}"
, self.vw.is_leaves() , self.val_wrapper.is_leaves()
, self.filter_mode , 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; let filter_mode = self.filter_mode;
match self.vw.get_val().deref() { match self.val_wrapper.get_val().deref() {
RefValue::Array(ref vec) => { RefValue::Array(ref vec) => {
let mut ret = Vec::new(); let mut ret = Vec::new();
for v in vec { for v in vec {
@ -191,16 +191,16 @@ impl ValueFilter {
} }
RefValue::Array(ret).into() RefValue::Array(ret).into()
} }
_ => key.take_value(&self.vw.get_val()) _ => key.take_value(&self.val_wrapper.get_val())
} }
} else { } 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.last_key = Some(ValueFilterKey::Num(key.index(&v)));
self.vw.replace(v); self.val_wrapper.replace(v);
trace!("step_in_num - after: {:?}", self.vw.get_val()); trace!("step_in_num - after: {:?}", self.val_wrapper.get_val());
&self.vw &self.val_wrapper
} }
pub fn step_in_str(&mut self, key: &str) -> &ValueWrapper { 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 { pub fn step_in_string(&mut self, key: &String) -> &ValueWrapper {
debug!("step_in_string"); debug!("step_in_string");
trace!("step_in_string - before: {},{},{:?}" trace!("step_in_string - before: {},{},{:?}"
, self.vw.is_leaves() , self.val_wrapper.is_leaves()
, self.filter_mode , self.filter_mode
, self.vw.get_val()); , self.val_wrapper.get_val());
let filter_mode = self.filter_mode; let filter_mode = self.filter_mode;
let is_leaves = self.vw.is_leaves(); let is_leaves = self.val_wrapper.is_leaves();
let val = match self.vw.get_val().deref() { let val = match self.val_wrapper.get_val().deref() {
RefValue::Array(ref vec) if is_leaves => { RefValue::Array(ref vec) if is_leaves => {
let mut buf = Vec::new(); let mut buf = Vec::new();
for mut v in vec { for mut v in vec {
@ -230,6 +230,11 @@ impl ValueFilter {
} }
} }
buf.append(&mut ret); 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 { } else {
match v.get(key.clone()) { match v.get(key.clone()) {
Some(v) => buf.push(v.clone()), Some(v) => buf.push(v.clone()),
@ -251,7 +256,7 @@ impl ValueFilter {
RefValue::Array(ret).into() 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(), Some(v) => v.clone(),
_ => RefValue::Null.into() _ => RefValue::Null.into()
} }
@ -259,12 +264,12 @@ impl ValueFilter {
}; };
self.last_key = Some(ValueFilterKey::String(key.clone())); self.last_key = Some(ValueFilterKey::String(key.clone()));
self.vw.replace(val); self.val_wrapper.replace(val);
trace!("step_in_string - after: {},{},{:?}" trace!("step_in_string - after: {},{},{:?}"
, self.vw.is_leaves() , self.val_wrapper.is_leaves()
, self.filter_mode , self.filter_mode
, self.vw.get_val()); , self.val_wrapper.get_val());
&self.vw &self.val_wrapper
} }
} }
@ -279,7 +284,7 @@ impl JsonValueFilter {
pub fn new(json: &str) -> Result<Self, String> { pub fn new(json: &str) -> Result<Self, String> {
let json: RefValue = serde_json::from_str(json) let json: RefValue = serde_json::from_str(json)
.map_err(|e| e.description().to_string())?; .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 { pub fn new_from_value(json: RefValueWrapper) -> Self {
@ -303,7 +308,7 @@ impl JsonValueFilter {
if from_current { if from_current {
self.filter_stack.last() self.filter_stack.last()
.map(|vf| { .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| { .and_then(|vf| {
Some(self.filter_stack.push(vf)) Some(self.filter_stack.push(vf))
@ -321,13 +326,13 @@ impl JsonValueFilter {
} else { } else {
match self.filter_stack.last_mut() { match self.filter_stack.last_mut() {
Some(vf) => { Some(vf) => {
vf.vw.set_leaves(is_leaves); vf.val_wrapper.set_leaves(is_leaves);
if v.is_null() { if v.is_null() {
vf.vw.replace(v); vf.val_wrapper.replace(v);
} else if v.is_array() && v.as_array().unwrap().is_empty() { } else if v.is_array() && v.as_array().unwrap().is_empty() {
vf.vw.replace(RefValue::Null.into()); vf.val_wrapper.replace(RefValue::Null.into());
} else if vf.vw.is_array() { } else if vf.val_wrapper.is_array() {
vf.vw.replace(v); vf.val_wrapper.replace(v);
} }
} }
_ => {} _ => {}
@ -337,14 +342,14 @@ impl JsonValueFilter {
pub fn into_value(&self) -> Value { pub fn into_value(&self) -> Value {
match self.filter_stack.last() { match self.filter_stack.last() {
Some(v) => v.vw.into_value(), Some(v) => v.val_wrapper.into_value(),
_ => Value::Null _ => Value::Null
} }
} }
pub fn take_value(&mut self) -> RefValueWrapper { pub fn take_value(&mut self) -> RefValueWrapper {
match self.filter_stack.last_mut() { match self.filter_stack.last_mut() {
Some(v) => v.vw.get_val().clone(), Some(v) => v.val_wrapper.get_val().clone(),
_ => RefValue::Null.into() _ => RefValue::Null.into()
} }
} }
@ -353,9 +358,9 @@ impl JsonValueFilter {
self.token_stack.pop(); self.token_stack.pop();
match self.filter_stack.last_mut() { 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(); 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 mut v in val {
for i in &indices { for i in &indices {
let v = i.take_value(v); 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(); let mut ret = Vec::new();
for i in indices { 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() { if !wrapper.is_null() {
ret.push(wrapper.clone()); 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() { 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(); 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 { for mut v in vec {
let (from, to) = _from_to(from, to, v); let (from, to) = _from_to(from, to, v);
let mut v: Vec<RefValueWrapper> = _range(from, to, v); let mut v: Vec<RefValueWrapper> = _range(from, to, v);
buf.append(&mut 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() => { Some(ref mut vf) if vf.val_wrapper.is_array() && !vf.val_wrapper.is_leaves() => {
let (from, to) = _from_to(from, to, &vf.vw.get_val()); let (from, to) = _from_to(from, to, &vf.val_wrapper.get_val());
let vec: Vec<RefValueWrapper> = _range(from, to, vf.vw.get_val()); let vec: Vec<RefValueWrapper> = _range(from, to, vf.val_wrapper.get_val());
vf.vw.replace(RefValue::Array(vec).into()); vf.val_wrapper.replace(RefValue::Array(vec).into());
} }
_ => {} _ => {}
} }
@ -491,13 +496,13 @@ impl JsonValueFilter {
_ => { _ => {
match self.filter_stack.pop() { match self.filter_stack.pop() {
Some(mut vf) => { Some(mut vf) => {
let is_leaves = vf.vw.is_leaves(); let is_leaves = vf.val_wrapper.is_leaves();
match vf.vw.get_val().deref() { match vf.val_wrapper.get_val().deref() {
RefValue::Null | RefValue::Bool(false) => { RefValue::Null | RefValue::Bool(false) => {
self.replace_filter_stack(RefValue::Null.into(), is_leaves); 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); self.push_value_filter(ParseToken::Relative == token);
} }
ParseToken::In ParseToken::In
| ParseToken::Leaves | ParseToken::Leaves => {
| ParseToken::Array => { self.token_stack.push(token);
}
ParseToken::Array => {
if let Some(ParseToken::Leaves) = self.token_stack.last() {
self.token_all();
}
self.token_stack.push(token); self.token_stack.push(token);
} }
ParseToken::ArrayEof => { ParseToken::ArrayEof => {
@ -593,7 +603,7 @@ impl NodeVisitor for JsonValueFilter {
if self.token_stack.is_empty() && self.filter_stack.len() > 1 { if self.token_stack.is_empty() && self.filter_stack.len() > 1 {
match self.filter_stack.pop() { match self.filter_stack.pop() {
Some(vf) => { 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 jf = do_filter("$..book[?( (@.price == 12.99 || @.category == 'reference') && @.price > 10)].price", "./benches/example.json");
let friends = json!([12.99]); let friends = json!([12.99]);
assert_eq!(friends, jf.into_value()); 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] #[test]