use std::fs;
use std::path::{Path, PathBuf};
use rustik_highlight as syntax;
use crate::{BuiltinHighlighter, DiffDocument, DiffPalette};
const THEME_NAME: &str = "rustik-catppuccin-mocha";
const THEME: &str = include_str!("themes/rustik-catppuccin-mocha.json");
const CUSTOM_SYNTAX_DIR: &str = "rustik/highlight/grammars";
const SYNTAXES: [SyntaxAsset; 20] = [
SyntaxAsset {
source: syntax::syntaxes::C,
file_types: &["c", "h"],
dependencies: &[],
},
SyntaxAsset {
source: syntax::syntaxes::CSS,
file_types: &["css"],
dependencies: &[],
},
SyntaxAsset {
source: syntax::syntaxes::ERB,
file_types: &["erb", "rhtml", "html.erb"],
dependencies: &[
syntax::syntaxes::HTML,
syntax::syntaxes::RUBY,
syntax::syntaxes::CSS,
syntax::syntaxes::JAVASCRIPT,
],
},
SyntaxAsset {
source: syntax::syntaxes::FISH,
file_types: &["fish"],
dependencies: &[],
},
SyntaxAsset {
source: syntax::syntaxes::GO,
file_types: &["go"],
dependencies: &[],
},
SyntaxAsset {
source: syntax::syntaxes::HTML,
file_types: &["html", "htm", "xhtml"],
dependencies: &[syntax::syntaxes::CSS, syntax::syntaxes::JAVASCRIPT],
},
SyntaxAsset {
source: syntax::syntaxes::JAVASCRIPT,
file_types: &["js", "cjs", "mjs"],
dependencies: &[],
},
SyntaxAsset {
source: syntax::syntaxes::LUA,
file_types: &["lua"],
dependencies: &[],
},
SyntaxAsset {
source: syntax::syntaxes::MAKE,
file_types: &["makefile", "mk"],
dependencies: &[],
},
SyntaxAsset {
source: syntax::syntaxes::MARKDOWN,
file_types: &["md", "markdown", "mdown"],
dependencies: &[
syntax::syntaxes::YAML,
syntax::syntaxes::HTML,
syntax::syntaxes::CSS,
syntax::syntaxes::JAVASCRIPT,
syntax::syntaxes::LUA,
syntax::syntaxes::TSX,
],
},
SyntaxAsset {
source: syntax::syntaxes::PYTHON,
file_types: &["py", "pyw"],
dependencies: &[],
},
SyntaxAsset {
source: syntax::syntaxes::RUBY,
file_types: &["rb", "rake", "gemspec"],
dependencies: &[],
},
SyntaxAsset {
source: syntax::syntaxes::RUST,
file_types: &["rs"],
dependencies: &[],
},
SyntaxAsset {
source: syntax::syntaxes::SHELL,
file_types: &["sh", "bash", "zsh"],
dependencies: &[],
},
SyntaxAsset {
source: syntax::syntaxes::SQL,
file_types: &["sql"],
dependencies: &[],
},
SyntaxAsset {
source: syntax::syntaxes::TOML,
file_types: &["toml"],
dependencies: &[],
},
SyntaxAsset {
source: syntax::syntaxes::TYPESCRIPT,
file_types: &["ts", "cts", "mts"],
dependencies: &[],
},
SyntaxAsset {
source: syntax::syntaxes::TSX,
file_types: &["tsx"],
dependencies: &[],
},
SyntaxAsset {
source: syntax::syntaxes::XML,
file_types: &["svg", "xml"],
dependencies: &[],
},
SyntaxAsset {
source: syntax::syntaxes::YAML,
file_types: &["yaml", "yml"],
dependencies: &[],
},
];
pub struct Builtins {
pub palette: DiffPalette,
}
impl Builtins {
pub fn load() -> Result<Self, syntax::Error> {
let raw_theme = THEME.parse::<syntax::RawTheme>()?;
Ok(Self {
palette: (&raw_theme).into(),
})
}
pub fn highlighter(document: &DiffDocument) -> Result<BuiltinHighlighter, syntax::Error> {
Self::highlighter_for_paths(&Self::document_paths(document))
}
pub(crate) fn highlighter_for_paths(
paths: &[PathBuf],
) -> Result<BuiltinHighlighter, syntax::Error> {
let raw_theme = THEME.parse::<syntax::RawTheme>()?;
let mut registry = syntax::Registry::default();
registry.add_theme(syntax::Theme::compile(&raw_theme));
for syntax in SYNTAXES
.iter()
.filter(|syntax| paths.iter().any(|path| syntax.matches_path(path)))
{
registry.add_grammar(syntax.grammar()?);
}
for grammar in custom_grammars() {
registry.add_grammar(grammar);
}
Ok(BuiltinHighlighter::new(registry, THEME_NAME))
}
pub(crate) fn document_paths(document: &DiffDocument) -> Vec<PathBuf> {
document
.files
.iter()
.flat_map(|file| [&file.header.old_path, &file.header.new_path])
.flatten()
.cloned()
.collect()
}
pub fn load_head_grammars(
highlighter: &mut BuiltinHighlighter,
head: &str,
) -> Result<(), syntax::Error> {
if !head.starts_with("#!") {
return Ok(());
}
for syntax in &SYNTAXES {
if let Some(grammar) = syntax.head_grammar(head)? {
highlighter.ensure_grammar(grammar);
}
}
Ok(())
}
}
fn custom_grammars() -> Vec<syntax::Grammar> {
let Some(directory) = config_dir().map(|directory| directory.join(CUSTOM_SYNTAX_DIR)) else {
return Vec::new();
};
let Ok(entries) = fs::read_dir(directory) else {
return Vec::new();
};
let paths = entries
.flatten()
.map(|entry| entry.path())
.filter(|path| {
path.extension()
.and_then(|extension| extension.to_str())
.is_some_and(|extension| extension.eq_ignore_ascii_case("json"))
})
.collect::<Vec<_>>();
let raw = paths
.iter()
.filter_map(|path| fs::read_to_string(path).ok())
.filter_map(|source| source.parse::<syntax::RawGrammar>().ok())
.collect::<Vec<_>>();
raw.iter()
.filter_map(|grammar| syntax::Grammar::compile_with(grammar, &raw).ok())
.collect()
}
fn config_dir() -> Option<PathBuf> {
std::env::var_os("XDG_CONFIG_HOME")
.map(PathBuf::from)
.or_else(|| Some(PathBuf::from(std::env::var_os("HOME")?).join(".config")))
}
struct SyntaxAsset {
source: &'static str,
file_types: &'static [&'static str],
dependencies: &'static [&'static str],
}
impl SyntaxAsset {
fn matches_path(&self, path: &Path) -> bool {
let file_name = path.file_name().and_then(|name| name.to_str());
let extension = path.extension().and_then(|extension| extension.to_str());
self.file_types.iter().any(|file_type| {
file_name.is_some_and(|name| name.eq_ignore_ascii_case(file_type))
|| extension.is_some_and(|extension| extension.eq_ignore_ascii_case(file_type))
})
}
fn grammar(&self) -> Result<syntax::Grammar, syntax::Error> {
let mut raw: syntax::RawGrammar = self.source.parse()?;
self.compile(&mut raw)
}
fn head_grammar(&self, head: &str) -> Result<Option<syntax::Grammar>, syntax::Error> {
let mut raw: syntax::RawGrammar = self.source.parse()?;
if raw.first_line_match.is_none() {
return Ok(None);
}
let grammar = self.compile(&mut raw)?;
Ok(grammar.matches_head(head).then_some(grammar))
}
fn compile(&self, raw: &mut syntax::RawGrammar) -> Result<syntax::Grammar, syntax::Error> {
for file_type in self.file_types {
if !raw
.file_types
.iter()
.any(|existing| existing.eq_ignore_ascii_case(file_type))
{
raw.file_types.push((*file_type).to_owned());
}
}
let dependencies = self
.dependencies
.iter()
.map(|source| source.parse())
.collect::<Result<Vec<syntax::RawGrammar>, syntax::Error>>()?;
syntax::Grammar::compile_with(raw, &dependencies)
}
}
#[cfg(test)]
#[allow(clippy::unwrap_used)]
mod tests {
use super::*;
use crate::{Decode as _, DiffSide, HighlightKey, HighlightKeyInput, HighlightRequest};
use rustik_tui::Color;
#[test]
fn syntax_assets_match_common_source_paths() {
for path in [
"main.go",
"app.js",
"server.mjs",
"Makefile",
"rules.mk",
"index.html.erb",
"config.fish",
"init.lua",
"script.py",
"task.rb",
"build.sh",
"Cargo.toml",
"schema.sql",
"component.tsx",
"document.xml",
"icon.svg",
"page.xhtml",
"config.yml",
] {
assert!(
SYNTAXES
.iter()
.any(|syntax| syntax.matches_path(path.as_ref())),
"no built-in syntax matched {path}"
);
}
}
#[test]
fn scripting_assets_match_shebangs() {
for (head, source) in [
("#!/usr/bin/env ruby3.3", syntax::syntaxes::RUBY),
("#!/usr/bin/env python3.11", syntax::syntaxes::PYTHON),
("#!/bin/sh", syntax::syntaxes::SHELL),
("#!/usr/bin/env -S bash -e", syntax::syntaxes::SHELL),
("#!/usr/bin/env fish", syntax::syntaxes::FISH),
] {
assert!(
SYNTAXES.iter().any(|syntax| syntax.source == source
&& syntax.head_grammar(head).unwrap().is_some()),
"no built-in syntax matched {head}"
);
}
}
#[test]
fn scripting_assets_highlight_extensionless_full_source_shebangs() {
for (head, line, token) in [
("#!/usr/bin/env ruby", "if true", "if"),
("#!/usr/bin/env python3", "if True:", "if"),
("#!/bin/sh", "if true; then", "if"),
("#!/usr/bin/env fish", "if test -n \"$argv\"", "if"),
] {
let result = highlight_extensionless_full_source(head, line);
assert!(
result
.line
.labels()
.iter()
.any(|label| label.content() == token
&& label.paint.style.fg_color() != Color::Unset),
"{:?}",
result.line
);
}
}
fn highlight_extensionless_full_source(head: &str, line: &str) -> crate::HighlightResult {
let patch = format!(
"diff --git a/script b/script\n\
index 1111111111111111111111111111111111111111..2222222222222222222222222222222222222222 100755\n\
--- a/script\n\
+++ b/script\n\
@@ -10,1 +10,1 @@\n\
-old\n\
+{line}\n"
);
let document = DiffDocument::decode_str(&patch).unwrap();
let file = &document.files[0];
let source = crate::HighlightSource::new(format!("{head}\n\n\n\n\n\n\n\n\n{line}"), 1);
let text = source.line(10).unwrap();
let request = HighlightRequest {
key: HighlightKey::new(HighlightKeyInput {
file: file.id,
side: DiffSide::New,
source_line: 10,
text,
syntax: None,
theme: "auto",
}),
hunk: file.hunks[0].id,
row: file.hunks[0].lines[1].id,
path: file.source_path(DiffSide::New),
source,
};
let mut highlighter = Builtins::highlighter(&document).unwrap();
Builtins::load_head_grammars(&mut highlighter, head).unwrap();
highlighter.highlight(request)
}
#[test]
fn added_sources_highlight_by_path() {
for (path, line, token) in [
("init.lua", "local ok = true", "local"),
("config.fish", "if test -n \"$argv\"", "if"),
(
"component.tsx",
"const view = <Button disabled />;",
"Button",
),
("document.xml", "<item enabled=\"true\" />", "item"),
("icon.svg", "<circle cx=\"8\" cy=\"8\" r=\"4\" />", "circle"),
("page.xhtml", "<strong>hello</strong>", "strong"),
] {
let result = highlight_path_source(path, line);
assert!(
result
.line
.labels()
.iter()
.any(|label| label.content() == token
&& label.paint.style.fg_color() != Color::Unset),
"{:?}",
result.line
);
}
}
fn highlight_path_source(path: &str, line: &str) -> crate::HighlightResult {
let patch = format!(
"diff --git a/{path} b/{path}\n\
index 1111111111111111111111111111111111111111..2222222222222222222222222222222222222222 100644\n\
--- a/{path}\n\
+++ b/{path}\n\
@@ -1,1 +1,1 @@\n\
-old\n\
+{line}\n"
);
let document = DiffDocument::decode_str(&patch).unwrap();
let file = &document.files[0];
let source = crate::HighlightSource::new(line.to_owned(), 1);
let text = source.line(1).unwrap();
let request = HighlightRequest {
key: HighlightKey::new(HighlightKeyInput {
file: file.id,
side: DiffSide::New,
source_line: 1,
text,
syntax: None,
theme: "auto",
}),
hunk: file.hunks[0].id,
row: file.hunks[0].lines[1].id,
path: file.source_path(DiffSide::New),
source,
};
let mut highlighter = Builtins::highlighter(&document).unwrap();
highlighter.highlight(request)
}
}