git.iko.soy/bat
on 90e7d2f help sign in
bat/src/assets.rs
363 lines 12 kB history raw
1use std::collections::BTreeMap;
2use std::fs::{self, File};
3use std::io::BufReader;
4use std::path::Path;
6use syntect::dumps::{dump_to_file, from_binary, from_reader};
7use syntect::highlighting::{Theme, ThemeSet};
8use syntect::parsing::{SyntaxReference, SyntaxSet, SyntaxSetBuilder};
10use crate::errors::*;
11use crate::inputfile::{InputFile, InputFileReader};
12use crate::syntax_mapping::{MappingTarget, SyntaxMapping};
14#[derive(Debug)]
15pub struct HighlightingAssets {
16 pub(crate) syntax_set: SyntaxSet,
17 pub(crate) theme_set: ThemeSet,
18 fallback_theme: Option<&'static str>,
21impl HighlightingAssets {
22 pub fn default_theme() -> &'static str {
23 "Monokai Extended"
24 }
26 pub fn from_files(source_dir: &Path, include_integrated_assets: bool) -> Result<Self> {
27 let mut theme_set = if include_integrated_assets {
28 Self::get_integrated_themeset()
29 } else {
30 ThemeSet {
31 themes: BTreeMap::new(),
32 }
33 };
35 let theme_dir = source_dir.join("themes");
37 let res = theme_set.add_from_folder(&theme_dir);
38 if res.is_err() {
39 println!(
40 "No themes were found in '{}', using the default set",
41 theme_dir.to_string_lossy()
42 );
43 }
45 let mut syntax_set_builder = if !include_integrated_assets {
46 let mut builder = SyntaxSetBuilder::new();
47 builder.add_plain_text_syntax();
48 builder
49 } else {
50 Self::get_integrated_syntaxset().into_builder()
51 };
53 let syntax_dir = source_dir.join("syntaxes");
54 if syntax_dir.exists() {
55 syntax_set_builder.add_from_folder(syntax_dir, true)?;
56 } else {
57 println!(
58 "No syntaxes were found in '{}', using the default set.",
59 syntax_dir.to_string_lossy()
60 );
61 }
63 Ok(HighlightingAssets {
64 syntax_set: syntax_set_builder.build(),
65 theme_set,
66 fallback_theme: None,
67 })
68 }
70 pub fn from_cache(theme_set_path: &Path, syntax_set_path: &Path) -> Result<Self> {
71 let syntax_set_file = File::open(syntax_set_path).chain_err(|| {
72 format!(
73 "Could not load cached syntax set '{}'",
74 syntax_set_path.to_string_lossy()
75 )
76 })?;
77 let syntax_set: SyntaxSet = from_reader(BufReader::new(syntax_set_file))
78 .chain_err(|| "Could not parse cached syntax set")?;
80 let theme_set_file = File::open(&theme_set_path).chain_err(|| {
81 format!(
82 "Could not load cached theme set '{}'",
83 theme_set_path.to_string_lossy()
84 )
85 })?;
86 let theme_set: ThemeSet = from_reader(BufReader::new(theme_set_file))
87 .chain_err(|| "Could not parse cached theme set")?;
89 Ok(HighlightingAssets {
90 syntax_set,
91 theme_set,
92 fallback_theme: None,
93 })
94 }
96 fn get_integrated_syntaxset() -> SyntaxSet {
97 from_binary(include_bytes!("../assets/syntaxes.bin"))
98 }
100 fn get_integrated_themeset() -> ThemeSet {
101 from_binary(include_bytes!("../assets/themes.bin"))
102 }
104 pub fn from_binary() -> Self {
105 let syntax_set = Self::get_integrated_syntaxset();
106 let theme_set = Self::get_integrated_themeset();
108 HighlightingAssets {
109 syntax_set,
110 theme_set,
111 fallback_theme: None,
112 }
113 }
115 pub fn save_to_cache(&self, target_dir: &Path) -> Result<()> {
116 let _ = fs::create_dir_all(target_dir);
117 let theme_set_path = target_dir.join("themes.bin");
118 let syntax_set_path = target_dir.join("syntaxes.bin");
120 print!(
121 "Writing theme set to {} ... ",
122 theme_set_path.to_string_lossy()
123 );
124 dump_to_file(&self.theme_set, &theme_set_path).chain_err(|| {
125 format!(
126 "Could not save theme set to {}",
127 theme_set_path.to_string_lossy()
128 )
129 })?;
130 println!("okay");
132 print!(
133 "Writing syntax set to {} ... ",
134 syntax_set_path.to_string_lossy()
135 );
136 dump_to_file(&self.syntax_set, &syntax_set_path).chain_err(|| {
137 format!(
138 "Could not save syntax set to {}",
139 syntax_set_path.to_string_lossy()
140 )
141 })?;
142 println!("okay");
144 Ok(())
145 }
147 pub fn set_fallback_theme(&mut self, theme: &'static str) {
148 self.fallback_theme = Some(theme);
149 }
151 pub fn syntaxes(&self) -> &[SyntaxReference] {
152 self.syntax_set.syntaxes()
153 }
155 pub fn themes(&self) -> impl Iterator<Item = &String> {
156 self.theme_set.themes.keys()
157 }
159 pub(crate) fn get_theme(&self, theme: &str) -> &Theme {
160 match self.theme_set.themes.get(theme) {
161 Some(theme) => theme,
162 None => {
163 if theme != "" {
164 use ansi_term::Colour::Yellow;
165 eprintln!(
166 "{}: Unknown theme '{}', using default.",
167 Yellow.paint("[bat warning]"),
168 theme
169 );
170 }
171 &self.theme_set.themes[self.fallback_theme.unwrap_or(Self::default_theme())]
172 }
173 }
174 }
176 pub(crate) fn get_syntax(
177 &self,
178 language: Option<&str>,
179 file: InputFile,
180 reader: &mut InputFileReader,
181 mapping: &SyntaxMapping,
182 ) -> &SyntaxReference {
183 let syntax = match (language, file) {
184 (Some(language), _) => self.syntax_set.find_syntax_by_token(language),
185 (None, InputFile::Ordinary(ofile)) => {
186 let path = Path::new(ofile.filename());
188 let file_name = path.file_name().and_then(|n| n.to_str()).unwrap_or("");
189 let extension = path.extension().and_then(|x| x.to_str()).unwrap_or("");
191 let ext_syntax = self
192 .syntax_set
193 .find_syntax_by_extension(&file_name)
194 .or_else(|| self.syntax_set.find_syntax_by_extension(&extension));
195 let line_syntax = String::from_utf8(reader.first_line.clone())
196 .ok()
197 .and_then(|l| self.syntax_set.find_syntax_by_first_line(&l));
199 let absolute_path = path.canonicalize().ok().unwrap_or(path.to_owned());
200 match mapping.get_syntax_for(absolute_path) {
201 Some(MappingTarget::MapTo(syntax_name)) => {
202 // TODO: we should probably return an error here if this syntax can not be
203 // found. Currently, we just fall back to 'plain'.
204 self.syntax_set.find_syntax_by_name(syntax_name)
205 }
206 Some(MappingTarget::MapToUnknown) => line_syntax,
207 None => ext_syntax.or(line_syntax),
208 }
209 }
210 (None, InputFile::StdIn(None)) => String::from_utf8(reader.first_line.clone())
211 .ok()
212 .and_then(|l| self.syntax_set.find_syntax_by_first_line(&l)),
213 (None, InputFile::StdIn(Some(file_name))) => self
214 .syntax_set
215 .find_syntax_by_extension(file_name.to_str().unwrap())
216 .or_else(|| {
217 self.syntax_set.find_syntax_by_extension(
218 Path::new(file_name)
219 .extension()
220 .and_then(|x| x.to_str())
221 .unwrap_or(""),
222 )
223 })
224 .or(String::from_utf8(reader.first_line.clone())
225 .ok()
226 .and_then(|l| self.syntax_set.find_syntax_by_first_line(&l))),
227 (_, InputFile::ThemePreviewFile) => self.syntax_set.find_syntax_by_name("Rust"),
228 };
230 syntax.unwrap_or_else(|| self.syntax_set.find_syntax_plain_text())
231 }
234#[cfg(test)]
235mod tests {
236 use std::ffi::OsStr;
237 use std::fs::File;
238 use std::io;
239 use std::io::Write;
241 use tempdir::TempDir;
243 use crate::assets::HighlightingAssets;
244 use crate::inputfile::{InputFile, OrdinaryFile};
245 use crate::syntax_mapping::{MappingTarget, SyntaxMapping};
247 struct SyntaxDetectionTest<'a> {
248 assets: HighlightingAssets,
249 pub syntax_mapping: SyntaxMapping<'a>,
250 temp_dir: TempDir,
251 }
253 impl<'a> SyntaxDetectionTest<'a> {
254 fn new() -> Self {
255 SyntaxDetectionTest {
256 assets: HighlightingAssets::from_binary(),
257 syntax_mapping: SyntaxMapping::builtin(),
258 temp_dir: TempDir::new("bat_syntax_detection_tests")
259 .expect("creation of temporary directory"),
260 }
261 }
263 fn syntax_for_file_with_content(&self, file_name: &str, first_line: &str) -> String {
264 let file_path = self.temp_dir.path().join(file_name);
265 {
266 let mut temp_file = File::create(&file_path).unwrap();
267 writeln!(temp_file, "{}", first_line).unwrap();
268 }
270 let input_file = InputFile::Ordinary(OrdinaryFile::from_path(OsStr::new(&file_path)));
271 let syntax = self.assets.get_syntax(
272 None,
273 input_file,
274 &mut input_file.get_reader(&io::stdin()).unwrap(),
275 &self.syntax_mapping,
276 );
278 syntax.name.clone()
279 }
281 fn syntax_for_file(&self, file_name: &str) -> String {
282 self.syntax_for_file_with_content(file_name, "")
283 }
284 }
286 #[test]
287 fn syntax_detection_basic() {
288 let test = SyntaxDetectionTest::new();
290 assert_eq!(test.syntax_for_file("test.rs"), "Rust");
291 assert_eq!(test.syntax_for_file("test.cpp"), "C++");
292 assert_eq!(test.syntax_for_file("test.build"), "NAnt Build File");
293 assert_eq!(
294 test.syntax_for_file("PKGBUILD"),
295 "Bourne Again Shell (bash)"
296 );
297 assert_eq!(test.syntax_for_file(".bashrc"), "Bourne Again Shell (bash)");
298 assert_eq!(test.syntax_for_file("Makefile"), "Makefile");
299 }
301 #[test]
302 fn syntax_detection_well_defined_mapping_for_duplicate_extensions() {
303 let test = SyntaxDetectionTest::new();
305 assert_eq!(test.syntax_for_file("test.h"), "C++");
306 assert_eq!(test.syntax_for_file("test.sass"), "Sass");
307 assert_eq!(test.syntax_for_file("test.hs"), "Haskell (improved)");
308 assert_eq!(test.syntax_for_file("test.js"), "JavaScript (Babel)");
309 }
311 #[test]
312 fn syntax_detection_first_line() {
313 let test = SyntaxDetectionTest::new();
315 assert_eq!(
316 test.syntax_for_file_with_content("my_script", "#!/bin/bash"),
317 "Bourne Again Shell (bash)"
318 );
319 assert_eq!(
320 test.syntax_for_file_with_content("build", "#!/bin/bash"),
321 "Bourne Again Shell (bash)"
322 );
323 assert_eq!(
324 test.syntax_for_file_with_content("my_script", "<?php"),
325 "PHP"
326 );
327 }
329 #[test]
330 fn syntax_detection_with_custom_mapping() {
331 let mut test = SyntaxDetectionTest::new();
333 assert_eq!(test.syntax_for_file("test.h"), "C++");
334 test.syntax_mapping
335 .insert("*.h", MappingTarget::MapTo("C"))
336 .ok();
337 assert_eq!(test.syntax_for_file("test.h"), "C");
338 }
340 #[test]
341 fn syntax_detection_is_case_sensitive() {
342 let mut test = SyntaxDetectionTest::new();
344 assert_ne!(test.syntax_for_file("README.MD"), "Markdown");
345 test.syntax_mapping
346 .insert("*.MD", MappingTarget::MapTo("Markdown"))
347 .ok();
348 assert_eq!(test.syntax_for_file("README.MD"), "Markdown");
349 }
351 #[test]
352 fn syntax_detection_stdin_filename() {
353 let test = SyntaxDetectionTest::new();
355 // from file extension
356 assert_eq!(test.syntax_for_file_with_content("test.cpp", ""), "C++");
357 // from first line (fallback)
358 assert_eq!(
359 test.syntax_for_file_with_content("my_script", "#!/bin/bash"),
360 "Bourne Again Shell (bash)"
361 );
362 }