new inc takes a path

This commit is contained in:
Jonathan Turner 2019-07-18 13:32:19 +12:00
parent 7cae7e8064
commit 3b682046b7
3 changed files with 114 additions and 21 deletions

View File

@ -347,6 +347,62 @@ impl Value {
} }
} }
pub fn get_data_by_path(&'a self, span: Span, path: &str) -> Option<Spanned<&Value>> {
let mut current = self;
for p in path.split(".") {
match current.get_data_by_key(p) {
Some(v) => current = v,
None => return None,
}
}
Some(Spanned {
item: current,
span,
})
}
pub fn replace_data_at_path(
&'a self,
span: Span,
path: &str,
replaced_value: Value,
) -> Option<Spanned<Value>> {
let mut new_obj = self.clone();
let split_path: Vec<_> = path.split(".").collect();
if let Value::Object(ref mut o) = new_obj {
let mut current = o;
for idx in 0..split_path.len() {
match current.entries.get_mut(split_path[idx]) {
Some(next) => {
if idx == (split_path.len() - 1) {
*next = Spanned {
item: replaced_value,
span,
};
return Some(Spanned {
item: new_obj,
span,
});
} else {
match next.item {
Value::Object(ref mut o) => {
current = o;
}
_ => return None,
}
}
}
_ => return None,
}
}
}
None
}
pub fn get_data(&'a self, desc: &String) -> MaybeOwned<'a, Value> { pub fn get_data(&'a self, desc: &String) -> MaybeOwned<'a, Value> {
match self { match self {
p @ Value::Primitive(_) => MaybeOwned::Borrowed(p), p @ Value::Primitive(_) => MaybeOwned::Borrowed(p),

View File

@ -50,7 +50,7 @@ impl<T> Spanned<T> {
} }
} }
crate fn map<U>(self, input: impl FnOnce(T) -> U) -> Spanned<U> { pub fn map<U>(self, input: impl FnOnce(T) -> U) -> Spanned<U> {
let Spanned { span, item } = self; let Spanned { span, item } = self;
let mapped = input(item); let mapped = input(item);

View File

@ -5,11 +5,56 @@ use nu::{
}; };
struct Inc { struct Inc {
inc_by: i64, field: Option<String>,
} }
impl Inc { impl Inc {
fn new() -> Inc { fn new() -> Inc {
Inc { inc_by: 1 } Inc { field: None }
}
fn inc(value: Spanned<Value>, field: &Option<String>) -> Result<Spanned<Value>, ShellError> {
match value.item {
Value::Primitive(Primitive::Int(i)) => Ok(Value::int(i + 1).spanned(value.span)),
Value::Primitive(Primitive::Bytes(b)) => {
Ok(Value::bytes(b + 1 as u64).spanned(value.span))
}
Value::Primitive(Primitive::String(s)) => {
if let Ok(i) = s.parse::<u64>() {
Ok(Spanned {
item: Value::string(format!("{}", i + 1)),
span: value.span,
})
} else {
Err(ShellError::string("string could not be incremented"))
}
}
Value::Object(_) => match field {
Some(f) => {
let replacement = match value.item.get_data_by_path(value.span, f) {
Some(result) => Inc::inc(result.map(|x| x.clone()), &None)?,
None => {
return Err(ShellError::string("inc could not find field to replace"))
}
};
match value
.item
.replace_data_at_path(value.span, f, replacement.item.clone())
{
Some(v) => return Ok(v),
None => {
return Err(ShellError::string("inc could not find field to replace"))
}
}
}
None => Err(ShellError::string(
"inc needs a field when incrementing a value in an object",
)),
},
x => Err(ShellError::string(format!(
"Unrecognized type in stream: {:?}",
x
))),
}
} }
} }
@ -17,7 +62,7 @@ impl Plugin for Inc {
fn config(&mut self) -> Result<CommandConfig, ShellError> { fn config(&mut self) -> Result<CommandConfig, ShellError> {
Ok(CommandConfig { Ok(CommandConfig {
name: "inc".to_string(), name: "inc".to_string(),
positional: vec![PositionalType::optional_any("Increment")], positional: vec![PositionalType::optional_any("Field")],
is_filter: true, is_filter: true,
is_sink: false, is_sink: false,
named: IndexMap::new(), named: IndexMap::new(),
@ -29,12 +74,17 @@ impl Plugin for Inc {
for arg in args { for arg in args {
match arg { match arg {
Spanned { Spanned {
item: Value::Primitive(Primitive::Int(i)), item: Value::Primitive(Primitive::String(s)),
.. ..
} => { } => {
self.inc_by = i; self.field = Some(s);
}
_ => {
return Err(ShellError::string(format!(
"Unrecognized type in params: {:?}",
arg
)))
} }
_ => return Err(ShellError::string("Unrecognized type in params")),
} }
} }
} }
@ -43,20 +93,7 @@ impl Plugin for Inc {
} }
fn filter(&mut self, input: Spanned<Value>) -> Result<Vec<ReturnValue>, ShellError> { fn filter(&mut self, input: Spanned<Value>) -> Result<Vec<ReturnValue>, ShellError> {
let span = input.span; Ok(vec![ReturnSuccess::value(Inc::inc(input, &self.field)?)])
match input.item {
Value::Primitive(Primitive::Int(i)) => Ok(vec![ReturnSuccess::value(
Value::int(i + self.inc_by).spanned(span),
)]),
Value::Primitive(Primitive::Bytes(b)) => Ok(vec![ReturnSuccess::value(
Value::bytes(b + self.inc_by as u64).spanned(span),
)]),
x => Err(ShellError::string(format!(
"Unrecognized type in stream: {:?}",
x
))),
}
} }
} }