Add InlineAnnotation

Author: zbraniecki

Diff for: examples/format.rs

@@ -1,5 +1,5 @@
 use annotate_snippets::DisplayList;
-use annotate_snippets::{Annotation, AnnotationType, SourceAnnotation};
+use annotate_snippets::{Annotation, AnnotationType, InlineAnnotation, SourceAnnotation};
 use annotate_snippets::{Slice, Snippet};
 
 use annotate_snippets::renderers::get_renderer;
@@ -52,6 +52,20 @@ fn main() {
                     range: 23..725,
                 },
             ],
+            inline_annotations: &[
+                InlineAnnotation {
+                    annotation_type: AnnotationType::Warning,
+                    range: 5..19,
+                },
+                InlineAnnotation {
+                    annotation_type: AnnotationType::Error,
+                    range: 49..50,
+                },
+                InlineAnnotation {
+                    annotation_type: AnnotationType::Error,
+                    range: 724..725,
+                },
+            ],
         }],
     };
     let dl = DisplayList::from(&snippet);

Diff for: src/annotation.rs

@@ -23,3 +23,9 @@ pub struct SourceAnnotation<'s> {
     pub label: &'s str,
     pub annotation_type: AnnotationType,
 }
+
+#[derive(Debug, Clone)]
+pub struct InlineAnnotation {
+    pub range: Range<usize>,
+    pub annotation_type: AnnotationType,
+}

Diff for: src/display_list/line.rs

@@ -13,10 +13,17 @@ pub enum DisplayLine<'d> {
 }
 
 #[derive(Debug, Clone)]
-pub enum DisplaySourceLine<'d> {
-    Content {
+pub enum DisplayContentElement<'d> {
+    Text(&'d str),
+    AnnotatedText {
         text: &'d str,
+        annotation_type: AnnotationType,
     },
+}
+
+#[derive(Debug, Clone)]
+pub enum DisplaySourceLine<'d> {
+    Content(Vec<DisplayContentElement<'d>>),
     Annotation {
         annotation: Annotation<'d>,
         range: Range<usize>,

Diff for: src/display_list/list.rs

@@ -1,6 +1,9 @@
 use super::annotation::Annotation;
-use super::line::{DisplayLine, DisplayMark, DisplayMarkType, DisplayRawLine, DisplaySourceLine};
-use crate::{Slice, Snippet, SourceAnnotation};
+use super::line::{
+    DisplayContentElement, DisplayLine, DisplayMark, DisplayMarkType, DisplayRawLine,
+    DisplaySourceLine,
+};
+use crate::{InlineAnnotation, Slice, Snippet, SourceAnnotation};
 
 #[derive(Debug, Clone)]
 pub struct DisplayList<'d> {
@@ -55,15 +58,17 @@ impl<'d> From<&Slice<'d>> for DisplayList<'d> {
         });
 
         let mut annotations: Vec<&SourceAnnotation> = slice.annotations.iter().collect();
+        let mut inline_annotations: Vec<&InlineAnnotation> =
+            slice.inline_annotations.iter().collect();
 
-        // let mut current_annotation = annotations.next();
         let mut line_start_pos = 0;
 
         let mut i = slice.line_start.unwrap_or(1);
         for line in slice.source.lines() {
             let line_range = line_start_pos..(line_start_pos + line.chars().count() + 1);
 
             let mut current_annotations = vec![];
+            let mut current_inline_annotations = vec![];
             let mut inline_marks = vec![];
 
             annotations.retain(|ann| {
@@ -100,10 +105,41 @@ impl<'d> From<&Slice<'d>> for DisplayList<'d> {
                 }
             });
 
+            inline_annotations.retain(|ann| {
+                if line_range.contains(&ann.range.start) && line_range.contains(&ann.range.end) {
+                    // Annotation in this line
+                    current_inline_annotations.push(*ann);
+                    false
+                } else {
+                    true
+                }
+            });
+
+            let mut frag = vec![];
+
+            let mut ptr = 0;
+            for ann in current_inline_annotations {
+                if ptr < ann.range.start {
+                    frag.push(DisplayContentElement::Text(
+                        &line[ptr..ann.range.start - line_range.start],
+                    ));
+                }
+                frag.push(DisplayContentElement::AnnotatedText {
+                    text: &line
+                        [(ann.range.start - line_range.start)..(ann.range.end - line_range.start)],
+                    annotation_type: ann.annotation_type.clone(),
+                });
+                ptr = ann.range.end - line_range.start;
+            }
+
+            if ptr < line_range.end {
+                frag.push(DisplayContentElement::Text(&line[ptr..]));
+            }
+
             body.push(DisplayLine::Source {
                 lineno: Some(i),
                 inline_marks,
-                line: DisplaySourceLine::Content { text: line },
+                line: DisplaySourceLine::Content(frag),
             });
             for ann in current_annotations {
                 let start = if ann.range.start >= line_start_pos {

Diff for: src/lib.rs

@@ -4,7 +4,7 @@ pub mod renderers;
 pub mod slice;
 pub mod snippet;
 
-pub use annotation::{Annotation, AnnotationType, SourceAnnotation};
+pub use annotation::{Annotation, AnnotationType, InlineAnnotation, SourceAnnotation};
 pub use display_list::DisplayList;
 pub use slice::Slice;
 pub use snippet::Snippet;

Diff for: src/renderers/ascii_default/mod.rs

@@ -10,6 +10,7 @@ use crate::renderers::ascii_default::styles::plain::Style;
 
 use super::Renderer as RendererTrait;
 use crate::annotation::AnnotationType;
+use crate::display_list::line::DisplayContentElement;
 use crate::display_list::line::DisplayLine;
 use crate::display_list::line::DisplayMark;
 use crate::display_list::line::DisplayMarkType;
@@ -120,7 +121,22 @@ impl<S: StyleTrait> Renderer<S> {
         line: &DisplaySourceLine,
     ) -> std::io::Result<()> {
         match line {
-            DisplaySourceLine::Content { text } => write!(w, " {}", text),
+            DisplaySourceLine::Content(frag) => {
+                write!(w, " ")?;
+                for elem in frag {
+                    match elem {
+                        DisplayContentElement::Text(t) => write!(w, "{}", t)?,
+                        DisplayContentElement::AnnotatedText {
+                            text,
+                            annotation_type,
+                        } => {
+                            let (_, style) = self.get_annotation_type_style(&annotation_type);
+                            S::fmt(w, text, &[StyleType::Emphasis, style])?
+                        }
+                    }
+                }
+                Ok(())
+            }
             DisplaySourceLine::Annotation { annotation, range } => {
                 let (_, style) = self.get_annotation_type_style(&annotation.annotation_type);
                 let styles = [StyleType::Emphasis, style];

Diff for: src/slice.rs

@@ -1,9 +1,10 @@
-use crate::annotation::SourceAnnotation;
+use crate::annotation::{InlineAnnotation, SourceAnnotation};
 
 #[derive(Debug, Clone, Default)]
 pub struct Slice<'s> {
     pub source: &'s str,
     pub line_start: Option<usize>,
     pub origin: Option<&'s str>,
     pub annotations: &'s [SourceAnnotation<'s>],
+    pub inline_annotations: &'s [InlineAnnotation],
 }