use fig_core::kit::ast::PathSegment;
use crate::capi::{self, Status};
use crate::error::{EditTarget, Error, edit_status};
use crate::value::{Value, value_text, value_text_with};
use crate::{Format, SerializeOptions};
#[derive(Clone, Copy, Debug)]
pub enum Segment<'a> {
Key(&'a str),
Index(usize),
}
impl<'a> From<&'a str> for Segment<'a> {
fn from(key: &'a str) -> Self {
Segment::Key(key)
}
}
impl From<usize> for Segment<'_> {
fn from(index: usize) -> Self {
Segment::Index(index)
}
}
pub(crate) fn to_core_path<'a>(path: &[Segment<'a>]) -> Vec<PathSegment<'a>> {
path.iter()
.map(|seg| match seg {
Segment::Key(k) => PathSegment::Key(k.as_bytes()),
Segment::Index(i) => PathSegment::Index(*i),
})
.collect()
}
pub(crate) fn to_core_keys<S: AsRef<str>>(keys: &[S]) -> Vec<&[u8]> {
keys.iter().map(|k| k.as_ref().as_bytes()).collect()
}
#[derive(Debug)]
pub struct Editor {
inner: capi::Editor,
format: Format,
}
impl Editor {
pub fn open(input: &[u8], format: Format) -> Result<Self, Error> {
match capi::Editor::create(input, format.to_c()) {
Ok(inner) => Ok(Self { inner, format }),
Err(Status::ParseError) => Err(match crate::Document::parse(input, format) {
Err(e @ Error::Parse(_)) => e,
_ => Error::Parse(crate::error::ParseError::generic()),
}),
Err(status) => Err(Error::from_status(status).err().unwrap_or(Error::Internal)),
}
}
pub fn replace_value(
&mut self,
path: &[Segment],
value: impl Into<Value>,
) -> Result<(), Error> {
let value = value.into();
let repl = value_text(&value, self.format)?;
self.replace_rendered(path, &repl, &value)
}
pub fn rename_key(&mut self, path: &[Segment], key: &str) -> Result<(), Error> {
let p = to_core_path(path);
let status = self.inner.replace_named_key(&p, key.as_bytes());
edit_status(status, self.format, EditTarget::Key)
}
pub fn insert_value(
&mut self,
path: &[Segment],
key: &str,
value: impl Into<Value>,
) -> Result<(), Error> {
let val = value_text(&value.into(), self.format)?;
let p = to_core_path(path);
let status = self
.inner
.insert_named_key(&p, key.as_bytes(), val.as_bytes());
edit_status(status, self.format, EditTarget::Value)
}
pub fn set_value(&mut self, path: &[Segment], value: impl Into<Value>) -> Result<(), Error> {
let value = value.into();
let val = value_text(&value, self.format)?;
self.set_rendered(path, &val, &value)
}
pub fn replace_value_with(
&mut self,
path: &[Segment],
value: impl Into<Value>,
options: SerializeOptions,
) -> Result<(), Error> {
let value = value.into();
let repl = value_text_with(&value, self.format, options)?;
self.replace_rendered(path, &repl, &value)
}
pub fn insert_value_with(
&mut self,
path: &[Segment],
key: &str,
value: impl Into<Value>,
options: SerializeOptions,
) -> Result<(), Error> {
let val = value_text_with(&value.into(), self.format, options)?;
let p = to_core_path(path);
let status = self
.inner
.insert_named_key(&p, key.as_bytes(), val.as_bytes());
edit_status(status, self.format, EditTarget::Value)
}
pub fn set_value_with(
&mut self,
path: &[Segment],
value: impl Into<Value>,
options: SerializeOptions,
) -> Result<(), Error> {
let value = value.into();
let val = value_text_with(&value, self.format, options)?;
self.set_rendered(path, &val, &value)
}
fn replace_rendered(
&mut self,
path: &[Segment],
repl: &str,
value: &Value,
) -> Result<(), Error> {
let p = to_core_path(path);
let status = match value {
Value::Str(s) => self.inner.replace_string(&p, repl.as_bytes(), s.as_bytes()),
_ => self.inner.replace_val(&p, repl.as_bytes()),
};
edit_status(status, self.format, EditTarget::Value)
}
fn set_rendered(&mut self, path: &[Segment], val: &str, value: &Value) -> Result<(), Error> {
let p = to_core_path(path);
let status = match value {
Value::Str(s) => self.inner.set_string(&p, val.as_bytes(), s.as_bytes()),
_ => self.inner.set(&p, val.as_bytes()),
};
edit_status(status, self.format, EditTarget::Value)
}
pub fn append_value(&mut self, path: &[Segment], value: impl Into<Value>) -> Result<(), Error> {
let val = value_text(&value.into(), self.format)?;
self.append_text(path, &val)
}
pub fn append_value_with(
&mut self,
path: &[Segment],
value: impl Into<Value>,
options: SerializeOptions,
) -> Result<(), Error> {
let val = value_text_with(&value.into(), self.format, options)?;
self.append_text(path, &val)
}
fn append_text(&mut self, path: &[Segment], val: &str) -> Result<(), Error> {
let p = to_core_path(path);
let status = self.inner.append_seq(&p, val.as_bytes());
edit_status(status, self.format, EditTarget::Value)
}
pub fn prepend_value(
&mut self,
path: &[Segment],
value: impl Into<Value>,
) -> Result<(), Error> {
let val = value_text(&value.into(), self.format)?;
self.prepend_text(path, &val)
}
pub fn prepend_value_with(
&mut self,
path: &[Segment],
value: impl Into<Value>,
options: SerializeOptions,
) -> Result<(), Error> {
let val = value_text_with(&value.into(), self.format, options)?;
self.prepend_text(path, &val)
}
fn prepend_text(&mut self, path: &[Segment], val: &str) -> Result<(), Error> {
let p = to_core_path(path);
let status = self.inner.prepend_seq(&p, val.as_bytes());
edit_status(status, self.format, EditTarget::Value)
}
pub fn insert_item(
&mut self,
path: &[Segment],
index: usize,
value: impl Into<Value>,
) -> Result<(), Error> {
let val = value_text(&value.into(), self.format)?;
self.insert_item_text(path, index, &val)
}
pub fn insert_item_with(
&mut self,
path: &[Segment],
index: usize,
value: impl Into<Value>,
options: SerializeOptions,
) -> Result<(), Error> {
let val = value_text_with(&value.into(), self.format, options)?;
self.insert_item_text(path, index, &val)
}
fn insert_item_text(&mut self, path: &[Segment], index: usize, val: &str) -> Result<(), Error> {
let p = to_core_path(path);
let status = self.inner.insert_seq_item(&p, index, val.as_bytes());
edit_status(status, self.format, EditTarget::Value)
}
pub fn add_leading_comment(&mut self, path: &[Segment], text: &str) -> Result<(), Error> {
let p = to_core_path(path);
let status = self.inner.add_leading_comment(&p, text.as_bytes());
edit_status(status, self.format, EditTarget::Comment)
}
pub fn set_trailing_comment(&mut self, path: &[Segment], text: &str) -> Result<(), Error> {
let p = to_core_path(path);
let status = self.inner.set_trailing_comment(&p, text.as_bytes());
edit_status(status, self.format, EditTarget::Comment)
}
pub fn delete_leading_comment(&mut self, path: &[Segment]) -> Result<(), Error> {
let p = to_core_path(path);
let status = self.inner.delete_leading_comments(&p);
edit_status(status, self.format, EditTarget::Document)
}
pub fn delete_trailing_comment(&mut self, path: &[Segment]) -> Result<(), Error> {
let p = to_core_path(path);
let status = self.inner.delete_trailing_comment(&p);
edit_status(status, self.format, EditTarget::Document)
}
pub fn leading_comment(&self, path: &[Segment]) -> Result<Option<String>, Error> {
self.read_comment(path, false)
}
pub fn trailing_comment(&self, path: &[Segment]) -> Result<Option<String>, Error> {
self.read_comment(path, true)
}
fn read_comment(&self, path: &[Segment], trailing: bool) -> Result<Option<String>, Error> {
let p = to_core_path(path);
let comment = if trailing {
self.inner.get_trailing_comment(&p)
} else {
self.inner.get_leading_comment(&p)
};
comment_text(comment)
}
pub fn add_dangling_comment(&mut self, path: &[Segment], text: &str) -> Result<(), Error> {
let p = to_core_path(path);
let status = self.inner.add_dangling_comment(&p, text.as_bytes());
edit_status(status, self.format, EditTarget::Comment)
}
pub fn delete_dangling_comment(&mut self, path: &[Segment]) -> Result<(), Error> {
let p = to_core_path(path);
let status = self.inner.delete_dangling_comments(&p);
edit_status(status, self.format, EditTarget::Document)
}
pub fn dangling_comment(&self, path: &[Segment]) -> Result<Option<String>, Error> {
let p = to_core_path(path);
comment_text(self.inner.get_dangling_comment(&p))
}
pub fn comment_out(&mut self, path: &[Segment]) -> Result<(), Error> {
let p = to_core_path(path);
let status = self.inner.comment_out(&p);
edit_status(status, self.format, EditTarget::Document)
}
pub fn uncomment_leading(
&mut self,
path: &[Segment],
first_line: usize,
line_count: usize,
) -> Result<(), Error> {
let p = to_core_path(path);
let status = self.inner.uncomment_leading(&p, first_line, line_count);
edit_status(status, self.format, EditTarget::Document)
}
pub fn uncomment_dangling(
&mut self,
path: &[Segment],
first_line: usize,
line_count: usize,
) -> Result<(), Error> {
let p = to_core_path(path);
let status = self.inner.uncomment_dangling(&p, first_line, line_count);
edit_status(status, self.format, EditTarget::Document)
}
pub fn delete_key(&mut self, path: &[Segment]) -> Result<(), Error> {
let p = to_core_path(path);
let status = self.inner.delete_key(&p);
edit_status(status, self.format, EditTarget::Document)
}
pub fn delete_item(&mut self, path: &[Segment], index: usize) -> Result<(), Error> {
let p = to_core_path(path);
let status = self.inner.remove_seq_item(&p, index);
edit_status(status, self.format, EditTarget::Document)
}
pub fn move_key(&mut self, src_path: &[Segment], dest_path: &[Segment]) -> Result<(), Error> {
let s = to_core_path(src_path);
let d = to_core_path(dest_path);
let status = self.inner.move_key(&s, &d);
edit_status(status, self.format, EditTarget::Document)
}
pub fn reorder_keys<S: AsRef<str>>(
&mut self,
path: &[Segment],
keys: &[S],
) -> Result<(), Error> {
let p = to_core_path(path);
let k = to_core_keys(keys);
let status = self.inner.reorder_keys(&p, &k);
edit_status(status, self.format, EditTarget::Document)
}
pub fn move_item(&mut self, path: &[Segment], from: usize, to: usize) -> Result<(), Error> {
let p = to_core_path(path);
let status = self.inner.move_item(&p, from, to);
edit_status(status, self.format, EditTarget::Document)
}
pub fn reorder_items(&mut self, path: &[Segment], indices: &[usize]) -> Result<(), Error> {
let p = to_core_path(path);
let status = self.inner.reorder_items(&p, indices);
edit_status(status, self.format, EditTarget::Document)
}
pub fn set_sequence<I>(&mut self, path: &[Segment], items: I) -> Result<(), Error>
where
I: IntoIterator,
I::Item: Into<Value>,
{
let texts: Vec<String> = items
.into_iter()
.map(|v| value_text(&v.into(), self.format))
.collect::<Result<_, _>>()?;
let strs = to_core_keys(&texts);
let p = to_core_path(path);
let status = self.inner.set_sequence(&p, &strs);
edit_status(status, self.format, EditTarget::Value)
}
pub fn delete_container(&mut self, path: &[Segment]) -> Result<(), Error> {
let p = to_core_path(path);
let status = self.inner.delete_container(&p);
edit_status(status, self.format, EditTarget::Document)
}
pub fn insert_container(&mut self, path: &[Segment], body: &str) -> Result<(), Error> {
let p = to_core_path(path);
let status = self.inner.insert_container(&p, body.as_bytes());
edit_status(status, self.format, EditTarget::Value)
}
pub fn rename_container(&mut self, path: &[Segment], new_leaf: &str) -> Result<(), Error> {
let p = to_core_path(path);
let status = self.inner.rename_container(&p, new_leaf.as_bytes());
edit_status(status, self.format, EditTarget::Key)
}
pub fn move_container(
&mut self,
src_path: &[Segment],
dest_path: Option<&[Segment]>,
) -> Result<(), Error> {
let s = to_core_path(src_path);
let d = dest_path.map(to_core_path);
let status = self.inner.move_container(&s, d.as_deref());
edit_status(status, self.format, EditTarget::Document)
}
pub fn reorder_containers<S: AsRef<str>>(&mut self, order: &[S]) -> Result<(), Error> {
let o = to_core_keys(order);
let status = self.inner.reorder_containers(&o);
edit_status(status, self.format, EditTarget::Document)
}
pub fn append_container_to_seq(&mut self, path: &[Segment], body: &str) -> Result<(), Error> {
let p = to_core_path(path);
let status = self.inner.append_container_to_seq(&p, body.as_bytes());
edit_status(status, self.format, EditTarget::Value)
}
pub fn source(&self) -> Result<&str, Error> {
std::str::from_utf8(self.inner.source()).map_err(|_| Error::Utf8)
}
}
fn comment_text(comment: Result<Vec<u8>, Status>) -> Result<Option<String>, Error> {
match comment {
Ok(bytes) => String::from_utf8(bytes).map(Some).map_err(|_| Error::Utf8),
Err(Status::NotFound) => Ok(None),
Err(status) => Err(Error::from_status(status).err().unwrap_or(Error::Internal)),
}
}