Handle all features

Author: zbraniecki

benches/simple.rs

@@ -4,12 +4,13 @@ extern crate criterion;
 use criterion::black_box;
 use criterion::Criterion;
 
-use std::fmt::Write;
-
 use annotate_snippets::DisplayList;
 use annotate_snippets::{Annotation, AnnotationType, SourceAnnotation};
 use annotate_snippets::{Slice, Snippet};
 
+use annotate_snippets::renderers::ascii_default::styles::plain::Style as PlainStyle;
+use annotate_snippets::renderers::ascii_default::Renderer as AsciiRenderer;
+
 const SOURCE: &'static str = r#") -> Option<String> {
 for ann in annotations {
     match (ann.range.0, ann.range.1) {
@@ -59,9 +60,10 @@ fn create_snippet() {
             ],
         }],
     };
+    let r = AsciiRenderer::<PlainStyle>::new();
     let dl: DisplayList = (&snippet).into();
-    let mut result = String::new();
-    write!(result, "{}", dl).unwrap();
+    let mut result: Vec<u8> = Vec::new();
+    r.fmt(&mut result, &dl).unwrap();
 }
 
 pub fn criterion_benchmark(c: &mut Criterion) {

src/display_list/annotation.rs

@@ -1,5 +1,4 @@
 use crate::annotation::AnnotationType;
-use crate::styles::Stylesheet;
 use std::fmt;
 
 #[derive(Debug, Clone)]
@@ -9,17 +8,6 @@ pub struct Annotation<'d> {
     pub label: &'d str,
 }
 
