Support for ignored-suffix CLI arguments

src/assets.rs

@@ -11,10 +11,10 @@ use path_abs::PathAbs;
 
 use crate::bat_warning;
 use crate::error::*;
+use crate::ignored_suffixes::IgnoredSuffixes;
 use crate::input::{InputReader, OpenedInput};
 use crate::syntax_mapping::{MappingTarget, SyntaxMapping};
 
-use ignored_suffixes::*;
 use minimal_assets::*;
 use serialized_syntax_set::*;
 
@@ -24,7 +24,6 @@ pub use crate::assets::build_assets::*;
 pub(crate) mod assets_metadata;
 #[cfg(feature = "build-assets")]
 mod build_assets;
-mod ignored_suffixes;
 mod minimal_assets;
 mod serialized_syntax_set;
 
@@ -37,6 +36,7 @@ pub struct HighlightingAssets {
 
     theme_set: ThemeSet,
     fallback_theme: Option<&'static str>,
+    ignored_suffixes: IgnoredSuffixes,
 }
 
 #[derive(Debug)]
@@ -67,21 +67,23 @@ impl HighlightingAssets {
         serialized_syntax_set: SerializedSyntaxSet,
         minimal_syntaxes: MinimalSyntaxes,
         theme_set: ThemeSet,
+        ignored_suffixes: IgnoredSuffixes,
     ) -> Self {
         HighlightingAssets {
             syntax_set_cell: LazyCell::new(),
             serialized_syntax_set,
             minimal_assets: MinimalAssets::new(minimal_syntaxes),
             theme_set,
             fallback_theme: None,
+            ignored_suffixes,
         }
     }
 
     pub fn default_theme() -> &'static str {
         "Monokai Extended"
     }
 
