Add -s/--squeeze and --squeeze-limit.

CHANGELOG.md

@@ -3,6 +3,9 @@
 
 ## Features
 
+- `bat --squeeze`/`bat -s` will now squeeze consecutive empty lines, see #1441 (@eth-p)
+- `bat --squeeze-limit` to set the maximum number of empty consecutive when using `--squeeze`, see #1441 (@eth-p)
+
 ## Bugfixes
 
 ## Other
@@ -13,6 +16,8 @@
 
 ## `bat` as a library
 
+- `PrettyPrinter::squeeze_empty_lines` to support line squeezing for bat as a library, see #1441 (@eth-p)
+
 ## Packaging
 
 - `bat` is now available on snapstore with package name called `batcat`, see #1401 (@purveshpatel511)

src/bin/bat/app.rs

@@ -234,6 +234,16 @@ impl App {
                 .map(LineRanges::from)
                 .map(HighlightedLineRanges)
                 .unwrap_or_default(),
+            squeeze_lines: if self.matches.is_present("squeeze") {
+                Some(
+                    self.matches
+                        .value_of("squeeze-limit")
+                        .and_then(|s| s.parse::<usize>().ok())
+                        .unwrap_or(1),
+                )
+            } else {
+                None
+            },
         })
     }
 

src/bin/bat/clap_app.rs

@@ -352,6 +352,21 @@ pub fn build_app(interactive_output: bool) -> ClapApp<'static, 'static> {
                 .help("Display all supported highlighting themes.")
                 .long_help("Display a list of supported themes for syntax highlighting."),
         )
+        .arg(
+            Arg::with_name("squeeze")
+                .long("squeeze")
+                .short("s")
+                .help("Squeeze consecutive empty lines.")
+                .long_help("Squeeze consecutive empty lines into a single empty line.")
+        )
+        .arg(
+            Arg::with_name("squeeze-limit")
+                .long("squeeze-limit")
+                .takes_value(true)
+                .validator(|s| s.parse::<usize>().map(|_| ()).map_err(|_| "Requires a non-negative number".to_owned()))
+                .help("The maximum number of consecutive empty lines.")
+                .long_help("Set the maximum number of consecutive empty lines to be printed.")
+        )
         .arg(
             Arg::with_name("style")
                 .long("style")

src/config.rs

@@ -82,6 +82,9 @@ pub struct Config<'a> {
 
     /// Ranges of lines which should be highlighted with a special background color
     pub highlighted_lines: HighlightedLineRanges,
+
+    /// The maximum number of consecutive empty lines to display
+    pub squeeze_lines: Option<usize>,
 }
 
 #[test]

src/pretty_printer.rs

@@ -258,6 +258,12 @@ impl<'a> PrettyPrinter<'a> {
         self
     }
 
+    /// Specify the maximum number of consecutive empty lines to print.
+    pub fn squeeze_empty_lines(&mut self, maximum: Option<usize>) -> &mut Self {
+        self.config.squeeze_lines = maximum;
+        self
+    }
+
     /// Specify the highlighting theme
     pub fn theme(&mut self, theme: impl AsRef<str>) -> &mut Self {
         self.config.theme = theme.as_ref().to_owned();

src/printer.rs

@@ -114,6 +114,7 @@ pub(crate) struct InteractivePrinter<'a> {
     highlighter: Option<HighlightLines<'a>>,
     syntax_set: &'a SyntaxSet,
     background_color_highlight: Option<Color>,
+    consecutive_empty_lines: usize,
 }
 
 impl<'a> InteractivePrinter<'a> {
@@ -197,6 +198,7 @@ impl<'a> InteractivePrinter<'a> {
             highlighter,
             syntax_set: &assets.syntax_set,
             background_color_highlight,
+            consecutive_empty_lines: 0,
         })
     }
 
@@ -395,6 +397,19 @@ impl<'a> Printer for InteractivePrinter<'a> {
             highlighter.highlight(line.as_ref(), self.syntax_set)
         };
 
+        // Skip squeezed lines.
+        if let Some(squeeze_limit) = self.config.squeeze_lines {
+            if line.trim_end_matches(|c| c == '\r' || c == '\n').is_empty() {
+                self.consecutive_empty_lines += 1;
+                if self.consecutive_empty_lines > squeeze_limit {
+                    return Ok(());
+                }
+            } else {
+                self.consecutive_empty_lines = 0;
+            }
+        }
+
+        // Skip lines that are out of range.
         if out_of_range {
             return Ok(());
         }