Refactor write.rs

.gitignore

@@ -1,2 +1,3 @@
 /target
-Cargo.lock
+Cargo.lock
+*.pending-snap

src/display.rs

@@ -1,30 +1,24 @@
 use std::fmt::{self, Display};
 
 #[derive(Copy, Clone, Debug)]
-pub struct Show<T>(pub T);
+pub(crate) struct Show<T>(pub Option<T>);
 
-impl<T: Display> Display for Show<Option<T>> {
+impl<T: Display> Display for Show<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match &self.0 {
-            Some(x) => write!(f, "{}", x),
+            Some(x) => write!(f, "{x}"),
             None => Ok(()),
         }
     }
 }
 
-impl<'a, T, F: Fn(&mut fmt::Formatter, &'a T) -> fmt::Result> Display for Show<(&'a [T], F)> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        for x in self.0 .0 {
-            (self.0 .1)(f, x)?;
-        }
-        Ok(())
-    }
-}
+#[derive(Copy, Clone, Debug)]
+pub(crate) struct Rept<T>(pub T, pub usize);
 
-impl<T: Display> Display for Show<(T, usize)> {
+impl<T: Display> Display for Rept<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        for _ in 0..self.0 .1 {
-            write!(f, "{}", self.0 .0)?;
+        for _ in 0..self.1 {
+            write!(f, "{}", self.0)?;
         }
         Ok(())
     }

src/draw.rs

@@ -76,6 +76,22 @@ impl Characters {
             underline: '^',
         }
     }
+
+    pub(crate) fn arrow_bend(&self, is_top: bool) -> char {
+        if is_top {
+            self.ltop
+        } else {
+            self.lbot
+        }
+    }
+
+    pub(crate) fn vbar(&self, is_gap: bool) -> char {
+        if is_gap {
+            self.vbar_gap
+        } else {
+            self.vbar
+        }
+    }
 }
 
 /// Output stream to check for whether color is enabled.

src/lib.rs

@@ -267,13 +267,24 @@ pub enum ReportKind<'a> {
     Custom(&'a str, Color),
 }
 
+impl ReportKind<'_> {
+    fn color(&self, config: &Config) -> Option<Color> {
+        match self {
+            ReportKind::Error => config.error_color(),
+            ReportKind::Warning => config.warning_color(),
+            ReportKind::Advice => config.advice_color(),
+            ReportKind::Custom(_, color) => Some(*color),
+        }
+    }
+}
+
 impl fmt::Display for ReportKind<'_> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
             ReportKind::Error => write!(f, "Error"),
             ReportKind::Warning => write!(f, "Warning"),
             ReportKind::Advice => write!(f, "Advice"),
-            ReportKind::Custom(s, _) => write!(f, "{}", s),
+            ReportKind::Custom(s, _) => write!(f, "{s}"),
         }
     }
 }

src/source.rs

@@ -209,7 +209,7 @@ impl<I: AsRef<str>> Source<I> {
     /// Get the line that the given offset appears on, and the line/column numbers of the offset.
     ///
     /// Note that the line/column numbers are zero-indexed.
-    pub fn get_offset_line(&self, offset: usize) -> Option<(Line, usize, usize)> {
+    pub fn get_offset_line(&self, offset: usize) -> Option<Location> {
         if offset <= self.len {
             let idx = self
                 .lines
@@ -222,7 +222,11 @@ impl<I: AsRef<str>> Source<I> {
                 offset,
                 line.offset
             );
-            Some((line, idx, offset - line.offset))
+            Some(Location {
+                line,
+                line_idx: idx,
+                col_idx: offset - line.offset,
+            })
         } else {
             None
         }
@@ -231,7 +235,7 @@ impl<I: AsRef<str>> Source<I> {
     /// Get the line that the given byte offset appears on, and the line/byte column numbers of the offset.
     ///
     /// Note that the line/column numbers are zero-indexed.
-    pub fn get_byte_line(&self, byte_offset: usize) -> Option<(Line, usize, usize)> {
+    pub fn get_byte_line(&self, byte_offset: usize) -> Option<Location> {
         if byte_offset <= self.byte_len {
             let idx = self
                 .lines
@@ -244,7 +248,11 @@ impl<I: AsRef<str>> Source<I> {
                 byte_offset,
                 line.byte_offset
             );
-            Some((line, idx, byte_offset - line.byte_offset))
+            Some(Location {
+                line,
+                line_idx: idx,
+                col_idx: byte_offset - line.byte_offset,
+            })
         } else {
             None
         }
@@ -255,10 +263,12 @@ impl<I: AsRef<str>> Source<I> {
     /// The resulting range is guaranteed to contain valid line indices (i.e: those that can be used for
     /// [`Source::line`]).
     pub fn get_line_range<S: Span>(&self, span: &S) -> Range<usize> {
-        let start = self.get_offset_line(span.start()).map_or(0, |(_, l, _)| l);
+        let start = self
+            .get_offset_line(span.start())
+            .map_or(0, |location| location.line_idx);
         let end = self
             .get_offset_line(span.end().saturating_sub(1).max(span.start()))
-            .map_or(self.lines.len(), |(_, l, _)| l + 1);
+            .map_or(self.lines.len(), |location| location.line_idx + 1);
         start..end
     }
 
@@ -268,6 +278,13 @@ impl<I: AsRef<str>> Source<I> {
     }
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Location {
+    pub line: Line,
+    pub line_idx: usize,
+    pub col_idx: usize,
+}
+
 impl<I: AsRef<str>> Cache<()> for Source<I> {
     type Storage = I;