use crate::rules::Origin;
use std::fmt;
use std::path::Path;
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct ParseError {
pub origin: Origin,
pub message: String,
}
impl fmt::Display for ParseError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}: {}", describe(&self.origin), self.message)
}
}
impl std::error::Error for ParseError {}
pub(crate) fn describe(origin: &Origin) -> String {
match origin {
Origin::File { path, line } => format!("{}:{line}", path.display()),
Origin::Argument { index } => format!("argv[{index}]"),
Origin::Builtin { line } => format!("builtin:{line}"),
}
}
pub(crate) fn error(origin: Origin, message: impl Into<String>) -> ParseError {
ParseError {
origin,
message: message.into(),
}
}
pub(crate) fn is_skippable(line: &str) -> bool {
let trimmed = line.trim();
trimmed.is_empty() || trimmed.starts_with('#')
}
pub(crate) fn parse_lines<T, O, P>(
text: &str,
origin: O,
parse: P,
) -> Result<Vec<T>, ParseError>
where
O: Fn(usize) -> Origin,
P: Fn(&str, Origin) -> Result<T, ParseError>,
{
let mut entries = Vec::new();
for (index, line) in text.lines().enumerate() {
if is_skippable(line) {
continue;
}
entries.push(parse(line.trim(), origin(index.saturating_add(1)))?);
}
Ok(entries)
}
pub(crate) fn parse_file<T, P>(
text: &str,
path: &Path,
parse: P,
) -> Result<Vec<T>, ParseError>
where
P: Fn(&str, Origin) -> Result<T, ParseError>,
{
let origin = |line| Origin::File {
path: path.to_path_buf(),
line,
};
parse_lines(text, origin, parse)
}
pub(crate) fn parse_builtin<T, P>(
text: &str,
parse: P,
) -> Result<Vec<T>, ParseError>
where
P: Fn(&str, Origin) -> Result<T, ParseError>,
{
parse_lines(text, |line| Origin::Builtin { line }, parse)
}
pub(crate) fn parse_flag<T, P>(
value: &str,
index: usize,
parse: P,
) -> Result<Option<T>, ParseError>
where
P: Fn(&str, Origin) -> Result<T, ParseError>,
{
let origin = Origin::Argument { index };
if value.lines().nth(1).is_some() {
return Err(error(origin, "a flag value is exactly one line"));
}
if is_skippable(value) {
return Ok(None);
}
parse(value.trim(), origin).map(Some)
}
#[cfg(test)]
mod tests {
use super::*;
fn keep(
text: &str,
origin: Origin,
) -> Result<(String, Origin), ParseError> {
Ok((text.to_string(), origin))
}
fn refuse(_: &str, origin: Origin) -> Result<(), ParseError> {
Err(error(origin, "no"))
}
fn path() -> &'static Path {
Path::new(".ctrm")
}
#[test]
fn blank_and_comment_lines_yield_no_entry() {
let text = "\n# a comment\n \n*.md caveman\n";
let entries = parse_file(text, path(), keep).unwrap_or_default();
assert_eq!(entries.len(), 1);
}
#[test]
fn line_numbers_count_the_skipped_lines() {
let text = "# one\n\n*.md caveman\n";
let entries = parse_file(text, path(), keep).unwrap_or_default();
let origin = entries.first().map(|entry| entry.1.clone());
assert_eq!(
origin,
Some(Origin::File {
path: path().to_path_buf(),
line: 3,
})
);
}
#[test]
fn a_number_sign_after_the_first_field_stays_literal() {
let entries = parse_file("a#b ascii\n", path(), keep);
let texts = entries.unwrap_or_default();
assert_eq!(
texts.first().map(|entry| entry.0.as_str()),
Some("a#b ascii")
);
}
#[test]
fn a_builtin_line_is_numbered_like_a_file() {
let entries = parse_builtin("x ascii\n", keep).unwrap_or_default();
let origin = entries.first().map(|entry| entry.1.clone());
assert_eq!(origin, Some(Origin::Builtin { line: 1 }));
}
#[test]
fn a_flag_carries_its_argv_index() {
let entry = parse_flag("*.md caveman", 7, keep).unwrap_or(None);
assert_eq!(
entry.map(|entry| entry.1),
Some(Origin::Argument { index: 7 })
);
}
#[test]
fn a_multi_line_flag_value_is_refused() {
let entry = parse_flag("a ascii\nb ascii", 1, keep);
assert!(entry.is_err());
}
#[test]
fn a_comment_flag_value_yields_no_entry() {
let entry = parse_flag("# nothing here", 1, keep).unwrap_or(None);
assert!(entry.is_none());
}
#[test]
fn a_failing_line_stops_the_file_and_names_its_origin() {
let failure = parse_file("\na ascii\n", path(), refuse);
let shown = failure.err().map(|error| error.to_string());
assert_eq!(shown, Some(".ctrm:2: no".to_string()));
}
}