Dehardcode folds

Author: Zibi Braniecki

src/display_list.rs

@@ -92,7 +92,9 @@ pub enum DisplayLine {
         label: Option<String>,
         annotation_type: DisplayAnnotationType,
     },
-    Fold,
+    Fold {
+        inline_marks: Vec<DisplayMark>,
+    },
 }
 
 #[derive(Debug, Clone, PartialEq)]
@@ -156,6 +158,53 @@ fn format_header(snippet: &Snippet, body: &[DisplayLine]) -> Vec<DisplayLine> {
     header
 }
 
+fn fold_body(body: &[DisplayLine]) -> Vec<DisplayLine> {
+    let mut new_body = vec![];
+
+    let mut no_annotation_lines_counter = 0;
+    let mut idx = 0;
+
+    while idx < body.len() {
+        match body[idx] {
+            DisplayLine::Annotation {
+                ref inline_marks, ..
+            } => {
+                if no_annotation_lines_counter > 10 {
+                    let fold_start = idx - no_annotation_lines_counter;
+                    let fold_end = idx;
+                    for i in fold_start..fold_start + 4 {
+                        new_body.push(body[i].clone());
+                    }
+                    new_body.push(DisplayLine::Fold {
+                        inline_marks: inline_marks.clone(),
+                    });
+                    for i in fold_end - 2..fold_end {
+                        new_body.push(body[i].clone());
+                    }
+                } else {
+                    let start = idx - no_annotation_lines_counter;
+                    for i in start..idx {
+                        new_body.push(body[i].clone());
+                    }
+                }
+                no_annotation_lines_counter = 0;
+            }
+            DisplayLine::Source { .. } => {
+                no_annotation_lines_counter += 1;
+                idx += 1;
+                continue;
+            }
+            _ => {
+                no_annotation_lines_counter += 1;
+            }
+        }
+        new_body.push(body[idx].clone());
+        idx += 1;
+    }
+
+    return new_body;
+}
+
 fn format_body(snippet: &Snippet) -> Vec<DisplayLine> {
     let mut body = vec![];
 
@@ -262,27 +311,7 @@ fn format_body(snippet: &Snippet) -> Vec<DisplayLine> {
     }
 
     if snippet.fold.unwrap_or(false) {
-        let mut no_annotation_lines_counter = 0;
-        let mut idx = 0;
-        while idx < body.len() {
-            match body[idx] {
-                DisplayLine::Annotation { .. } => {
-                    if no_annotation_lines_counter > 10 {
-                        let fold_start = idx - no_annotation_lines_counter + 5;
-                        let fold_end = idx - 2;
-                        let fold_len = fold_end - fold_start;
-
-                        let slice = &[DisplayLine::Fold];
-
-                        body.splice(fold_start..fold_end, slice.iter().cloned());
-                        idx -= fold_len - 1;
-                    }
-                    no_annotation_lines_counter += 0;
-                }
-                _ => no_annotation_lines_counter += 1,
-            }
-            idx += 1;
-        }
+        body = fold_body(&body);
     }
 
     body.insert(0, DisplayLine::EmptySource);

src/display_list_formatting.rs

@@ -1,6 +1,5 @@
+use display_list::{DisplayAnnotationType, DisplayLine, DisplayMark, DisplaySnippetType};
 use std::fmt;
-use display_list::{DisplayAnnotationType, DisplayLine, DisplayMark,
-                            DisplaySnippetType};
 
 pub trait DisplayListFormatting {
     fn format_snippet_type(snippet_type: &DisplaySnippetType) -> String;
@@ -54,28 +53,40 @@ pub trait DisplayListFormatting {
         }
     }
 
-    fn format_line(f: &mut fmt::Formatter, dl: &DisplayLine, lineno_width: usize, inline_marks_width: usize) -> fmt::Result {
+    fn format_line(
+        f: &mut fmt::Formatter,
+        dl: &DisplayLine,
+        lineno_width: usize,
+        inline_marks_width: usize,
+    ) -> fmt::Result {
         match dl {
             DisplayLine::Description {
                 snippet_type,
                 id,
                 label,
-            } => writeln!(f,
+            } => writeln!(
+                f,
                 "{}[{}]: {}",
                 Self::format_snippet_type(&snippet_type),
                 id,
                 label
             ),
-            DisplayLine::Origin { path, row, col } => {
-                writeln!(f, "{}--> {}:{}:{}", " ".repeat(lineno_width), path, row, col)
-            }
+            DisplayLine::Origin { path, row, col } => writeln!(
+                f,
+                "{}--> {}:{}:{}",
+                " ".repeat(lineno_width),
+                path,
+                row,
+                col
+            ),
             DisplayLine::EmptySource => writeln!(f, "{} |", " ".repeat(lineno_width)),
             DisplayLine::Source {
                 lineno,
                 inline_marks,
                 content,
                 ..
-            } => writeln!(f,
+            } => writeln!(
+                f,
                 "{:>width$} |{} {}",
                 lineno,
                 Self::format_inline_marks(&inline_marks, inline_marks_width),
@@ -87,13 +98,18 @@ pub trait DisplayListFormatting {
                 range,
                 label,
                 annotation_type,
-            } => writeln!(f,
+            } => writeln!(
+                f,
                 "{} |{}{}",
                 " ".repeat(lineno_width),
                 Self::format_inline_marks(&inline_marks, inline_marks_width),
                 Self::format_annotation_content(range, &label, &annotation_type),
             ),
-            DisplayLine::Fold => writeln!(f, "...  |",),
+            DisplayLine::Fold { inline_marks } => writeln!(
+                f,
+                "... {}",
+                Self::format_inline_marks(&inline_marks, inline_marks_width),
+            ),
         }
     }
 }

src/format.rs

@@ -1,6 +1,6 @@
-use std::fmt;
 use display_list::{DisplayLine, DisplayList, DisplaySnippetType};
 use display_list_formatting::DisplayListFormatting;
+use std::fmt;
 
 struct Formatter {}
 
@@ -37,7 +37,7 @@ impl fmt::Display for DisplayList {
             }
             _ => max,
         });
-        
+
         for line in &self.body {
             Formatter::format_line(f, line, lineno_width, inline_marks_width)?;
         }

src/lib.rs

@@ -25,7 +25,7 @@
 //! In order to produce such output, the user builds a
 //! [Snippet](self::snippet::Snippet) which has a single public method: `format`.
 
-pub mod format;
-pub mod display_list_formatting;
 pub mod display_list;
+pub mod display_list_formatting;
+pub mod format;
 pub mod snippet;