Add renderer and styles

Author: zbraniecki

Cargo.toml

@@ -8,13 +8,15 @@ edition = "2018"
 
 [dependencies]
 ansi_term = { version = "0.12", optional = true }
+termcolor = { version = "1", optional = true }
 
 [dev-dependencies]
 criterion = "0.3"
 
 [features]
 default = []
 color = ["ansi_term"]
+color2 = ["termcolor"]
 
 [[bench]]
 name = "simple"

examples/format.rs

@@ -1,3 +1,11 @@
+#[cfg(feature = "ansi_term")]
+use annotate_snippets::renderers::ascii_default::styles::color::Style as ColorStyle;
+#[cfg(feature = "termcolor")]
+use annotate_snippets::renderers::ascii_default::styles::color2::Style as ColorStyle;
+#[cfg(all(not(feature = "ansi_term"), not(feature = "termcolor")))]
+use annotate_snippets::renderers::ascii_default::styles::plain::Style as PlainStyle;
+use annotate_snippets::renderers::ascii_default::Renderer as AsciiRenderer;
+use annotate_snippets::DisplayList;
 use annotate_snippets::{Annotation, AnnotationType, SourceAnnotation};
 use annotate_snippets::{Slice, Snippet};
 
@@ -50,5 +58,15 @@ fn main() {
             ],
         }],
     };
-    println!("{}", snippet);
+    let dl = DisplayList::from(&snippet);
+
+    #[cfg(all(not(feature = "ansi_term"), not(feature = "termcolor")))]
+    let r = AsciiRenderer::<PlainStyle>::new();
+    #[cfg(feature = "ansi_term")]
+    let r = AsciiRenderer::<ColorStyle>::new();
+    #[cfg(feature = "termcolor")]
+    let r = AsciiRenderer::<ColorStyle>::new();
+    let mut s: Vec<u8> = Vec::new();
+    r.fmt(&mut s, &dl).unwrap();
+    println!("{}", std::str::from_utf8(&s).unwrap());
 }

src/display_list/line.rs

@@ -118,11 +118,11 @@ impl<'d> DisplayRawLine<'d> {
             Self::Annotation { annotation, .. } => {
                 style.format(
                     f,
+                    format_args!("{}", annotation.annotation_type),
                     &[
                         StyleClass::TitleLineAnnotationType,
                         StyleClass::AnnotationTypeError,
                     ],
-                    &annotation.annotation_type,
                 )?;
                 if let Some(id) = annotation.id {
                     write!(f, "[{}]", id)?;

src/display_list/mod.rs

@@ -1,5 +1,5 @@
-mod annotation;
-mod line;
-mod list;
+pub mod annotation;
+pub mod line;
+pub mod list;
 
 pub use list::DisplayList;

src/lib.rs

@@ -1,5 +1,6 @@
 pub mod annotation;
 mod display_list;
+pub mod renderers;
 pub mod slice;
 pub mod snippet;
 pub mod styles;

src/renderers/ascii_default/mod.rs

@@ -0,0 +1,59 @@
+pub mod styles;
+
+use super::Renderer as RendererTrait;
+use crate::display_list::line::DisplayLine;
+use crate::display_list::line::DisplayRawLine;
+use crate::DisplayList;
+use std::io::Write;
+use std::marker::PhantomData;
+use styles::Style as StyleTrait;
+
+pub struct Renderer<S: StyleTrait> {
+    style: PhantomData<S>,
+}
+
+impl<S: StyleTrait> Renderer<S> {
+    pub fn new() -> Self {
+        Renderer { style: PhantomData }
+    }
+
+    pub fn fmt(&self, w: &mut impl Write, dl: &DisplayList) -> std::io::Result<()> {
+        for line in &dl.body {
+            self.fmt_line(w, line)?;
+        }
+        Ok(())
+    }
+
+    fn fmt_line(&self, w: &mut impl Write, line: &DisplayLine) -> std::io::Result<()> {
+        match line {
+            DisplayLine::Raw(l) => self.fmt_raw_line(w, l),
+            _ => Ok(()),
+        }
+    }
+
+    fn fmt_raw_line(
+        &self,
+        w: &mut impl std::io::Write,
+        line: &DisplayRawLine,
+    ) -> std::io::Result<()> {
+        match line {
+            DisplayRawLine::Origin { path, .. } => {
+                let _lineno_max = 1;
+                S::fmt(w, path)
+                //write!(w, "{:>1$}", "", lineno_max)?;
+                //write!(w, "--> {}", path)?;
+                //if let Some(line) = pos.0 {
+                //write!(w, ":{}", line)?;
+                //}
+                //w.write_char('\n')
+            }
+            _ => Ok(()),
+        }
+    }
+}
+
+impl<S: StyleTrait> RendererTrait for Renderer<S> {
+    fn fmt(&self, w: &mut impl Write, dl: &DisplayList) -> std::io::Result<()> {
+        Renderer::fmt(self, w, dl)
+    }
+}

src/renderers/ascii_default/styles/color.rs

@@ -0,0 +1,14 @@
+use ansi_term::Style as AnsiTermStyle;
+
+use super::Style as StyleTrait;
+
+use std::fmt;
+
+pub struct Style {}
+
+impl StyleTrait for Style {
+    fn fmt(w: &mut dyn fmt::Write, pattern: impl fmt::Display) -> fmt::Result<()> {
+        let style = AnsiTermStyle::new().bold();
+        write!(w, "{}", style.paint(pattern.to_string()))
+    }
+}

src/renderers/ascii_default/styles/color2.rs

@@ -0,0 +1,18 @@
+use termcolor::{Ansi, ColorSpec, WriteColor};
+
+use super::Style as StyleTrait;
+
+use std::fmt;
+use std::io::Write;
+
+pub struct Style {}
+
+impl StyleTrait for Style {
+    fn fmt(w: &mut dyn std::io::Write, pattern: impl fmt::Display) -> std::io::Result<()> {
+        let mut ansi = Ansi::new(w);
+        ansi.set_color(ColorSpec::new().set_bold(true)).unwrap();
+        write!(ansi, "{}", pattern)?;
+        ansi.reset().unwrap();
+        Ok(())
+    }
+}

src/renderers/ascii_default/styles/mod.rs

@@ -0,0 +1,11 @@
+#[cfg(feature = "ansi_term")]
+pub mod color;
+#[cfg(feature = "termcolor")]
+pub mod color2;
+pub mod plain;
+
+use std::fmt;
+
+pub trait Style {
+    fn fmt(w: &mut dyn std::io::Write, pattern: impl fmt::Display) -> std::io::Result<()>;
+}

src/renderers/ascii_default/styles/plain.rs

@@ -0,0 +1,11 @@
+use super::Style as StyleTrait;
+
+use std::fmt;
+
+pub struct Style {}
+
+impl StyleTrait for Style {
+    fn fmt(w: &mut dyn std::io::Write, pattern: impl fmt::Display) -> std::io::Result<()> {
+        write!(w, "{}", pattern)
+    }
+}