-impl<'d> Annotation<'d> {
-    pub fn fmt_with_style(
-        &self,
-        f: &mut fmt::Formatter<'_>,
-        _style: &impl Stylesheet,
-    ) -> fmt::Result {
-        // style.format(f, &self.annotation_type, self.label)
-        f.write_str(self.label)
-    }
-}
-
 impl fmt::Display for AnnotationType {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {

src/display_list/line.rs

@@ -3,7 +3,6 @@ use std::fmt::Write;
 
 use super::annotation::Annotation;
 use crate::annotation::AnnotationType;
-use crate::styles::{StyleClass, Stylesheet};
 
 #[derive(Debug, Clone)]
 pub enum DisplayLine<'d> {
@@ -15,39 +14,6 @@ pub enum DisplayLine<'d> {
     Raw(DisplayRawLine<'d>),
 }
 
-impl<'d> DisplayLine<'d> {
-    pub fn fmt_with_style(
-        &self,
-        f: &mut fmt::Formatter<'_>,
-        style: &impl Stylesheet,
-        lineno_max: Option<usize>,
-        inline_marks_width: usize,
-    ) -> fmt::Result {
-        let lineno_max = lineno_max.unwrap_or(1);
-        match self {
-            Self::Source {
-                lineno,
-                inline_marks,
-                line,
-            } => {
-                if let Some(lineno) = lineno {
-                    write!(f, "{:>1$}", lineno, lineno_max)?;
-                } else {
-                    write!(f, "{:>1$}", "", lineno_max)?;
-                }
-                f.write_str(" | ")?;
-                write!(f, "{:>1$}", "", inline_marks_width - inline_marks.len())?;
-                for mark in inline_marks {
-                    write!(f, "{}", mark)?;
-                }
-                line.fmt_with_style(f, style)?;
-                f.write_char('\n')
-            }
-            Self::Raw(dl) => dl.fmt_with_style(f, style, lineno_max),
-        }
-    }
-}
-
 #[derive(Debug, Clone)]
 pub enum DisplaySourceLine<'d> {
     Content {
@@ -60,32 +26,6 @@ pub enum DisplaySourceLine<'d> {
     Empty,
 }
 
-impl<'d> DisplaySourceLine<'d> {
-    fn fmt_with_style(&self, f: &mut fmt::Formatter<'_>, style: &impl Stylesheet) -> fmt::Result {
-        match self {
-            Self::Content { text } => {
-                f.write_char(' ')?;
-                f.write_str(text)
-            }
-            Self::Annotation {
-                annotation,
-                range: (start, end),
-            } => {
-                let indent = if start == &0 { 0 } else { start + 1 };
-                write!(f, "{:>1$}", "", indent)?;
-                if start == &0 {
-                    write!(f, "{:_>1$}", "^", end - start + 1)?;
-                } else {
-                    write!(f, "{:->1$}", "", end - start)?;
-                }
-                f.write_char(' ')?;
-                annotation.fmt_with_style(f, style)
-            }
-            Self::Empty => Ok(()),
-        }
-    }
-}
-
 #[derive(Debug, Clone)]
 pub enum DisplayRawLine<'d> {
     Origin {
@@ -99,40 +39,6 @@ pub enum DisplayRawLine<'d> {
     },
 }
 
-impl<'d> DisplayRawLine<'d> {
-    fn fmt_with_style(
-        &self,
-        f: &mut fmt::Formatter<'_>,
-        style: &impl Stylesheet,
-        lineno_max: usize,
-    ) -> fmt::Result {
-        match self {
-            Self::Origin { path, pos } => {
-                write!(f, "{:>1$}", "", lineno_max)?;
-                write!(f, "--> {}", path)?;
-                if let Some(line) = pos.0 {
-                    write!(f, ":{}", line)?;
-                }
-                f.write_char('\n')
-            }
-            Self::Annotation { annotation, .. } => {
-                style.format(
-                    f,
-                    format_args!("{}", annotation.annotation_type),
-                    &[
-                        StyleClass::TitleLineAnnotationType,
-                        StyleClass::AnnotationTypeError,
-                    ],
-                )?;
-                if let Some(id) = annotation.id {
-                    write!(f, "[{}]", id)?;
-                }
-                writeln!(f, ": {}", annotation.label)
-            }
-        }
-    }
-}
-
 #[derive(Debug, Clone)]
 pub struct DisplayMark {
     pub mark_type: DisplayMarkType,

src/display_list/list.rs

@@ -1,44 +1,13 @@
 use super::annotation::Annotation;
 use super::line::{DisplayLine, DisplayMark, DisplayMarkType, DisplayRawLine, DisplaySourceLine};
 use crate::annotation::AnnotationType;
-use crate::styles::{get_stylesheet, Stylesheet};
 use crate::{Slice, Snippet, SourceAnnotation};
-use std::cmp;
-use std::fmt;
 
 #[derive(Debug, Clone)]
 pub struct DisplayList<'d> {
     pub body: Vec<DisplayLine<'d>>,
 }
 
-impl<'d> DisplayList<'d> {
-    pub fn fmt_with_style(
-        &self,
-        f: &mut fmt::Formatter<'_>,
-        style: &impl Stylesheet,
-    ) -> fmt::Result {
-        let lineno_max = self.body.iter().rev().find_map(|line| {
-            if let DisplayLine::Source {
-                lineno: Some(lineno),
-                ..
-            } = line
-            {
-                Some(digits(*lineno))
-            } else {
-                None
-            }
-        });
-        let inline_marks_width = self.body.iter().fold(0, |max, line| match line {
-            DisplayLine::Source { inline_marks, .. } => cmp::max(inline_marks.len(), max),
-            _ => max,
-        });
-        for line in &self.body {
-            line.fmt_with_style(f, style, lineno_max, inline_marks_width)?
-        }
-        Ok(())
-    }
-}
-
 fn get_header_pos(slice: &Slice) -> (Option<usize>, Option<usize>) {
     let line = slice.line_start;
     (line, None)
@@ -181,20 +150,3 @@ impl<'d> From<&Slice<'d>> for DisplayList<'d> {
         DisplayList { body }
     }
 }
-
-fn digits(n: usize) -> usize {
-    let mut n = n;
-    let mut sum = 0;
-    while n != 0 {
-        n /= 10;
-        sum += 1;
-    }
-    sum
-}
-
-impl<'d> fmt::Display for DisplayList<'d> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let style = get_stylesheet();
-        self.fmt_with_style(f, &style)
-    }
-}

src/renderers/ascii_default/mod.rs

@@ -1,55 +1,134 @@
 pub mod styles;
 
 use super::Renderer as RendererTrait;
+use crate::DisplayList;
 use crate::display_list::line::DisplayLine;
 use crate::display_list::line::DisplayRawLine;
-use crate::DisplayList;
+use crate::display_list::line::DisplaySourceLine;
+use crate::display_list::annotation::Annotation;
 use std::io::Write;
 use std::marker::PhantomData;
 use styles::Style as StyleTrait;
