git.iko.soy/bat
on 96aedf6 help sign in
bat/src/assets.rs
336 lines 11 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 filename: InputFile,
180 reader: &mut InputFileReader,
181 mapping: &SyntaxMapping,
182 ) -> &SyntaxReference {
183 let syntax = match (language, filename) {
184 (Some(language), _) => self.syntax_set.find_syntax_by_token(language),
185 (None, InputFile::Ordinary(filename)) => {
186 let path = Path::new(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) => String::from_utf8(reader.first_line.clone())
211 .ok()
212 .and_then(|l| self.syntax_set.find_syntax_by_first_line(&l)),
213 (_, InputFile::ThemePreviewFile) => self.syntax_set.find_syntax_by_name("Rust"),
214 };
216 syntax.unwrap_or_else(|| self.syntax_set.find_syntax_plain_text())
217 }
220#[cfg(test)]
221mod tests {
222 use std::ffi::OsStr;
223 use std::fs::File;
224 use std::io;
225 use std::io::Write;
227 use tempdir::TempDir;
229 use crate::assets::HighlightingAssets;
230 use crate::inputfile::InputFile;
231 use crate::syntax_mapping::{MappingTarget, SyntaxMapping};
233 struct SyntaxDetectionTest<'a> {
234 assets: HighlightingAssets,
235 pub syntax_mapping: SyntaxMapping<'a>,
236 temp_dir: TempDir,
237 }
239 impl<'a> SyntaxDetectionTest<'a> {
240 fn new() -> Self {
241 SyntaxDetectionTest {
242 assets: HighlightingAssets::from_binary(),
243 syntax_mapping: SyntaxMapping::builtin(),
244 temp_dir: TempDir::new("bat_syntax_detection_tests")
245 .expect("creation of temporary directory"),
246 }
247 }
249 fn synax_for_file_with_content(&self, file_name: &str, first_line: &str) -> String {
250 let file_path = self.temp_dir.path().join(file_name);
251 {
252 let mut temp_file = File::create(&file_path).unwrap();
253 writeln!(temp_file, "{}", first_line).unwrap();
254 }
256 let input_file = InputFile::Ordinary(OsStr::new(&file_path));
257 let syntax = self.assets.get_syntax(
258 None,
259 input_file,
260 &mut input_file.get_reader(&io::stdin()).unwrap(),
261 &self.syntax_mapping,
262 );
264 syntax.name.clone()
265 }
267 fn syntax_for_file(&self, file_name: &str) -> String {
268 self.synax_for_file_with_content(file_name, "")
269 }
270 }
272 #[test]
273 fn syntax_detection_basic() {
274 let test = SyntaxDetectionTest::new();
276 assert_eq!(test.syntax_for_file("test.rs"), "Rust");
277 assert_eq!(test.syntax_for_file("test.cpp"), "C++");
278 assert_eq!(test.syntax_for_file("test.build"), "NAnt Build File");
279 assert_eq!(
280 test.syntax_for_file("PKGBUILD"),
281 "Bourne Again Shell (bash)"
282 );
283 assert_eq!(test.syntax_for_file(".bashrc"), "Bourne Again Shell (bash)");
284 assert_eq!(test.syntax_for_file("Makefile"), "Makefile");
285 }
287 #[test]
288 fn syntax_detection_well_defined_mapping_for_duplicate_extensions() {
289 let test = SyntaxDetectionTest::new();
291 assert_eq!(test.syntax_for_file("test.h"), "C++");
292 assert_eq!(test.syntax_for_file("test.sass"), "Sass");
293 assert_eq!(test.syntax_for_file("test.hs"), "Haskell (improved)");
294 assert_eq!(test.syntax_for_file("test.js"), "JavaScript (Babel)");
295 }
297 #[test]
298 fn syntax_detection_first_line() {
299 let test = SyntaxDetectionTest::new();
301 assert_eq!(
302 test.synax_for_file_with_content("my_script", "#!/bin/bash"),
303 "Bourne Again Shell (bash)"
304 );
305 assert_eq!(
306 test.synax_for_file_with_content("build", "#!/bin/bash"),
307 "Bourne Again Shell (bash)"
308 );
309 assert_eq!(
310 test.synax_for_file_with_content("my_script", "<?php"),
311 "PHP"
312 );
313 }
315 #[test]
316 fn syntax_detection_with_custom_mapping() {
317 let mut test = SyntaxDetectionTest::new();
319 assert_eq!(test.syntax_for_file("test.h"), "C++");
320 test.syntax_mapping
321 .insert("*.h", MappingTarget::MapTo("C"))
322 .ok();
323 assert_eq!(test.syntax_for_file("test.h"), "C");
324 }
326 #[test]
327 fn syntax_detection_is_case_sensitive() {
328 let mut test = SyntaxDetectionTest::new();
330 assert_ne!(test.syntax_for_file("README.MD"), "Markdown");
331 test.syntax_mapping
332 .insert("*.MD", MappingTarget::MapTo("Markdown"))
333 .ok();
334 assert_eq!(test.syntax_for_file("README.MD"), "Markdown");
335 }