git.iko.soy/bat
on 5f6e310 help sign in
bat/src/assets.rs
397 lines 13 kB history raw
1use std::collections::BTreeMap;
2use std::ffi::OsStr;
3use std::fs::{self, File};
4use std::io::BufReader;
5use std::path::Path;
7use syntect::dumps::{dump_to_file, from_binary, from_reader};
8use syntect::highlighting::{Theme, ThemeSet};
9use syntect::parsing::{SyntaxReference, SyntaxSet, SyntaxSetBuilder};
11use crate::errors::*;
12use crate::inputfile::{InputFile, InputFileReader};
13use crate::syntax_mapping::{MappingTarget, SyntaxMapping};
15#[derive(Debug)]
16pub struct HighlightingAssets {
17 pub(crate) syntax_set: SyntaxSet,
18 pub(crate) theme_set: ThemeSet,
19 fallback_theme: Option<&'static str>,
22impl HighlightingAssets {
23 pub fn default_theme() -> &'static str {
24 "Monokai Extended"
25 }
27 pub fn from_files(source_dir: &Path, include_integrated_assets: bool) -> Result<Self> {
28 let mut theme_set = if include_integrated_assets {
29 Self::get_integrated_themeset()
30 } else {
31 ThemeSet {
32 themes: BTreeMap::new(),
33 }
34 };
36 let theme_dir = source_dir.join("themes");
38 let res = theme_set.add_from_folder(&theme_dir);
39 if res.is_err() {
40 println!(
41 "No themes were found in '{}', using the default set",
42 theme_dir.to_string_lossy()
43 );
44 }
46 let mut syntax_set_builder = if !include_integrated_assets {
47 let mut builder = SyntaxSetBuilder::new();
48 builder.add_plain_text_syntax();
49 builder
50 } else {
51 Self::get_integrated_syntaxset().into_builder()
52 };
54 let syntax_dir = source_dir.join("syntaxes");
55 if syntax_dir.exists() {
56 syntax_set_builder.add_from_folder(syntax_dir, true)?;
57 } else {
58 println!(
59 "No syntaxes were found in '{}', using the default set.",
60 syntax_dir.to_string_lossy()
61 );
62 }
64 Ok(HighlightingAssets {
65 syntax_set: syntax_set_builder.build(),
66 theme_set,
67 fallback_theme: None,
68 })
69 }
71 pub fn from_cache(theme_set_path: &Path, syntax_set_path: &Path) -> Result<Self> {
72 let syntax_set_file = File::open(syntax_set_path).chain_err(|| {
73 format!(
74 "Could not load cached syntax set '{}'",
75 syntax_set_path.to_string_lossy()
76 )
77 })?;
78 let syntax_set: SyntaxSet = from_reader(BufReader::new(syntax_set_file))
79 .chain_err(|| "Could not parse cached syntax set")?;
81 let theme_set_file = File::open(&theme_set_path).chain_err(|| {
82 format!(
83 "Could not load cached theme set '{}'",
84 theme_set_path.to_string_lossy()
85 )
86 })?;
87 let theme_set: ThemeSet = from_reader(BufReader::new(theme_set_file))
88 .chain_err(|| "Could not parse cached theme set")?;
90 Ok(HighlightingAssets {
91 syntax_set,
92 theme_set,
93 fallback_theme: None,
94 })
95 }
97 fn get_integrated_syntaxset() -> SyntaxSet {
98 from_binary(include_bytes!("../assets/syntaxes.bin"))
99 }
101 fn get_integrated_themeset() -> ThemeSet {
102 from_binary(include_bytes!("../assets/themes.bin"))
103 }
105 pub fn from_binary() -> Self {
106 let syntax_set = Self::get_integrated_syntaxset();
107 let theme_set = Self::get_integrated_themeset();
109 HighlightingAssets {
110 syntax_set,
111 theme_set,
112 fallback_theme: None,
113 }
114 }
116 pub fn save_to_cache(&self, target_dir: &Path) -> Result<()> {
117 let _ = fs::create_dir_all(target_dir);
118 let theme_set_path = target_dir.join("themes.bin");
119 let syntax_set_path = target_dir.join("syntaxes.bin");
121 print!(
122 "Writing theme set to {} ... ",
123 theme_set_path.to_string_lossy()
124 );
125 dump_to_file(&self.theme_set, &theme_set_path).chain_err(|| {
126 format!(
127 "Could not save theme set to {}",
128 theme_set_path.to_string_lossy()
129 )
130 })?;
131 println!("okay");
133 print!(
134 "Writing syntax set to {} ... ",
135 syntax_set_path.to_string_lossy()
136 );
137 dump_to_file(&self.syntax_set, &syntax_set_path).chain_err(|| {
138 format!(
139 "Could not save syntax set to {}",
140 syntax_set_path.to_string_lossy()
141 )
142 })?;
143 println!("okay");
145 Ok(())
146 }
148 pub fn set_fallback_theme(&mut self, theme: &'static str) {
149 self.fallback_theme = Some(theme);
150 }
152 pub fn syntaxes(&self) -> &[SyntaxReference] {
153 self.syntax_set.syntaxes()
154 }
156 pub fn themes(&self) -> impl Iterator<Item = &String> {
157 self.theme_set.themes.keys()
158 }
160 pub(crate) fn get_theme(&self, theme: &str) -> &Theme {
161 match self.theme_set.themes.get(theme) {
162 Some(theme) => theme,
163 None => {
164 if theme != "" {
165 use ansi_term::Colour::Yellow;
166 eprintln!(
167 "{}: Unknown theme '{}', using default.",
168 Yellow.paint("[bat warning]"),
169 theme
170 );
171 }
172 &self.theme_set.themes[self.fallback_theme.unwrap_or(Self::default_theme())]
173 }
174 }
175 }
177 pub(crate) fn get_syntax(
178 &self,
179 language: Option<&str>,
180 file: InputFile,
181 reader: &mut InputFileReader,
182 mapping: &SyntaxMapping,
183 ) -> &SyntaxReference {
184 let syntax = match (language, file) {
185 (Some(language), _) => self.syntax_set.find_syntax_by_token(language),
186 (None, InputFile::Ordinary(ofile)) => {
187 let path = Path::new(ofile.provided_path());
188 let line_syntax = self.get_first_line_syntax(reader);
190 let absolute_path = path.canonicalize().ok().unwrap_or(path.to_owned());
191 match mapping.get_syntax_for(absolute_path) {
192 Some(MappingTarget::MapTo(syntax_name)) => {
193 // TODO: we should probably return an error here if this syntax can not be
194 // found. Currently, we just fall back to 'plain'.
195 self.syntax_set.find_syntax_by_name(syntax_name)
196 }
197 Some(MappingTarget::MapToUnknown) => line_syntax,
198 None => {
199 let file_name = path.file_name().unwrap_or_default();
200 self.get_extension_syntax(file_name).or(line_syntax)
201 }
202 }
203 }
204 (None, InputFile::StdIn(None)) => String::from_utf8(reader.first_line.clone())
205 .ok()
206 .and_then(|l| self.syntax_set.find_syntax_by_first_line(&l)),
207 (None, InputFile::StdIn(Some(file_name))) => self
208 .get_extension_syntax(file_name)
209 .or(self.get_first_line_syntax(reader)),
210 (_, InputFile::ThemePreviewFile) => self.syntax_set.find_syntax_by_name("Rust"),
211 };
213 syntax.unwrap_or_else(|| self.syntax_set.find_syntax_plain_text())
214 }
216 fn get_extension_syntax(&self, file_name: &OsStr) -> Option<&SyntaxReference> {
217 self.syntax_set
218 .find_syntax_by_extension(file_name.to_str().unwrap_or_default())
219 .or_else(|| {
220 self.syntax_set.find_syntax_by_extension(
221 Path::new(file_name)
222 .extension()
223 .and_then(|x| x.to_str())
224 .unwrap_or_default(),
225 )
226 })
227 }
229 fn get_first_line_syntax(&self, reader: &mut InputFileReader) -> Option<&SyntaxReference> {
230 String::from_utf8(reader.first_line.clone())
231 .ok()
232 .and_then(|l| self.syntax_set.find_syntax_by_first_line(&l))
233 }
236#[cfg(test)]
237mod tests {
238 use std::ffi::OsStr;
239 use std::fs::File;
240 use std::io;
241 use std::io::Write;
243 use tempdir::TempDir;
245 use crate::assets::HighlightingAssets;
246 use crate::inputfile::{InputFile, OrdinaryFile};
247 use crate::syntax_mapping::{MappingTarget, SyntaxMapping};
249 struct SyntaxDetectionTest<'a> {
250 assets: HighlightingAssets,
251 pub syntax_mapping: SyntaxMapping<'a>,
252 temp_dir: TempDir,
253 }
255 impl<'a> SyntaxDetectionTest<'a> {
256 fn new() -> Self {
257 SyntaxDetectionTest {
258 assets: HighlightingAssets::from_binary(),
259 syntax_mapping: SyntaxMapping::builtin(),
260 temp_dir: TempDir::new("bat_syntax_detection_tests")
261 .expect("creation of temporary directory"),
262 }
263 }
265 fn syntax_for_file_with_content_os(&self, file_name: &OsStr, first_line: &str) -> String {
266 let file_path = self.temp_dir.path().join(file_name);
267 {
268 let mut temp_file = File::create(&file_path).unwrap();
269 writeln!(temp_file, "{}", first_line).unwrap();
270 }
272 let input_file = InputFile::Ordinary(OrdinaryFile::from_path(file_path.as_os_str()));
273 let syntax = self.assets.get_syntax(
274 None,
275 input_file,
276 &mut input_file.get_reader(io::stdin().lock()).unwrap(),
277 &self.syntax_mapping,
278 );
280 syntax.name.clone()
281 }
283 fn syntax_for_file_os(&self, file_name: &OsStr) -> String {
284 self.syntax_for_file_with_content_os(file_name, "")
285 }
287 fn syntax_for_file_with_content(&self, file_name: &str, first_line: &str) -> String {
288 self.syntax_for_file_with_content_os(OsStr::new(file_name), first_line)
289 }
291 fn syntax_for_file(&self, file_name: &str) -> String {
292 self.syntax_for_file_with_content(file_name, "")
293 }
295 fn syntax_for_stdin_with_content(&self, file_name: &str, content: &[u8]) -> String {
296 let input_file = InputFile::StdIn(Some(OsStr::new(file_name)));
297 let syntax = self.assets.get_syntax(
298 None,
299 input_file,
300 &mut input_file.get_reader(content).unwrap(),
301 &self.syntax_mapping,
302 );
303 syntax.name.clone()
304 }
305 }
307 #[test]
308 fn syntax_detection_basic() {
309 let test = SyntaxDetectionTest::new();
311 assert_eq!(test.syntax_for_file("test.rs"), "Rust");
312 assert_eq!(test.syntax_for_file("test.cpp"), "C++");
313 assert_eq!(test.syntax_for_file("test.build"), "NAnt Build File");
314 assert_eq!(
315 test.syntax_for_file("PKGBUILD"),
316 "Bourne Again Shell (bash)"
317 );
318 assert_eq!(test.syntax_for_file(".bashrc"), "Bourne Again Shell (bash)");
319 assert_eq!(test.syntax_for_file("Makefile"), "Makefile");
320 }
322 #[cfg(unix)]
323 #[test]
324 fn syntax_detection_invalid_utf8() {
325 use std::os::unix::ffi::OsStrExt;
327 let test = SyntaxDetectionTest::new();
329 assert_eq!(
330 test.syntax_for_file_os(OsStr::from_bytes(b"invalid_\xFEutf8_filename.rs")),
331 "Rust"
332 );
333 }
335 #[test]
336 fn syntax_detection_well_defined_mapping_for_duplicate_extensions() {
337 let test = SyntaxDetectionTest::new();
339 assert_eq!(test.syntax_for_file("test.h"), "C++");
340 assert_eq!(test.syntax_for_file("test.sass"), "Sass");
341 assert_eq!(test.syntax_for_file("test.hs"), "Haskell (improved)");
342 assert_eq!(test.syntax_for_file("test.js"), "JavaScript (Babel)");
343 }
345 #[test]
346 fn syntax_detection_first_line() {
347 let test = SyntaxDetectionTest::new();
349 assert_eq!(
350 test.syntax_for_file_with_content("my_script", "#!/bin/bash"),
351 "Bourne Again Shell (bash)"
352 );
353 assert_eq!(
354 test.syntax_for_file_with_content("build", "#!/bin/bash"),
355 "Bourne Again Shell (bash)"
356 );
357 assert_eq!(
358 test.syntax_for_file_with_content("my_script", "<?php"),
359 "PHP"
360 );
361 }
363 #[test]
364 fn syntax_detection_with_custom_mapping() {
365 let mut test = SyntaxDetectionTest::new();
367 assert_eq!(test.syntax_for_file("test.h"), "C++");
368 test.syntax_mapping
369 .insert("*.h", MappingTarget::MapTo("C"))
370 .ok();
371 assert_eq!(test.syntax_for_file("test.h"), "C");
372 }
374 #[test]
375 fn syntax_detection_is_case_sensitive() {
376 let mut test = SyntaxDetectionTest::new();
378 assert_ne!(test.syntax_for_file("README.MD"), "Markdown");
379 test.syntax_mapping
380 .insert("*.MD", MappingTarget::MapTo("Markdown"))
381 .ok();
382 assert_eq!(test.syntax_for_file("README.MD"), "Markdown");
383 }
385 #[test]
386 fn syntax_detection_stdin_filename() {
387 let test = SyntaxDetectionTest::new();
389 // from file extension
390 assert_eq!(test.syntax_for_stdin_with_content("test.cpp", b"a"), "C++");
391 // from first line (fallback)
392 assert_eq!(
393 test.syntax_for_stdin_with_content("my_script", b"#!/bin/bash"),
394 "Bourne Again Shell (bash)"
395 );
396 }