+use std::cmp;
+
+fn digits(n: usize) -> usize {
+    let mut n = n;
+    let mut sum = 0;
+    while n != 0 {
+        n /= 10;
+        sum += 1;
+    }
+    sum
+}
 
 pub struct Renderer<S: StyleTrait> {
-    style: PhantomData<S>,
+    style: PhantomData<S>
 }
 
 impl<S: StyleTrait> Renderer<S> {
     pub fn new() -> Self {
-        Renderer { style: PhantomData }
+        Renderer {
+            style: PhantomData
+        }
     }
 
     pub fn fmt(&self, w: &mut impl Write, dl: &DisplayList) -> std::io::Result<()> {
+        let lineno_max = dl.body.iter().rev().find_map(|line| {
+            if let DisplayLine::Source {
+                lineno: Some(lineno),
+                ..
+            } = line
+            {
+                Some(digits(*lineno))
+            } else {
+                None
+            }
+        });
+        let inline_marks_width = dl.body.iter().fold(0, |max, line| match line {
+            DisplayLine::Source { inline_marks, .. } => cmp::max(inline_marks.len(), max),
+            _ => max,
+        });
         for line in &dl.body {
-            self.fmt_line(w, line)?;
+            self.fmt_line(w, line, lineno_max, inline_marks_width)?;
         }
         Ok(())
     }
 
-    fn fmt_line(&self, w: &mut impl Write, line: &DisplayLine) -> std::io::Result<()> {
+    fn fmt_line(&self, w: &mut impl Write, line: &DisplayLine, lineno_max: Option<usize>, inline_marks_width: usize) -> std::io::Result<()> {
+        let lineno_max = lineno_max.unwrap_or(1);
         match line {
-            DisplayLine::Raw(l) => self.fmt_raw_line(w, l),
-            _ => Ok(()),
+            DisplayLine::Source {
+                lineno,
+                inline_marks,
+                line,
+            } => {
+                if let Some(lineno) = lineno {
+                    write!(w, "{:>1$}", lineno, lineno_max)?;
+                } else {
+                    write!(w, "{:>1$}", "", lineno_max)?;
+                }
+                write!(w, " | ")?;
+                write!(w, "{:>1$}", "", inline_marks_width - inline_marks.len())?;
+                for mark in inline_marks {
+                    write!(w, "{}", mark)?;
+                }
+                self.fmt_source_line(w, line)?;
+                //line.fmt_with_style(w, style)?;
+                write!(w, "\n")
+            },
+            DisplayLine::Raw(l) => {
+                self.fmt_raw_line(w, l, lineno_max)
+            },
         }
     }
 
-    fn fmt_raw_line(
-        &self,
-        w: &mut impl std::io::Write,
-        line: &DisplayRawLine,
-    ) -> std::io::Result<()> {
+    fn fmt_source_line(&self, w: &mut impl std::io::Write, line: &DisplaySourceLine) -> std::io::Result<()> {
+      match line {
+          DisplaySourceLine::Content { text } => {
+              write!(w, " {}", text)
+          }
+          DisplaySourceLine::Annotation {
+              annotation,
+              range: (start, end),
+          } => {
+              let indent = if start == &0 { 0 } else { start + 1 };
+              write!(w, "{:>1$}", "", indent)?;
+              if start == &0 {
+                  write!(w, "{:_>1$}", "^", end - start + 1)?;
+              } else {
+                  write!(w, "{:->1$}", "", end - start)?;
+              }
+              write!(w, " ")?;
+              self.fmt_annotation(w, annotation)
+          }
+          DisplaySourceLine::Empty => Ok(()),
+      }
+    }
+
+    fn fmt_raw_line(&self, w: &mut impl std::io::Write, line: &DisplayRawLine, lineno_max: usize) -> 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')
+            DisplayRawLine::Origin { path, pos } => {
+                S::fmt(w, format_args!("{:>1$}", "", lineno_max))?;
+                S::fmt(w, format_args!("--> {}", path))?;
+                if let Some(line) = pos.0 {
+                    S::fmt(w, format_args!(":{}", line))?;
+                }
+                write!(w, "\n")
+            },
+            DisplayRawLine::Annotation { annotation, .. } => {
+                S::fmt(w, format_args!("{}", annotation.annotation_type))?;
+                if let Some(id) = annotation.id {
+                    write!(w, "[{}]", id)?;
+                }
+                writeln!(w, ": {}", annotation.label)
             }
-            _ => Ok(()),
         }
     }
+
+    
+    fn fmt_annotation(&self, w: &mut impl std::io::Write, annotation: &Annotation) -> std::io::Result<()> {
+        write!(w, "{}", annotation.label)
+    }
 }
 
 impl<S: StyleTrait> RendererTrait for Renderer<S> {