git.iko.soy/bat
on v0.19.0 help sign in
bat/src/syntax_mapping.rs
230 lines 6.8 kB history raw
1use std::path::Path;
3use crate::error::Result;
4use ignored_suffixes::IgnoredSuffixes;
6use globset::{Candidate, GlobBuilder, GlobMatcher};
8pub mod ignored_suffixes;
10#[derive(Debug, Clone, Copy, PartialEq)]
11#[non_exhaustive]
12pub enum MappingTarget<'a> {
13 /// For mapping a path to a specific syntax.
14 MapTo(&'a str),
16 /// For mapping a path (typically an extension-less file name) to an unknown
17 /// syntax. This typically means later using the contents of the first line
18 /// of the file to determine what syntax to use.
19 MapToUnknown,
21 /// For mapping a file extension (e.g. `*.conf`) to an unknown syntax. This
22 /// typically means later using the contents of the first line of the file
23 /// to determine what syntax to use. However, if a syntax handles a file
24 /// name that happens to have the given file extension (e.g. `resolv.conf`),
25 /// then that association will have higher precedence, and the mapping will
26 /// be ignored.
27 MapExtensionToUnknown,
30#[derive(Debug, Clone, Default)]
31pub struct SyntaxMapping<'a> {
32 mappings: Vec<(GlobMatcher, MappingTarget<'a>)>,
33 pub(crate) ignored_suffixes: IgnoredSuffixes<'a>,
36impl<'a> SyntaxMapping<'a> {
37 pub fn empty() -> SyntaxMapping<'a> {
38 Default::default()
39 }
41 pub fn builtin() -> SyntaxMapping<'a> {
42 let mut mapping = Self::empty();
43 mapping.insert("*.h", MappingTarget::MapTo("C++")).unwrap();
44 mapping.insert("*.fs", MappingTarget::MapTo("F#")).unwrap();
45 mapping
46 .insert("build", MappingTarget::MapToUnknown)
47 .unwrap();
48 mapping
49 .insert("**/.ssh/config", MappingTarget::MapTo("SSH Config"))
50 .unwrap();
51 mapping
52 .insert(
53 "**/bat/config",
54 MappingTarget::MapTo("Bourne Again Shell (bash)"),
55 )
56 .unwrap();
57 mapping
58 .insert(
59 "/etc/profile",
60 MappingTarget::MapTo("Bourne Again Shell (bash)"),
61 )
62 .unwrap();
63 mapping
64 .insert("*.pac", MappingTarget::MapTo("JavaScript (Babel)"))
65 .unwrap();
67 // See #1008
68 mapping
69 .insert("rails", MappingTarget::MapToUnknown)
70 .unwrap();
72 // Nginx and Apache syntax files both want to style all ".conf" files
73 // see #1131 and #1137
74 mapping
75 .insert("*.conf", MappingTarget::MapExtensionToUnknown)
76 .unwrap();
78 for glob in &[
79 "/etc/nginx/**/*.conf",
80 "/etc/nginx/sites-*/**/*",
81 "nginx.conf",
82 "mime.types",
83 ] {
84 mapping.insert(glob, MappingTarget::MapTo("nginx")).unwrap();
85 }
87 for glob in &[
88 "/etc/apache2/**/*.conf",
89 "/etc/apache2/sites-*/**/*",
90 "httpd.conf",
91 ] {
92 mapping
93 .insert(glob, MappingTarget::MapTo("Apache Conf"))
94 .unwrap();
95 }
97 for glob in &[
98 "**/systemd/**/*.conf",
99 "**/systemd/**/*.example",
100 "*.automount",
101 "*.device",
102 "*.dnssd",
103 "*.link",
104 "*.mount",
105 "*.netdev",
106 "*.network",
107 "*.nspawn",
108 "*.path",
109 "*.service",
110 "*.scope",
111 "*.slice",
112 "*.socket",
113 "*.swap",
114 "*.target",
115 "*.timer",
116 ] {
117 mapping.insert(glob, MappingTarget::MapTo("INI")).unwrap();
118 }
120 // pacman hooks
121 mapping
122 .insert("*.hook", MappingTarget::MapTo("INI"))
123 .unwrap();
125 if let Some(xdg_config_home) = std::env::var_os("XDG_CONFIG_HOME") {
126 let git_config_path = Path::new(&xdg_config_home).join("git");
128 mapping
129 .insert(
130 &git_config_path.join("config").to_string_lossy(),
131 MappingTarget::MapTo("Git Config"),
132 )
133 .ok();
135 mapping
136 .insert(
137 &git_config_path.join("ignore").to_string_lossy(),
138 MappingTarget::MapTo("Git Ignore"),
139 )
140 .ok();
142 mapping
143 .insert(
144 &git_config_path.join("attributes").to_string_lossy(),
145 MappingTarget::MapTo("Git Attributes"),
146 )
147 .ok();
148 }
150 mapping
151 }
153 pub fn insert(&mut self, from: &str, to: MappingTarget<'a>) -> Result<()> {
154 let glob = GlobBuilder::new(from)
155 .case_insensitive(false)
156 .literal_separator(true)
157 .build()?;
158 self.mappings.push((glob.compile_matcher(), to));
159 Ok(())
160 }
162 pub fn mappings(&self) -> &[(GlobMatcher, MappingTarget<'a>)] {
163 &self.mappings
164 }
166 pub(crate) fn get_syntax_for(&self, path: impl AsRef<Path>) -> Option<MappingTarget<'a>> {
167 let candidate = Candidate::new(&path);
168 let candidate_filename = path.as_ref().file_name().map(Candidate::new);
169 for (ref glob, ref syntax) in self.mappings.iter().rev() {
170 if glob.is_match_candidate(&candidate)
171 || candidate_filename
172 .as_ref()
173 .map_or(false, |filename| glob.is_match_candidate(filename))
174 {
175 return Some(*syntax);
176 }
177 }
178 None
179 }
181 pub fn insert_ignored_suffix(&mut self, suffix: &'a str) {
182 self.ignored_suffixes.add_suffix(suffix);
183 }
186#[test]
187fn basic() {
188 let mut map = SyntaxMapping::empty();
189 map.insert("/path/to/Cargo.lock", MappingTarget::MapTo("TOML"))
190 .ok();
191 map.insert("/path/to/.ignore", MappingTarget::MapTo("Git Ignore"))
192 .ok();
194 assert_eq!(
195 map.get_syntax_for("/path/to/Cargo.lock"),
196 Some(MappingTarget::MapTo("TOML"))
197 );
198 assert_eq!(map.get_syntax_for("/path/to/other.lock"), None);
200 assert_eq!(
201 map.get_syntax_for("/path/to/.ignore"),
202 Some(MappingTarget::MapTo("Git Ignore"))
203 );
206#[test]
207fn user_can_override_builtin_mappings() {
208 let mut map = SyntaxMapping::builtin();
210 assert_eq!(
211 map.get_syntax_for("/etc/profile"),
212 Some(MappingTarget::MapTo("Bourne Again Shell (bash)"))
213 );
214 map.insert("/etc/profile", MappingTarget::MapTo("My Syntax"))
215 .ok();
216 assert_eq!(
217 map.get_syntax_for("/etc/profile"),
218 Some(MappingTarget::MapTo("My Syntax"))
219 );
222#[test]
223fn builtin_mappings() {
224 let map = SyntaxMapping::builtin();
226 assert_eq!(
227 map.get_syntax_for("/path/to/build"),
228 Some(MappingTarget::MapToUnknown)
229 );