-    pub fn from_cache(cache_path: &Path) -> Result<Self> {
+    pub fn from_cache(cache_path: &Path, ignored_suffixes: IgnoredSuffixes) -> Result<Self> {
         Ok(HighlightingAssets::new(
             SerializedSyntaxSet::FromFile(cache_path.join("syntaxes.bin")),
             asset_from_cache(
@@ -90,14 +92,16 @@ impl HighlightingAssets {
                 COMPRESS_MINIMAL_SYNTAXES,
             )?,
             asset_from_cache(&cache_path.join("themes.bin"), "theme set", COMPRESS_THEMES)?,
+            ignored_suffixes,
         ))
     }
 
-    pub fn from_binary() -> Self {
+    pub fn from_binary(ignored_suffixes: IgnoredSuffixes) -> Self {
         HighlightingAssets::new(
             SerializedSyntaxSet::FromBinary(get_serialized_integrated_syntaxset()),
             get_integrated_minimal_syntaxes(),
             get_integrated_themeset(),
+            ignored_suffixes,
         )
     }
 
@@ -269,9 +273,12 @@ impl HighlightingAssets {
             syntax = self.find_syntax_by_extension(Path::new(file_name).extension())?;
         }
         if syntax.is_none() {
-            syntax = try_with_stripped_suffix(file_name, |stripped_file_name| {
-                self.get_extension_syntax(stripped_file_name) // Note: recursion
-            })?;
+            syntax = self.ignored_suffixes.try_with_stripped_suffix(
+                file_name,
+                |stripped_file_name| {
+                    self.get_extension_syntax(stripped_file_name) // Note: recursion
+                },
+            )?;
         }
         Ok(syntax)
     }
@@ -358,7 +365,7 @@ mod tests {
     impl<'a> SyntaxDetectionTest<'a> {
         fn new() -> Self {
             SyntaxDetectionTest {
-                assets: HighlightingAssets::from_binary(),
+                assets: HighlightingAssets::from_binary(IgnoredSuffixes::default()),
                 syntax_mapping: SyntaxMapping::builtin(),
                 temp_dir: TempDir::new().expect("creation of temporary directory"),
             }

src/bin/bat/app.rs

@@ -235,6 +235,12 @@ impl App {
                 .map(HighlightedLineRanges)
                 .unwrap_or_default(),
             use_custom_assets: !self.matches.is_present("no-custom-assets"),
+            ignored_suffixes: self
+                .matches
+                .values_of("ignored-suffix")
+                .unwrap_or_default()
+                .map(String::from)
+                .collect(),
         })
     }
 

src/bin/bat/assets.rs

@@ -1,6 +1,8 @@
 use std::borrow::Cow;
 use std::fs;
 
+use bat::config::Config;
+use bat::ignored_suffixes::IgnoredSuffixes;
 use clap::crate_version;
 
 use crate::directories::PROJECT_DIRS;
@@ -24,7 +26,7 @@ pub fn clear_assets() {
     clear_asset("metadata.yaml", "metadata file");
 }
 
-pub fn assets_from_cache_or_binary(use_custom_assets: bool) -> Result<HighlightingAssets> {
+pub fn assets_from_cache_or_binary(config: &Config) -> Result<HighlightingAssets> {
     let cache_dir = PROJECT_DIRS.cache_dir();
     if let Some(metadata) = AssetsMetadata::load_from_folder(cache_dir)? {
         if !metadata.is_compatible_with(crate_version!()) {
@@ -42,12 +44,13 @@ pub fn assets_from_cache_or_binary(use_custom_assets: bool) -> Result<Highlighti
         }
     }
 
-    let custom_assets = if use_custom_assets {
-        HighlightingAssets::from_cache(cache_dir).ok()
+    let ignored_suffixes = IgnoredSuffixes::new(config.ignored_suffixes.clone());
+    let custom_assets = if config.use_custom_assets {
+        HighlightingAssets::from_cache(cache_dir, ignored_suffixes.clone()).ok()
     } else {
         None
     };
-    Ok(custom_assets.unwrap_or_else(HighlightingAssets::from_binary))
+    Ok(custom_assets.unwrap_or_else(|| HighlightingAssets::from_binary(ignored_suffixes.clone())))
 }
 
 fn clear_asset(filename: &str, description: &str) {

src/bin/bat/clap_app.rs

@@ -494,6 +494,17 @@ pub fn build_app(interactive_output: bool) -> ClapApp<'static, 'static> {
                 .hidden_short_help(true)
                 .help("Show diagnostic information for bug reports.")
         )
+        .arg(
+            Arg::with_name("ignored-suffix")
+                .number_of_values(1)
+                .multiple(true)
+                .takes_value(true)
+                .long("ignored-suffix")
+                .help(
+                    "Ignore extension. For example:\n  \
+                    'bat --ignored-suffix \".dev\" my_file.json.dev' will use JSON syntax, and ignore '.dev'"
+                )
+        )
         .help_message("Print this help message.")
         .version_message("Show version information.");
 

src/bin/bat/main.rs

@@ -84,7 +84,7 @@ fn get_syntax_mapping_to_paths<'a>(
 pub fn get_languages(config: &Config) -> Result<String> {
     let mut result: String = String::new();
 
-    let assets = assets_from_cache_or_binary(config.use_custom_assets)?;
+    let assets = assets_from_cache_or_binary(config)?;
     let mut languages = assets
         .get_syntaxes()?
         .iter()
@@ -177,7 +177,7 @@ fn theme_preview_file<'a>() -> Input<'a> {
 }
 
 pub fn list_themes(cfg: &Config) -> Result<()> {
-    let assets = assets_from_cache_or_binary(cfg.use_custom_assets)?;
+    let assets = assets_from_cache_or_binary(cfg)?;
     let mut config = cfg.clone();
     let mut style = HashSet::new();
     style.insert(StyleComponent::Plain);
@@ -218,7 +218,7 @@ pub fn list_themes(cfg: &Config) -> Result<()> {
 }
 
 fn run_controller(inputs: Vec<Input>, config: &Config) -> Result<bool> {
-    let assets = assets_from_cache_or_binary(config.use_custom_assets)?;
+    let assets = assets_from_cache_or_binary(config)?;
     let controller = Controller::new(config, &assets);
     controller.run(inputs)
 }

src/config.rs

@@ -86,6 +86,9 @@ pub struct Config<'a> {
     /// Whether or not to allow custom assets. If this is false or if custom assets (a.k.a.
     /// cached assets) are not available, assets from the binary will be used instead.
     pub use_custom_assets: bool,
+
+    /// Ignored suffixes
+    pub ignored_suffixes: Vec<String>,
 }
 
 #[cfg(all(feature = "minimal-application", feature = "paging"))]

src/ignored_suffixes.rs

@@ -0,0 +1,104 @@
+use std::ffi::OsStr;
+use std::path::Path;
+
+use crate::error::*;
+
+const IGNORED_SUFFIXES: [&str; 13] = [
+    // Editor etc backups
+    "~",
+    ".bak",
+    ".old",
+    ".orig",
+    // Debian and derivatives apt/dpkg/ucf backups
+    ".dpkg-dist",
+    ".dpkg-old",
+    ".ucf-dist",
+    ".ucf-new",
+    ".ucf-old",
+    // Red Hat and derivatives rpm backups
+    ".rpmnew",
+    ".rpmorig",
+    ".rpmsave",
+    // Build system input/template files
+    ".in",
+];
+
+#[derive(Debug, Clone, Default)]
+pub struct IgnoredSuffixes {
+    values: Vec<String>,
+}
+
+impl IgnoredSuffixes {
+    pub fn new(values: Vec<String>) -> Self {
+        IgnoredSuffixes { values }
+    }
+
+    /// If we find an ignored suffix on the file name, e.g. '~', we strip it and
+    /// then try again without it.
+    pub fn try_with_stripped_suffix<'a, T, F>(
+        &self,
+        file_name: &'a OsStr,
+        func: F,
+    ) -> Result<Option<T>>
+    where
+        F: Fn(&'a OsStr) -> Result<Option<T>>,
+    {
+        let mut from_stripped = None;
+        if let Some(file_str) = Path::new(file_name).to_str() {
+            for suffix in self
+                .values
+                .iter()
+                .map(|v| v.as_str())
+                .chain(IGNORED_SUFFIXES.iter().map(|v| *v))
+            {
+                if let Some(stripped_filename) = file_str.strip_suffix(suffix) {
+                    from_stripped = func(OsStr::new(stripped_filename))?;
+                    break;
+                }
+            }
+        }
+        Ok(from_stripped)
+    }
+}
+
+#[test]
+fn internal_suffixes() {
+    let ignored_suffixes = IgnoredSuffixes::new(vec![]);
+
+    let file_names = IGNORED_SUFFIXES
+        .iter()
+        .map(|suffix| format!("test.json{}", suffix));
+    for file_name_str in file_names {
+        let file_name = OsStr::new(&file_name_str);
+        let expected_stripped_file_name = OsStr::new("test.json");
+        let stripped_file_name = ignored_suffixes
+            .try_with_stripped_suffix(file_name, |stripped_file_name| Ok(Some(stripped_file_name)));
+        assert_eq!(
+            expected_stripped_file_name,
+            stripped_file_name.unwrap().unwrap()
+        );
+    }
+}
+
+#[test]
+fn external_suffixes() {
+    let ignored_suffixes = IgnoredSuffixes::new(vec![
+        String::from(".development"),
+        String::from(".production"),
+    ]);
+
+    let file_names = ignored_suffixes
+        .values
+        .iter()
+        .map(|suffix| format!("test.json{}", suffix));
+    for file_name_str in file_names {
+        let file_name = OsStr::new(&file_name_str);
+        let expected_stripped_file_name = OsStr::new("test.json");
+        let stripped_file_name = ignored_suffixes
+            .try_with_stripped_suffix(file_name, |stripped_file_name| Ok(Some(stripped_file_name)));
+        assert_eq!(
+            expected_stripped_file_name,
+            stripped_file_name.unwrap().unwrap()
+        );
+    }
+}

src/lib.rs

@@ -32,6 +32,7 @@ pub mod controller;
 mod decorations;
 mod diff;
 pub mod error;
+pub mod ignored_suffixes;
 pub mod input;
 mod less;
 pub mod line_range;

src/pretty_printer.rs

@@ -9,6 +9,7 @@ use crate::{
     config::{Config, VisibleLines},
     controller::Controller,
     error::Result,
+    ignored_suffixes::IgnoredSuffixes,
     input,
     line_range::{HighlightedLineRanges, LineRange, LineRanges},
     style::{StyleComponent, StyleComponents},
@@ -49,7 +50,7 @@ impl<'a> PrettyPrinter<'a> {
         PrettyPrinter {
             inputs: vec![],
             config,
-            assets: HighlightingAssets::from_binary(),
+            assets: HighlightingAssets::from_binary(IgnoredSuffixes::default()),
 
             highlighted_lines: vec![],
             term_width: None,

tests/assets.rs

@@ -1,11 +1,11 @@
-use bat::assets::HighlightingAssets;
+use bat::{assets::HighlightingAssets, ignored_suffixes::IgnoredSuffixes};
 
 /// This test ensures that we are not accidentally removing themes due to submodule updates.
 /// It is 'ignore'd by default because it requires themes.bin to be up-to-date.
 #[test]
 #[ignore]
 fn all_themes_are_present() {
-    let assets = HighlightingAssets::from_binary();
+    let assets = HighlightingAssets::from_binary(IgnoredSuffixes::default());
 
     let mut themes: Vec<_> = assets.themes().collect();
     themes.sort_unstable();