use crate::expr::Expr;
use crate::query::{FieldSel, QueryOp};
pub fn translate(src: &str) -> Result<Vec<QueryOp>, String> {
let mut ops = Vec::new();
for stage in split_pipe(src)? {
let stage = stage.trim();
if stage.is_empty() {
return Err(format!("jq: empty pipe stage in `{src}`"));
}
translate_stage(stage, &mut ops)?;
}
Ok(ops)
}
fn split_pipe(src: &str) -> Result<Vec<String>, String> {
let mut out = Vec::new();
let mut cur = String::new();
let mut depth = 0i32;
let mut in_str = false;
for c in src.chars() {
match c {
'"' => {
in_str = !in_str;
cur.push(c);
}
'(' | '[' if !in_str => {
depth += 1;
cur.push(c);
}
')' | ']' if !in_str => {
depth -= 1;
cur.push(c);
}
'|' if !in_str && depth == 0 => {
out.push(std::mem::take(&mut cur));
}
_ => cur.push(c),
}
}
if in_str {
return Err(format!("jq: unterminated string in `{src}`"));
}
out.push(cur);
Ok(out)
}
fn translate_stage(s: &str, ops: &mut Vec<QueryOp>) -> Result<(), String> {
match s {
"." => return Ok(()), ".[]" => {
ops.push(QueryOp::Each);
return Ok(());
}
"keys" => {
ops.push(QueryOp::Keys);
return Ok(());
}
"values" => {
ops.push(QueryOp::NonNull);
return Ok(());
}
"length" => {
ops.push(QueryOp::JsonLen);
return Ok(());
}
"add" => {
ops.push(QueryOp::Add);
return Ok(());
}
"flatten" => {
ops.push(QueryOp::Flatten);
return Ok(());
}
"to_entries" => {
ops.push(QueryOp::Entries);
return Ok(());
}
_ => {}
}
if let Some(inner) = fn_call(s, "select") {
ops.push(QueryOp::Where(parse_expr(inner)?));
return Ok(());
}
if let Some(inner) = fn_call(s, "map") {
ops.push(QueryOp::Each);
translate_stage(inner.trim(), ops)?;
return Ok(());
}
if let Some(inner) = fn_call(s, "has") {
let key = strip_quotes(inner.trim());
if key.is_empty() {
return Err(format!("jq: has() expects a key: `{s}`"));
}
ops.push(QueryOp::HasKey(key));
return Ok(());
}
if s.starts_with('.') {
if is_pure_path(s) {
return translate_path(s, ops);
}
ops.push(QueryOp::Map(parse_expr(s)?));
return Ok(());
}
Err(format!("jq: unsupported expression `{s}`"))
}
fn fn_call<'a>(s: &'a str, name: &str) -> Option<&'a str> {
let rest = s.strip_prefix(name)?.trim_start();
let inner = rest.strip_prefix('(')?.strip_suffix(')')?;
Some(inner)
}
fn strip_quotes(s: &str) -> String {
s.strip_prefix('"')
.and_then(|x| x.strip_suffix('"'))
.unwrap_or(s)
.to_string()
}
fn is_pure_path(s: &str) -> bool {
s.chars()
.all(|c| c.is_ascii_alphanumeric() || matches!(c, '.' | '[' | ']' | '"' | '_' | ':' | '-'))
}
fn translate_path(s: &str, ops: &mut Vec<QueryOp>) -> Result<(), String> {
let cs: Vec<char> = s.chars().collect();
let mut i = 0usize;
let mut key: Vec<String> = Vec::new();
if cs.first() != Some(&'.') {
return Err(format!("jq: path must start with `.`: `{s}`"));
}
let flush = |key: &mut Vec<String>, ops: &mut Vec<QueryOp>| {
if !key.is_empty() {
ops.push(QueryOp::Field(FieldSel::Key(std::mem::take(key))));
}
};
while i < cs.len() {
match cs[i] {
'.' => {
i += 1;
if cs.get(i) == Some(&'[') {
parse_bracket(&cs, &mut i, &mut key, ops, &flush, s)?;
} else {
let id = take_ident(&cs, &mut i);
if id.is_empty() {
return Err(format!("jq: expected a key after `.` in `{s}`"));
}
key.push(id);
}
}
'[' => parse_bracket(&cs, &mut i, &mut key, ops, &flush, s)?,
other => return Err(format!("jq: unexpected `{other}` in path `{s}`")),
}
}
flush(&mut key, ops);
Ok(())
}
fn parse_bracket(
cs: &[char],
i: &mut usize,
key: &mut Vec<String>,
ops: &mut Vec<QueryOp>,
flush: &dyn Fn(&mut Vec<String>, &mut Vec<QueryOp>),
s: &str,
) -> Result<(), String> {
*i += 1; let start = *i;
while *i < cs.len() && cs[*i] != ']' {
*i += 1;
}
if cs.get(*i) != Some(&']') {
return Err(format!("jq: unterminated `[` in `{s}`"));
}
let content: String = cs[start..*i].iter().collect();
*i += 1; let c = content.trim();
if c.is_empty() {
flush(key, ops);
ops.push(QueryOp::Each);
return Ok(());
}
if let Some(k) = c.strip_prefix('"').and_then(|x| x.strip_suffix('"')) {
key.push(k.to_string());
return Ok(());
}
if let Some((a, b)) = c.split_once(':') {
flush(key, ops);
ops.push(QueryOp::JsonSlice(
parse_opt_int(a, s)?,
parse_opt_int(b, s)?,
));
return Ok(());
}
if c.parse::<i64>().is_ok() {
key.push(c.to_string());
Ok(())
} else {
Err(format!("jq: unsupported subscript `[{content}]` in `{s}`"))
}
}
fn parse_opt_int(s: &str, whole: &str) -> Result<Option<i64>, String> {
let s = s.trim();
if s.is_empty() {
Ok(None)
} else {
s.parse::<i64>()
.map(Some)
.map_err(|_| format!("jq: bad slice bound `{s}` in `{whole}`"))
}
}
fn take_ident(cs: &[char], i: &mut usize) -> String {
let start = *i;
while *i < cs.len() && (cs[*i].is_ascii_alphanumeric() || cs[*i] == '_') {
*i += 1;
}
cs[start..*i].iter().collect()
}
fn parse_expr(src: &str) -> Result<Expr, String> {
let rewritten = rewrite_fields(src)?;
crate::expr::parse(&rewritten).map_err(|e| format!("jq: {e}"))
}
fn rewrite_fields(src: &str) -> Result<String, String> {
let cs: Vec<char> = src.chars().collect();
let mut out = String::new();
let mut i = 0;
while i < cs.len() {
let c = cs[i];
if c == '.' {
let next = cs.get(i + 1).copied();
let prev_alnum = out
.chars()
.last()
.map(|p| p.is_alphanumeric() || p == '_')
.unwrap_or(false);
if matches!(next, Some(d) if d.is_ascii_alphabetic() || d == '_') {
if prev_alnum {
return Err(format!(
"jq: nested field path (.a.b) inside select/map is unsupported: `{src}`"
));
}
i += 1; while i < cs.len() && (cs[i].is_alphanumeric() || cs[i] == '_') {
out.push(cs[i]);
i += 1;
}
if cs.get(i) == Some(&'.')
&& matches!(cs.get(i + 1), Some(d) if d.is_ascii_alphabetic() || *d == '_')
{
return Err(format!(
"jq: nested field path (.a.b) inside select/map is unsupported: `{src}`"
));
}
continue;
}
if matches!(next, Some(d) if d.is_ascii_digit()) || next == Some('.') {
out.push('.');
} else {
out.push('x');
}
i += 1;
continue;
}
out.push(c);
i += 1;
}
Ok(out)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::query::{eval, QueryResult};
fn run(jq: &str, lines: &[&str]) -> Vec<String> {
let ops = translate(jq).unwrap();
match eval(
&ops,
&lines.iter().map(|s| s.to_string()).collect::<Vec<_>>(),
1.0,
) {
QueryResult::Lines(v) => v,
other => panic!("expected lines, got {other:?}"),
}
}
#[test]
fn identity() {
assert_eq!(run(".", &["a", "b"]), vec!["a", "b"]);
}
#[test]
fn key_path() {
assert_eq!(run(".foo.bar", &[r#"{"foo":{"bar":7}}"#]), vec!["7"]);
}
#[test]
fn iterate_root() {
assert_eq!(run(".[]", &["[1,2,3]"]), vec!["1", "2", "3"]);
}
#[test]
fn iterate_object_yields_values() {
assert_eq!(run(".[]", &[r#"{"a":1,"b":2}"#]), vec!["1", "2"]);
assert_eq!(run("map(.+1)", &[r#"{"a":1,"b":2}"#]), vec!["2", "3"]);
}
#[test]
fn field_then_iterate() {
assert_eq!(run(".items[]", &[r#"{"items":[1,2]}"#]), vec!["1", "2"]);
}
#[test]
fn array_index() {
assert_eq!(run(".[1]", &[r#"["a","b","c"]"#]), vec!["b"]);
assert_eq!(run(".foo[0]", &[r#"{"foo":["x","y"]}"#]), vec!["x"]);
}
#[test]
fn bracket_string_key() {
assert_eq!(run(r#".["foo"]"#, &[r#"{"foo":9}"#]), vec!["9"]);
}
#[test]
fn pipe_two_ops() {
assert_eq!(run(".foo | .bar", &[r#"{"foo":{"bar":5}}"#]), vec!["5"]);
}
#[test]
fn select_numeric() {
let out = run(
"select(.amount > 100)",
&[r#"{"amount":50}"#, r#"{"amount":150}"#],
);
assert_eq!(out, vec![r#"{"amount":150}"#]);
}
#[test]
fn iterate_then_select() {
let out = run(".[] | select(.n >= 2)", &[r#"[{"n":1},{"n":2},{"n":3}]"#]);
assert_eq!(out, vec![r#"{"n":2}"#, r#"{"n":3}"#]);
}
#[test]
fn map_field() {
assert_eq!(
run("map(.price)", &[r#"[{"price":3},{"price":4}]"#]),
vec!["3", "4"]
);
}
#[test]
fn map_arith() {
assert_eq!(run("map(. * 2)", &["[1,2,3]"]), vec!["2", "4", "6"]);
}
#[test]
fn has_key() {
let out = run(r#"has("id")"#, &[r#"{"id":1}"#, r#"{"x":2}"#]);
assert_eq!(out, vec!["true", "false"]);
}
#[test]
fn values_is_select_non_null() {
let out = run("values", &[r#"{"a":1,"b":2}"#, "null", "5"]);
assert_eq!(out, vec![r#"{"a":1,"b":2}"#, "5"]);
}
#[test]
fn flatten_is_recursive() {
assert_eq!(
run("flatten", &["[1,[2,[3,[4]]]]"]),
vec!["1", "2", "3", "4"]
);
}
#[test]
fn builtins() {
assert_eq!(run("keys", &[r#"{"a":1,"b":2}"#]), vec!["a", "b"]);
assert_eq!(run("add", &["[1,2,3]"]), vec!["6"]);
assert_eq!(run(".[] | length", &[r#"["ab","cde"]"#]), vec!["2", "3"]);
}
#[test]
fn slices_and_negative_indices() {
assert_eq!(run(".[1:3]", &["[10,20,30,40,50]"]), vec!["[20,30]"]);
assert_eq!(run(".[:2]", &["[10,20,30]"]), vec!["[10,20]"]);
assert_eq!(run(".[2:]", &["[10,20,30,40]"]), vec!["[30,40]"]);
assert_eq!(run(".[-2:]", &["[10,20,30,40]"]), vec!["[30,40]"]);
assert_eq!(run(".foo[1:3]", &[r#"{"foo":[1,2,3,4]}"#]), vec!["[2,3]"]);
assert_eq!(run(".[1:3]", &[r#""hello""#]), vec!["el"]);
assert_eq!(run(".[-1]", &[r#"["a","b","c"]"#]), vec!["c"]);
assert_eq!(run(".foo[-1]", &[r#"{"foo":[1,2,3]}"#]), vec!["3"]);
}
#[test]
fn length_is_json_aware() {
assert_eq!(run("length", &["[1,2,3]"]), vec!["3"]); assert_eq!(run("length", &[r#"{"a":1,"b":2}"#]), vec!["2"]); assert_eq!(run("length", &[r#""hello""#]), vec!["5"]); assert_eq!(run("length", &["-7"]), vec!["7"]); assert_eq!(run("length", &["null"]), vec!["0"]);
}
#[test]
fn unsupported_errors_cleanly() {
assert!(translate(".a.b as $x").is_err());
assert!(translate(".[1:x]").is_err()); assert!(translate(".foo // 0").is_err()); assert!(translate(".foo?").is_err()); assert!(translate("reduce .[] as $x (0; . + $x)").is_err());
assert!(translate(r#"select(.status == "ok")"#).is_err()); assert!(translate("select(.a.b > 1)").is_err()); }
}