use std::{error::Error, fmt, ops::Range};
use crate::{
Field, FieldName, FormatStyle, LineEnding, LogicalValue, Parse, SourceSpan, make, parse,
};
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum EditError {
RecordOutOfBounds {
index: usize,
},
FieldNotFound {
name: String,
},
}
impl fmt::Display for EditError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::RecordOutOfBounds { index } => {
write!(formatter, "record index {index} is out of bounds")
}
Self::FieldNotFound { name } => write!(formatter, "field {name:?} was not found"),
}
}
}
impl Error for EditError {}
impl Parse {
pub fn edit(&self) -> Editor {
Editor {
current: self.clone(),
}
}
pub fn replace_last(
&self,
record: usize,
name: &str,
value: &LogicalValue,
) -> Result<Self, EditError> {
replace(self, record, name, value, false)
}
pub fn replace_all(
&self,
record: usize,
name: &str,
value: &LogicalValue,
) -> Result<Self, EditError> {
replace(self, record, name, value, true)
}
pub fn remove_last(&self, record: usize, name: &str) -> Result<Self, EditError> {
remove(self, record, name, false)
}
pub fn remove_all(&self, record: usize, name: &str) -> Result<Self, EditError> {
remove(self, record, name, true)
}
pub fn insert_after(
&self,
record: usize,
after: &str,
name: &FieldName,
value: &LogicalValue,
) -> Result<Self, EditError> {
let selected = self
.records()
.nth(record)
.ok_or(EditError::RecordOutOfBounds { index: record })?;
let anchor = selected
.last_field(after)
.ok_or_else(|| EditError::FieldNotFound {
name: after.to_owned(),
})?;
let raw = anchor.raw_text();
let ending = final_ending(&raw);
let style = style_of(&anchor);
let new_field = make::field(name, value, &style);
let insertion = if ending.is_empty() {
format!("{}{new_field}", style.line_ending.as_str())
} else {
format!("{new_field}{ending}")
};
let offset = anchor.source_range().end;
Ok(parse(&replace_ranges(
&self.to_string(),
&[(SourceSpan::new(offset, offset), insertion)],
)))
}
pub fn set_unique(
&self,
record: usize,
name: &FieldName,
value: &LogicalValue,
style: &FormatStyle,
) -> Result<Self, EditError> {
set_unique(self, record, name, value, style)
}
}
#[derive(Debug, Clone)]
pub struct Editor {
current: Parse,
}
impl Editor {
pub fn replace_last(
mut self,
record: usize,
name: &str,
value: &LogicalValue,
) -> Result<Self, EditError> {
self.current = self.current.replace_last(record, name, value)?;
Ok(self)
}
pub fn replace_all(
mut self,
record: usize,
name: &str,
value: &LogicalValue,
) -> Result<Self, EditError> {
self.current = self.current.replace_all(record, name, value)?;
Ok(self)
}
pub fn insert_after(
mut self,
record: usize,
after: &str,
name: &FieldName,
value: &LogicalValue,
) -> Result<Self, EditError> {
self.current = self.current.insert_after(record, after, name, value)?;
Ok(self)
}
pub fn remove_last(mut self, record: usize, name: &str) -> Result<Self, EditError> {
self.current = self.current.remove_last(record, name)?;
Ok(self)
}
pub fn remove_all(mut self, record: usize, name: &str) -> Result<Self, EditError> {
self.current = self.current.remove_all(record, name)?;
Ok(self)
}
pub fn set_unique(
mut self,
record: usize,
name: &FieldName,
value: &LogicalValue,
style: &FormatStyle,
) -> Result<Self, EditError> {
self.current = self.current.set_unique(record, name, value, style)?;
Ok(self)
}
pub fn finish(self) -> Parse {
self.current
}
}
fn replace(
parse_result: &Parse,
record_index: usize,
name: &str,
value: &LogicalValue,
all: bool,
) -> Result<Parse, EditError> {
let record = parse_result
.records()
.nth(record_index)
.ok_or(EditError::RecordOutOfBounds {
index: record_index,
})?;
let mut fields: Vec<_> = record.fields_named(name).collect();
if fields.is_empty() {
return Err(EditError::FieldNotFound {
name: name.to_owned(),
});
}
if !all {
fields.drain(..fields.len() - 1);
}
let replacements: Vec<_> = fields
.iter()
.map(|field| (field.source_range(), styled_replacement(field, value)))
.collect();
Ok(parse(&replace_ranges(
&parse_result.to_string(),
&replacements,
)))
}
fn remove(
parse_result: &Parse,
record_index: usize,
name: &str,
all: bool,
) -> Result<Parse, EditError> {
let record = parse_result
.records()
.nth(record_index)
.ok_or(EditError::RecordOutOfBounds {
index: record_index,
})?;
let mut fields: Vec<_> = record.fields_named(name).collect();
if fields.is_empty() {
return Err(EditError::FieldNotFound {
name: name.to_owned(),
});
}
if !all {
fields.drain(..fields.len() - 1);
}
let replacements: Vec<_> = fields
.iter()
.map(|field| (field.source_range(), String::new()))
.collect();
Ok(parse(&replace_ranges(
&parse_result.to_string(),
&replacements,
)))
}
fn set_unique(
parse_result: &Parse,
record_index: usize,
name: &FieldName,
value: &LogicalValue,
style: &FormatStyle,
) -> Result<Parse, EditError> {
let record = parse_result
.records()
.nth(record_index)
.ok_or(EditError::RecordOutOfBounds {
index: record_index,
})?;
let fields = record.fields_named(name.as_str()).collect::<Vec<_>>();
let source = parse_result.to_string();
if fields.is_empty() {
let anchor = record
.fields()
.last()
.ok_or_else(|| EditError::FieldNotFound {
name: "<insertion anchor>".to_owned(),
})?;
let raw = anchor.raw_text();
let ending = final_ending(&raw);
let field = make::field(name, value, style);
let insertion = if ending.is_empty() {
format!("{}{field}", style.line_ending.as_str())
} else {
format!("{field}{ending}")
};
let offset = anchor.source_range().end;
return Ok(parse(&replace_ranges(
&source,
&[(SourceSpan::new(offset, offset), insertion)],
)));
}
let Some((last, earlier)) = fields.split_last() else {
return Ok(parse_result.clone());
};
let ending = final_ending(&last.raw_text()).to_owned();
let replacement = format!("{}{ending}", make::field(name, value, style));
let mut replacements = earlier
.iter()
.map(|field| (field.source_range(), String::new()))
.collect::<Vec<_>>();
replacements.push((last.source_range(), replacement));
Ok(parse(&replace_ranges(&source, &replacements)))
}
fn styled_replacement(field: &Field, value: &LogicalValue) -> String {
let raw = field.raw_text();
let ending = final_ending(&raw);
let name = FieldName::new(field.name().expect("valid fields have names"))
.expect("parser validates field names");
let style = style_of(field);
let first_body = raw.split(['\r', '\n']).next().unwrap_or_default();
let after_colon = first_body.split_once(':').map_or("", |(_, text)| text);
let prefix_len = after_colon
.bytes()
.take_while(|byte| matches!(byte, b' ' | b'\t'))
.count();
let prefix = &after_colon[..prefix_len];
let mut lines = value.as_str().split('\n');
let first = lines.next().unwrap_or_default();
let mut replacement = format!("{name}:{prefix}{first}");
for line in lines {
replacement.push_str(style.line_ending.as_str());
replacement.push_str(&style.continuation_indent);
replacement.push_str(if line.is_empty() { "." } else { line });
}
replacement.push_str(ending);
replacement
}
fn style_of(field: &Field) -> FormatStyle {
let raw = field.raw_text();
let line_ending = if raw.contains("\r\n") {
LineEnding::CrLf
} else if raw.contains('\r') {
LineEnding::Cr
} else {
LineEnding::Lf
};
let first_body = raw.split(['\r', '\n']).next().unwrap_or_default();
let after_colon = first_body.split_once(':').map_or("", |(_, value)| value);
FormatStyle {
line_ending,
continuation_indent: continuation_indent(&raw).unwrap_or_else(|| " ".to_owned()),
space_after_colon: after_colon.starts_with([' ', '\t']),
}
}
fn continuation_indent(raw: &str) -> Option<String> {
raw.split(['\r', '\n']).skip(1).find_map(|line| {
let length = line
.bytes()
.take_while(|byte| matches!(byte, b' ' | b'\t'))
.count();
(length > 0).then(|| line[..length].to_owned())
})
}
fn final_ending(raw: &str) -> &str {
if raw.ends_with("\r\n") {
"\r\n"
} else if raw.ends_with('\r') {
"\r"
} else if raw.ends_with('\n') {
"\n"
} else {
""
}
}
fn replace_ranges(source: &str, replacements: &[(SourceSpan, String)]) -> String {
let mut replacements = replacements.to_vec();
replacements.sort_unstable_by_key(|(span, _)| std::cmp::Reverse(span.start));
let mut output = source.to_owned();
for (span, replacement) in replacements {
output.replace_range(Range::<usize>::from(span), &replacement);
}
output
}