use std::borrow::Cow;
use cpa_common::json::{self, Res};
pub(crate) use gjson::Kind;
#[derive(Clone, Debug, Default)]
pub(crate) struct Value<'a> {
res: Res<'a>,
raw: Cow<'a, str>,
s: Option<Cow<'a, str>>,
}
fn as_str<'a>(src: &'a str, bytes: Cow<'a, [u8]>) -> Cow<'a, str> {
match bytes {
Cow::Borrowed(b) => {
let start = (b.as_ptr() as usize).wrapping_sub(src.as_ptr() as usize);
match src.get(start..start.wrapping_add(b.len())) {
Some(slice) if slice.as_ptr() == b.as_ptr() => Cow::Borrowed(slice),
_ => String::from_utf8_lossy(b),
}
}
Cow::Owned(v) => {
Cow::Owned(String::from_utf8(v).unwrap_or_else(|e| String::from_utf8_lossy(e.as_bytes()).into_owned()))
}
}
}
impl<'a> Value<'a> {
fn new(src: &'a str, res: Res<'a>) -> Self {
let raw = as_str(src, res.raw.clone());
let s = match (&res.kind, &res.s) {
(json::Kind::String, Cow::Owned(_)) => None,
_ => Some(as_str(src, res.bytes())),
};
Value { res, raw, s }
}
fn src(&self) -> &'a str {
match &self.raw {
Cow::Borrowed(raw) => raw,
Cow::Owned(_) => "",
}
}
pub(crate) fn get(&self, path: &str) -> Value<'a> {
Value::new(self.src(), self.res.get(path))
}
pub(crate) fn exists(&self) -> bool {
self.res.exists()
}
pub(crate) fn kind(&self) -> Kind {
match self.res.kind {
json::Kind::Null => Kind::Null,
json::Kind::False => Kind::False,
json::Kind::True => Kind::True,
json::Kind::Number => Kind::Number,
json::Kind::String => Kind::String,
json::Kind::Json if self.res.raw().first() == Some(&b'[') => Kind::Array,
json::Kind::Json => Kind::Object,
}
}
pub(crate) fn json(&self) -> &str {
&self.raw
}
pub(crate) fn str(&self) -> &str {
match &self.s {
Some(s) => s,
None => std::str::from_utf8(&self.res.s).unwrap_or_default(),
}
}
pub(crate) fn i64(&self) -> i64 {
self.res.int()
}
pub(crate) fn f64(&self) -> f64 {
self.res.float()
}
pub(crate) fn bool(&self) -> bool {
self.res.bool()
}
pub(crate) fn each(&self, mut f: impl FnMut(Value<'a>, Value<'a>) -> bool) {
let src = self.src();
self.res.each(|k, v| f(Value::new(src, k), Value::new(src, v)));
}
pub(crate) fn array(&self) -> Vec<Value<'a>> {
let src = self.src();
if self.kind() != Kind::Array {
return self.res.array().into_iter().map(|v| Value::new(src, v)).collect();
}
let mut n = 0;
self.res.each(|_, _| {
n += 1;
true
});
let mut out = Vec::with_capacity(n);
self.res.each(|_, v| {
out.push(Value::new(src, v));
true
});
out
}
pub(crate) fn items(&self) -> Vec<Value<'a>> {
if self.kind() == Kind::Array {
self.array()
} else {
Vec::new()
}
}
pub(crate) fn values(&self) -> Vec<Value<'a>> {
if self.kind() == Kind::Array {
return self.array();
}
let mut out = Vec::new();
self.each(|_, v| {
out.push(v);
true
});
out
}
pub(crate) fn map_len(&self) -> usize {
self.res.map().len()
}
}
pub(crate) fn get<'a>(json: &'a str, path: &str) -> Value<'a> {
Value::new(json, json::get(json.as_bytes(), path))
}
pub(crate) fn parse(json: &str) -> Value<'_> {
Value::new(json, json::parse(json.as_bytes()))
}
pub(crate) fn valid(json: &str) -> bool {
json::valid(json.as_bytes())
}
pub(crate) fn offset(json: &str, value: &Value<'_>) -> Option<usize> {
let raw = value.json();
let start = (raw.as_ptr() as usize).checked_sub(json.as_ptr() as usize)?;
(!raw.is_empty() && start + raw.len() <= json.len() && &json[start..start + raw.len()] == raw).then_some(start)
}
pub(crate) fn go_string(s: &str) -> String {
marshal(s, true)
}
pub(crate) fn js_string(s: &str) -> String {
marshal(s, false)
}
fn marshal(s: &str, html: bool) -> String {
let mut out = Vec::with_capacity(s.len() + 2);
json::marshal_str(&mut out, s.as_bytes(), html);
text(out)
}
fn text(bytes: Vec<u8>) -> String {
String::from_utf8(bytes).unwrap_or_else(|e| String::from_utf8_lossy(e.as_bytes()).into_owned())
}
pub(crate) fn set_raw(json: &str, path: &str, raw: &str) -> String {
json::try_set_raw(json.as_bytes(), path, raw).map_or_else(|_| json.to_owned(), text)
}
pub(crate) fn set_str(json: &str, path: &str, value: &str) -> String {
json::try_set_str(json.as_bytes(), path, value).map_or_else(|_| json.to_owned(), text)
}
pub(crate) fn delete(json: &str, path: &str) -> String {
json::try_delete(json.as_bytes(), path).map_or_else(|_| json.to_owned(), text)
}
pub(crate) fn delete_owned(json: String, path: &str) -> String {
json::delete_changed(json.as_bytes(), path).map_or(json, text)
}
pub(crate) fn string(json: &str, path: &str) -> String {
get(json, path).str().to_owned()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn sjson_cases_generated_by_go_match() {
let fixture: serde_json::Value =
serde_json::from_str(include_str!("claude/testdata/go_executor.json")).unwrap();
for case in fixture["sjson"].as_array().unwrap() {
let (json, path) = (case["json"].as_str().unwrap(), case["path"].as_str().unwrap());
let value = case["value"].as_str().unwrap_or_default();
let out = match case["op"].as_str().unwrap() {
"raw" => set_raw(json, path, value),
"delete" => delete(json, path),
_ => set_str(json, path, value),
};
assert_eq!(out, case["out"].as_str().unwrap(), "{case}");
}
}
#[test]
fn set_and_delete_match_sjson_byte_layout() {
assert_eq!(set_raw(r#"{"a":1 }"#, "b", "2"), r#"{"a":1 ,"b":2}"#);
assert_eq!(set_raw("{}", "b", "2"), r#"{"b":2}"#);
assert_eq!(set_raw(r#"{"a":{"x":1}}"#, "a.x", "true"), r#"{"a":{"x":true}}"#);
assert_eq!(
set_raw(r#"{"a":1}"#, "m.user_id", r#""u""#),
r#"{"a":1,"m":{"user_id":"u"}}"#
);
assert_eq!(set_raw(r#"{"a":[1,2]}"#, "a.3", "9"), r#"{"a":[1,2,null,9]}"#);
assert_eq!(set_raw(r#"{"a":[]}"#, "a.1", "9"), r#"{"a":[null,9]}"#);
assert_eq!(delete(r#"{"a":1, "b":2,"c":3}"#, "b"), r#"{"a":1,"c":3}"#);
assert_eq!(delete(r#"{"a":1, "b":2}"#, "a"), r#"{ "b":2}"#);
assert_eq!(delete(r#"{ "a" : 1 }"#, "a"), r#"{ }"#);
assert_eq!(delete(r#"{"a":[1,2,3]}"#, "a.0"), r#"{"a":[2,3]}"#);
assert_eq!(delete(r#"{"a":[1,2,3]}"#, "a.2"), r#"{"a":[1,2]}"#);
assert_eq!(delete(r#"{"a":1}"#, "zz"), r#"{"a":1}"#);
assert_eq!(set_str(r#"{"a":1}"#, "t", "x<y"), r#"{"a":1,"t":"x<y"}"#);
assert_eq!(set_str(r#"{"a":1}"#, "t", "é<"), r#"{"a":1,"t":"é\u003c"}"#);
assert_eq!(js_string("a\u{2028}<\u{1}"), "\"a\\u2028<\\u0001\"");
}
}