workspace: move crates under crates

crates/toml-config/src/config/error.rs

@@ -0,0 +1,89 @@
+use {
+    jay_toml::toml_span::Span,
+    bstr::ByteSlice,
+    error_reporter::Report,
+    std::{
+        borrow::Cow,
+        error::Error,
+        fmt::{Display, Formatter},
+        ops::Deref,
+    },
+};
+
+#[derive(Debug)]
+pub struct SpannedError<'a, E> {
+    pub input: Cow<'a, [u8]>,
+    pub span: Span,
+    pub cause: Option<E>,
+}
+
+impl<E: Error> Display for SpannedError<'_, E> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        let original = self.input.deref();
+        let span = self.span;
+
+        let (line, column) = translate_position(original, span.lo);
+        let line_num = line + 1;
+        let col_num = column + 1;
+        let gutter = line_num.to_string().len();
+        let content = original
+            .split(|c| *c == b'\n')
+            .nth(line)
+            .expect("valid line number");
+
+        if let Some(cause) = &self.cause {
+            write!(f, "{}: ", Report::new(cause))?;
+        }
+        writeln!(f, "At line {line_num}, column {col_num}:")?;
+        for _ in 0..=gutter {
+            write!(f, " ")?;
+        }
+        writeln!(f, "|")?;
+        write!(f, "{line_num} | ")?;
+        writeln!(f, "{}", content.as_bstr())?;
+        for _ in 0..=gutter {
+            write!(f, " ")?;
+        }
+        write!(f, "|")?;
+        for _ in 0..=column {
+            write!(f, " ")?;
+        }
+        write!(f, "^")?;
+        for _ in (span.lo + 1)..(span.hi.min(span.lo + content.len() - column)) {
+            write!(f, "^")?;
+        }
+
+        Ok(())
+    }
+}
+
+impl<E: Error> Error for SpannedError<'_, E> {}
+
+fn translate_position(input: &[u8], index: usize) -> (usize, usize) {
+    if input.is_empty() {
+        return (0, index);
+    }
+
+    let safe_index = index.min(input.len() - 1);
+    let column_offset = index - safe_index;
+    let index = safe_index;
+
+    let nl = input[0..index]
+        .iter()
+        .rev()
+        .enumerate()
+        .find(|(_, b)| **b == b'\n')
+        .map(|(nl, _)| index - nl - 1);
+    let line_start = match nl {
+        Some(nl) => nl + 1,
+        None => 0,
+    };
+    let line = input[0..line_start].iter().filter(|b| **b == b'\n').count();
+
+    let column = std::str::from_utf8(&input[line_start..=index])
+        .map(|s| s.chars().count() - 1)
+        .unwrap_or_else(|_| index - line_start);
+    let column = column + column_offset;
+
+    (line, column)
+}