use crate::error::Error;
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum PathSegment<'a> {
Key(&'a str),
Index(usize),
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum OwnedPathSegment {
Key(String),
Index(usize),
}
impl OwnedPathSegment {
pub fn as_ref(&self) -> PathSegment<'_> {
match self {
OwnedPathSegment::Key(k) => PathSegment::Key(k.as_str()),
OwnedPathSegment::Index(i) => PathSegment::Index(*i),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
pub struct Path {
segments: Vec<OwnedPathSegment>,
}
impl Path {
pub fn new() -> Self {
Self {
segments: Vec::new(),
}
}
pub fn from_owned(segments: Vec<OwnedPathSegment>) -> Self {
Self { segments }
}
pub fn parse(s: &str) -> Self {
Self {
segments: owned_from_borrowed(parse_path(s)),
}
}
pub fn try_parse(s: &str) -> Result<Self, Error> {
Ok(Self {
segments: owned_from_borrowed(try_parse_path(s)?),
})
}
pub fn from_json_pointer(pointer: &str) -> Result<Self, Error> {
if pointer.is_empty() {
return Ok(Self::new());
}
if !pointer.starts_with('/') {
return Err(Error::InvalidPath {
msg: "JSON Pointer must be empty or start with '/'",
});
}
let mut segments = Vec::new();
for raw in pointer[1..].split('/') {
let token = unescape_pointer_token(raw)?;
segments.push(pointer_token_to_segment(token));
}
Ok(Self { segments })
}
pub fn len(&self) -> usize {
self.segments.len()
}
pub fn is_empty(&self) -> bool {
self.segments.is_empty()
}
pub fn owned_segments(&self) -> &[OwnedPathSegment] {
&self.segments
}
pub fn borrowed(&self) -> Vec<PathSegment<'_>> {
self.segments.iter().map(OwnedPathSegment::as_ref).collect()
}
pub fn find<'a>(&self, json: &'a [u8]) -> Result<&'a [u8], Error> {
crate::scan::find_value(json, &self.borrowed())
}
pub fn mutate(&self, json: &mut Vec<u8>, new_value: &[u8]) -> Result<(), Error> {
crate::mutate::mutate_value(json, &self.borrowed(), new_value)
}
pub fn mutate_checked(&self, json: &mut Vec<u8>, new_value: &[u8]) -> Result<(), Error> {
crate::mutate::mutate_value_checked(json, &self.borrowed(), new_value)
}
}
fn owned_from_borrowed(segs: Vec<PathSegment<'_>>) -> Vec<OwnedPathSegment> {
segs.into_iter()
.map(|s| match s {
PathSegment::Key(k) => OwnedPathSegment::Key(k.to_string()),
PathSegment::Index(i) => OwnedPathSegment::Index(i),
})
.collect()
}
fn unescape_pointer_token(raw: &str) -> Result<String, Error> {
let mut out = String::with_capacity(raw.len());
let mut chars = raw.chars().peekable();
while let Some(c) = chars.next() {
if c == '~' {
match chars.next() {
Some('0') => out.push('~'),
Some('1') => out.push('/'),
_ => {
return Err(Error::InvalidPath {
msg: "Invalid JSON Pointer escape (expected ~0 or ~1)",
});
}
}
} else {
out.push(c);
}
}
Ok(out)
}
fn pointer_token_to_segment(token: String) -> OwnedPathSegment {
if token == "0"
|| (!token.is_empty()
&& !token.starts_with('0')
&& token.bytes().all(|b| b.is_ascii_digit()))
{
if let Ok(idx) = token.parse::<usize>() {
return OwnedPathSegment::Index(idx);
}
}
OwnedPathSegment::Key(token)
}
pub fn parse_path(s: &str) -> Vec<PathSegment<'_>> {
parse_path_inner(s, false).unwrap_or_default()
}
pub fn try_parse_path(s: &str) -> Result<Vec<PathSegment<'_>>, Error> {
parse_path_inner(s, true)
}
fn parse_path_inner(mut s: &str, strict: bool) -> Result<Vec<PathSegment<'_>>, Error> {
let mut segments = Vec::new();
while !s.is_empty() {
if s.starts_with('.') {
s = &s[1..];
continue;
}
if s.is_empty() {
break;
}
if s.starts_with('[') {
match s.find(']') {
Some(end_idx) => {
let idx_str = &s[1..end_idx];
if idx_str.is_empty() {
if strict {
return Err(Error::InvalidPath {
msg: "Empty array index brackets",
});
}
} else if !idx_str.bytes().all(|b| b.is_ascii_digit()) {
if strict {
return Err(Error::InvalidPath {
msg: "Non-numeric array index",
});
}
} else {
match idx_str.parse::<usize>() {
Ok(idx) => segments.push(PathSegment::Index(idx)),
Err(_) if strict => {
return Err(Error::InvalidPath {
msg: "Array index out of range for usize",
});
}
Err(_) => {}
}
}
s = &s[end_idx + 1..];
}
None => {
if strict {
return Err(Error::InvalidPath {
msg: "Unclosed array index bracket '['",
});
}
break;
}
}
} else {
let end_key = s.find(['.', '[']).unwrap_or(s.len());
let key = &s[..end_key];
if !key.is_empty() {
segments.push(PathSegment::Key(key));
}
s = &s[end_key..];
}
}
Ok(segments)
}