use std::fmt;
use jsonc_parser::cst::{CstArray, CstInputValue, CstObject, CstObjectProp, CstRootNode};
use jsonc_parser::errors::ParseError;
use jsonc_parser::ParseOptions;
pub fn set_json_string(text: &str, path: &[&str], next: &str) -> Result<String, JsonEditError> {
write_json_string(text, path, next, true)
}
pub(crate) fn replace_json_string(
text: &str,
path: &[&str],
next: &str,
) -> Result<String, JsonEditError> {
write_json_string(text, path, next, false)
}
pub(crate) fn package_json_version(text: &str) -> Result<Option<String>, JsonEditError> {
match json_string(text, &["version"]) {
Ok(version) => Ok(Some(version)),
Err(JsonEditError::Missing { .. }) => Ok(None),
Err(err) => Err(err),
}
}
pub(crate) fn json_string(text: &str, path: &[&str]) -> Result<String, JsonEditError> {
let Some((last, parents)) = path.split_last() else {
return Err(JsonEditError::EmptyPath);
};
let root = CstRootNode::parse(text, &jsonc_options())?;
let Some(root_obj) = root.object_value() else {
return Err(JsonEditError::RootNotObject);
};
let mut cursor = Cursor::Object(root_obj);
let mut walked = String::new();
for segment in parents {
cursor = descend(cursor, segment, &walked)?;
push_segment(&mut walked, segment);
}
let path = joined(&walked, last);
match cursor {
Cursor::Object(obj) => {
let matches = named_props(&obj, last);
match matches.as_slice() {
[] => Err(JsonEditError::Missing { path }),
[prop] => {
let Some(value) = prop.value() else {
return Err(JsonEditError::NotObject { path });
};
let Some(lit) = value.as_string_lit() else {
return Err(JsonEditError::NotString { path });
};
lit.decoded_value()
.map_err(|_| JsonEditError::NotString { path })
}
_ => Err(JsonEditError::Duplicate { path }),
}
}
Cursor::Array(_) => Err(JsonEditError::NotObject { path: walked }),
}
}
fn write_json_string(
text: &str,
path: &[&str],
next: &str,
create: bool,
) -> Result<String, JsonEditError> {
let root = CstRootNode::parse(text, &jsonc_options())?;
write_into(&root, path, next, create)?;
Ok(root.to_string())
}
pub(super) fn replace_in(
root: &CstRootNode,
path: &[&str],
next: &str,
) -> Result<(), JsonEditError> {
write_into(root, path, next, false)
}
fn write_into(
root: &CstRootNode,
path: &[&str],
next: &str,
create: bool,
) -> Result<(), JsonEditError> {
let Some((last, parents)) = path.split_last() else {
return Err(JsonEditError::EmptyPath);
};
let Some(root_obj) = root.object_value() else {
return Err(JsonEditError::RootNotObject);
};
let mut cursor = Cursor::Object(root_obj);
let mut walked = String::new();
for segment in parents {
cursor = descend(cursor, segment, &walked)?;
push_segment(&mut walked, segment);
}
match cursor {
Cursor::Object(obj) => {
let matches = named_props(&obj, last);
match matches.as_slice() {
[] if create => {
obj.append(last, CstInputValue::String(next.to_owned()));
}
[] => {
return Err(JsonEditError::Missing {
path: joined(&walked, last),
});
}
[prop] => {
let path = joined(&walked, last);
let Some(value) = prop.value() else {
return Err(JsonEditError::NotObject { path });
};
if value.as_string_lit().is_none() {
return Err(JsonEditError::NotString { path });
}
prop.set_value(CstInputValue::String(next.to_owned()));
}
_ => {
return Err(JsonEditError::Duplicate {
path: joined(&walked, last),
});
}
}
}
Cursor::Array(arr) => {
let index: usize = last.parse().map_err(|_| JsonEditError::BadIndex {
segment: (*last).to_owned(),
})?;
let path = joined(&walked, last);
let Some(elem) = arr.elements().into_iter().nth(index) else {
return Err(JsonEditError::Missing { path });
};
let Some(lit) = elem.as_string_lit() else {
return Err(JsonEditError::NotString { path });
};
if lit.decoded_value().is_err() {
return Err(JsonEditError::NotString { path });
}
lit.replace_with(CstInputValue::String(next.to_owned()));
}
}
Ok(())
}
pub(super) enum Cursor {
Object(CstObject),
Array(CstArray),
}
pub(super) fn descend(
cursor: Cursor,
segment: &str,
walked: &str,
) -> Result<Cursor, JsonEditError> {
let path = joined(walked, segment);
match cursor {
Cursor::Object(obj) => {
let matches = named_props(&obj, segment);
match matches.as_slice() {
[] => Err(JsonEditError::Missing { path }),
[prop] => {
let Some(value) = prop.value() else {
return Err(JsonEditError::NotObject { path });
};
if let Some(child) = value.as_object() {
return Ok(Cursor::Object(child));
}
if let Some(child) = value.as_array() {
return Ok(Cursor::Array(child));
}
Err(JsonEditError::NotObject { path })
}
_ => Err(JsonEditError::Duplicate { path }),
}
}
Cursor::Array(arr) => {
let index: usize = segment.parse().map_err(|_| JsonEditError::BadIndex {
segment: segment.to_owned(),
})?;
let Some(elem) = arr.elements().into_iter().nth(index) else {
return Err(JsonEditError::Missing { path });
};
if let Some(child) = elem.as_object() {
return Ok(Cursor::Object(child));
}
if let Some(child) = elem.as_array() {
return Ok(Cursor::Array(child));
}
Err(JsonEditError::NotObject { path })
}
}
}
pub(super) fn push_segment(walked: &mut String, segment: &str) {
if !walked.is_empty() {
walked.push('/');
}
walked.push_str(segment);
}
pub(super) fn jsonc_options() -> ParseOptions {
ParseOptions {
allow_comments: true,
allow_trailing_commas: true,
allow_loose_object_property_names: false,
allow_missing_commas: false,
allow_single_quoted_strings: false,
allow_hexadecimal_numbers: false,
allow_unary_plus_numbers: false,
allow_bare_decimal_point_numbers: false,
allow_extended_string_escapes: false,
allow_non_finite_numbers: false,
}
}
pub(super) fn named_props(obj: &CstObject, name: &str) -> Vec<CstObjectProp> {
obj.properties()
.into_iter()
.filter(|prop| {
prop.name()
.and_then(|n| n.decoded_value().ok())
.is_some_and(|decoded| decoded == name)
})
.collect()
}
fn joined(walked: &str, segment: &str) -> String {
if walked.is_empty() {
segment.to_owned()
} else {
format!("{walked}/{segment}")
}
}
#[derive(Debug)]
pub enum JsonEditError {
Parse(ParseError),
EmptyPath,
RootNotObject,
Missing { path: String },
NotObject { path: String },
NotString { path: String },
Duplicate { path: String },
BadIndex { segment: String },
}
impl fmt::Display for JsonEditError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Parse(err) => write!(f, "JSONC parse failed: {err}"),
Self::EmptyPath => f.write_str("JSON edit path must not be empty"),
Self::RootNotObject => f.write_str("JSON document root must be an object"),
Self::Missing { path } => write!(f, "JSON path `{path}` does not exist"),
Self::NotObject { path } => {
write!(f, "JSON path `{path}` is not an object")
}
Self::NotString { path } => {
write!(f, "JSON path `{path}` is not a string")
}
Self::Duplicate { path } => {
write!(f, "JSON path `{path}` has duplicate keys")
}
Self::BadIndex { segment } => {
write!(f, "JSON array index `{segment}` is not a number")
}
}
}
}
impl std::error::Error for JsonEditError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match self {
Self::Parse(err) => Some(err),
Self::EmptyPath
| Self::RootNotObject
| Self::Missing { .. }
| Self::NotObject { .. }
| Self::NotString { .. }
| Self::Duplicate { .. }
| Self::BadIndex { .. } => None,
}
}
}
impl From<ParseError> for JsonEditError {
fn from(err: ParseError) -> Self {
Self::Parse(err)
}
}
#[cfg(test)]
mod tests {
use super::{package_json_version, replace_json_string, set_json_string, JsonEditError};
#[test]
fn package_json_version_is_none_only_when_absent() {
assert_eq!(
package_json_version("{\"version\": \"0.4.1\"}").expect("read"),
Some(String::from("0.4.1"))
);
assert_eq!(
package_json_version("{\"name\": \"x\"}").expect("read"),
None
);
assert!(package_json_version("{\"version\": 1}").is_err());
assert!(package_json_version("not json").is_err());
}
#[test]
fn helper_keeps_comments_and_trailing_newline() {
let src = "{\n // keep\n \"name\": \"demo\",\n \"version\": \"0.1.0\"\n}\n";
let out = set_json_string(src, &["version"], "0.2.0").expect("edit");
assert_eq!(
out,
"{\n // keep\n \"name\": \"demo\",\n \"version\": \"0.2.0\"\n}\n"
);
}
#[test]
fn helper_keeps_crlf_and_trailing_newline() {
let src = "{\r\n \"version\": \"0.1.0\"\r\n}\r\n";
let out = set_json_string(src, &["version"], "0.2.0").expect("edit");
assert_eq!(out, "{\r\n \"version\": \"0.2.0\"\r\n}\r\n");
}
#[test]
fn helper_sets_nested_plugins_version() {
let src = "{\n \"plugins\": [\n {\n \"name\": \"demo\",\n \"version\": \"0.1.0\"\n }\n ]\n}\n";
let out = set_json_string(src, &["plugins", "0", "version"], "0.2.0").expect("edit");
assert_eq!(
out,
"{\n \"plugins\": [\n {\n \"name\": \"demo\",\n \"version\": \"0.2.0\"\n }\n ]\n}\n"
);
}
#[test]
fn helper_inserts_a_missing_version_key() {
let src = "{\n \"name\": \"demo\"\n}\n";
let out = set_json_string(src, &["version"], "0.1.0").expect("edit");
assert_eq!(
out,
"{\n \"name\": \"demo\",\n \"version\": \"0.1.0\"\n}\n"
);
}
#[test]
fn replace_missing_last_key_is_an_error() {
let err = replace_json_string("{\n \"name\": \"demo\"\n}\n", &["version"], "0.1.0")
.expect_err("missing");
assert!(matches!(err, JsonEditError::Missing { path } if path == "version"));
}
#[test]
fn existing_non_string_last_key_is_an_error() {
let err = replace_json_string("{\n \"version\": 1\n}\n", &["version"], "0.2.0")
.expect_err("kind");
assert_eq!(err.to_string(), "JSON path `version` is not a string");
assert!(matches!(err, JsonEditError::NotString { path } if path == "version"));
let set =
set_json_string("{\n \"version\": 1\n}\n", &["version"], "0.2.0").expect_err("kind");
assert!(matches!(set, JsonEditError::NotString { path } if path == "version"));
let catalog = replace_json_string(
"{\n \"catalog\": {\n \"core\": 1\n }\n}\n",
&["catalog", "core"],
"^0.2.0",
)
.expect_err("kind");
assert!(matches!(catalog, JsonEditError::NotString { path } if path == "catalog/core"));
}
#[test]
fn missing_intermediate_path_is_an_error() {
let err = set_json_string(
"{\n \"name\": \"demo\"\n}\n",
&["plugins", "0", "version"],
"0.2.0",
)
.expect_err("missing");
assert!(matches!(err, JsonEditError::Missing { path } if path == "plugins"));
}
#[test]
fn empty_path_is_an_error() {
let err = set_json_string("{\n}\n", &[], "0.1.0").expect_err("empty");
assert!(matches!(err, JsonEditError::EmptyPath));
}
#[test]
fn invalid_json_is_a_parse_error() {
let err = set_json_string("{", &["version"], "0.1.0").expect_err("parse");
assert!(matches!(err, JsonEditError::Parse(_)));
}
#[test]
fn scalar_intermediate_is_not_object() {
let err = set_json_string(
"{\n \"plugins\": \"nope\"\n}\n",
&["plugins", "0", "version"],
"0.2.0",
)
.expect_err("kind");
assert!(matches!(err, JsonEditError::NotObject { path } if path == "plugins"));
}
#[test]
fn duplicate_last_key_is_an_error() {
let err = set_json_string(
"{\n \"version\": \"0.1.0\",\n \"version\": \"9.9.9\"\n}\n",
&["version"],
"0.2.0",
)
.expect_err("dup");
assert!(matches!(err, JsonEditError::Duplicate { path } if path == "version"));
}
#[test]
fn helper_keeps_trailing_comment_on_the_edited_key() {
let src = "{\n \"version\": \"0.1.0\" // keep\n}\n";
let out = set_json_string(src, &["version"], "0.2.0").expect("edit");
assert_eq!(out, "{\n \"version\": \"0.2.0\" // keep\n}\n");
}
#[test]
fn helper_sets_the_second_plugin_and_leaves_the_first() {
let src = "{\n \"plugins\": [\n { \"version\": \"0.1.0\" },\n { \"version\": \"0.1.0\" }\n ]\n}\n";
let out = set_json_string(src, &["plugins", "1", "version"], "0.2.0").expect("edit");
assert_eq!(
out,
"{\n \"plugins\": [\n { \"version\": \"0.1.0\" },\n { \"version\": \"0.2.0\" }\n ]\n}\n"
);
}
#[test]
fn array_root_is_not_object() {
let err = set_json_string("[]\n", &["version"], "0.1.0").expect_err("root");
assert!(matches!(err, JsonEditError::RootNotObject));
}
#[test]
fn helper_walks_a_nested_object_key() {
let src = "{\n \"package\": {\n \"version\": \"0.1.0\"\n }\n}\n";
let out = set_json_string(src, &["package", "version"], "0.2.0").expect("edit");
assert_eq!(
out,
"{\n \"package\": {\n \"version\": \"0.2.0\"\n }\n}\n"
);
}
#[test]
fn out_of_range_array_index_is_missing() {
let err = set_json_string(
"{\n \"plugins\": [{ \"version\": \"0.1.0\" }]\n}\n",
&["plugins", "1", "version"],
"0.2.0",
)
.expect_err("oob");
assert!(matches!(err, JsonEditError::Missing { path } if path == "plugins/1"));
}
#[test]
fn non_numeric_array_index_is_bad_index() {
let err = set_json_string(
"{\n \"plugins\": [{ \"version\": \"0.1.0\" }]\n}\n",
&["plugins", "x", "version"],
"0.2.0",
)
.expect_err("idx");
assert!(matches!(err, JsonEditError::BadIndex { segment } if segment == "x"));
}
#[test]
fn scalar_array_element_is_not_object() {
let err = set_json_string(
"{\n \"plugins\": [\"0.1.0\"]\n}\n",
&["plugins", "0", "version"],
"0.2.0",
)
.expect_err("elem");
assert!(matches!(err, JsonEditError::NotObject { path } if path == "plugins/0"));
}
#[test]
fn duplicate_intermediate_key_is_an_error() {
let err = set_json_string(
"{\n \"plugins\": [{ \"version\": \"0.1.0\" }],\n \"plugins\": [{ \"version\": \"9.9.9\" }]\n}\n",
&["plugins", "0", "version"],
"0.2.0",
)
.expect_err("dup");
assert!(matches!(err, JsonEditError::Duplicate { path } if path == "plugins"));
}
#[test]
fn last_segment_on_an_array_replaces_a_string_element() {
let next = set_json_string(
"{\n \"versions\": [\"0.1.0\", \"9.9.9\"]\n}\n",
&["versions", "0"],
"0.2.0",
)
.expect("arr leaf");
assert!(next.contains("\"0.2.0\""));
assert!(next.contains("\"9.9.9\""));
}
#[test]
fn last_segment_on_an_object_array_element_is_not_string() {
let err = set_json_string(
"{\n \"plugins\": [{ \"version\": \"0.1.0\" }]\n}\n",
&["plugins", "0"],
"0.2.0",
)
.expect_err("arr");
assert!(matches!(err, JsonEditError::NotString { path } if path == "plugins/0"));
}
#[test]
fn json5_missing_comma_is_a_parse_error() {
let err = set_json_string(
"{ \"name\": \"demo\" \"version\": \"0.1.0\" }\n",
&["version"],
"0.2.0",
)
.expect_err("json5");
assert!(matches!(err, JsonEditError::Parse(_)));
}
#[test]
fn json5_extras_are_parse_errors() {
for extra in [
"{ name: \"demo\", \"version\": \"0.1.0\" }",
"{ \"name\": 'demo', \"version\": \"0.1.0\" }",
"{ \"n\": 0x10, \"version\": \"0.1.0\" }",
"{ \"n\": +1, \"version\": \"0.1.0\" }",
"{ \"n\": .5, \"version\": \"0.1.0\" }",
"{ \"d\": \"\\x41\", \"version\": \"0.1.0\" }",
"{ \"n\": NaN, \"version\": \"0.1.0\" }",
] {
let err = set_json_string(extra, &["version"], "0.2.0").expect_err(extra);
assert!(matches!(err, JsonEditError::Parse(_)), "{extra}: {err:?}");
}
}
}