highlight.rs 99.1%

106 of 107 lines run, 29 of 32 functions · run #525 on main · run missed

//! Syntax highlighting with syntect, emitted as classed spans so the
//! stylesheet colours them in both themes (`templates/style.css`).

use std::sync::OnceLock;
use syntect::html::{ClassStyle, ClassedHTMLGenerator};
use syntect::parsing::SyntaxSet;
use syntect::util::LinesWithEndings;

fn syntaxes() -> &'static SyntaxSet {
    static SET: OnceLock<SyntaxSet> = OnceLock::new();
    SET.get_or_init(SyntaxSet::load_defaults_newlines)
}

/// The language name shown for a file, if syntect knows the extension.
pub fn language(path: &str) -> Option<&'static str> {
    let ext = path.rsplit('.').next().unwrap_or("");
    let name = path.rsplit('/').next().unwrap_or(path);
    let set = syntaxes();
    set.find_syntax_by_extension(ext)
        .or_else(|| set.find_syntax_by_extension(name))
        .or_else(|| match name {
            "Makefile" | "GNUmakefile" => set.find_syntax_by_name("Makefile"),
            "Dockerfile" => set.find_syntax_by_name("Dockerfile"),
            _ => None,
        })
        .map(|s| s.name.as_str())
}

/// Highlighted files by (file name, text): 64 MiB.
fn cache() -> &'static super::cache::Lru<Vec<String>> {
    static C: OnceLock<super::cache::Lru<Vec<String>>> = OnceLock::new();
    C.get_or_init(|| super::cache::Lru::new(64 << 20))
}

/// (hits, misses, bytes) of the highlighted file cache.
pub fn cache_stats() -> (u64, u64, usize) {
    cache().stats()
}

/// Highlight `text`, returning one HTML fragment per line (no trailing
/// newline); plain escaped lines when the language is unknown. Cached by
/// the file's name (which picks the syntax) and its text.
pub fn lines(path: &str, text: &str) -> Vec<String> {
    let name = path.rsplit('/').next().unwrap_or(path);
    let key = super::cache::key(&[b"hl1", name.as_bytes(), text.as_bytes()]);
    cache().get_or(key, || lines_uncached(path, text)).as_ref().clone()
}

/// The longest line highlighted. syntect's time grows much faster than a
/// line's length: a minified 860 KB script of 31 lines took 6.2 s to
/// highlight, every time the hub had restarted, for a page nobody reads as
/// code. A text with a longer line is shown plain, as other forges do.
pub const MAX_HIGHLIGHTED_LINE: usize = 4_000;

fn lines_uncached(path: &str, text: &str) -> Vec<String> {
    if text.lines().any(|l| l.len() > MAX_HIGHLIGHTED_LINE) {
        return text.lines().map(super::escape).collect();
    }
    let set = syntaxes();
    let ext = path.rsplit('.').next().unwrap_or("");
    let name = path.rsplit('/').next().unwrap_or(path);
    let syntax = set.find_syntax_by_extension(ext).or_else(|| set.find_syntax_by_extension(name)).or_else(|| match name {
        "Makefile" | "GNUmakefile" => set.find_syntax_by_name("Makefile"),
        _ => None,
    });
    let Some(syntax) = syntax else {
        return text.lines().map(super::escape).collect();
    };
    let mut generator = ClassedHTMLGenerator::new_with_class_style(syntax, set, ClassStyle::SpacedPrefixed { prefix: "sy-" });
    let mut out = Vec::new();
    for line in LinesWithEndings::from(text) {
        if generator.parse_html_for_line_which_includes_newline(line).is_err() {
            return text.lines().map(super::escape).collect();
        }
    }
    let html = generator.finalize();
    // syntect emits the whole file with spans that may span lines; split
    // on newlines and keep spans balanced per line.
    let mut open: Vec<String> = Vec::new();
    let mut raw_lines: Vec<&str> = html.split('\n').collect();
    // syntect closes the outermost spans after the final newline; that
    // segment holds no text and every span is balanced per line below.
    if raw_lines.last().is_some_and(|l| l.replace("</span>", "").trim().is_empty()) {
        raw_lines.pop();
    }
    for raw in raw_lines {
        let mut line = String::new();
        for tag in &open {
            line.push_str(tag);
        }
        line.push_str(raw);
        // Track spans opened and closed on this line.
        let mut i = 0;
        while let Some(p) = raw[i..].find('<') {
            let start = i + p;
            let Some(end_rel) = raw[start..].find('>') else { break };
            let tag = &raw[start..start + end_rel + 1];
            if tag.starts_with("</") {
                open.pop();
            } else if tag.starts_with("<span") {
                open.push(tag.to_string());
            }
            i = start + end_rel + 1;
        }
        for _ in &open {
            line.push_str("</span>");
        }
        out.push(line);
    }
    out
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn highlights_rust_and_falls_back() {
        let l = lines("main.rs", "fn main() {\n    let x = 1;\n}\n");
        assert_eq!(l.len(), 3);
        assert!(l[0].contains("<span class=\"sy-source sy-rust\">"), "{}", l[0]);
        assert!(l[0].contains("sy-storage sy-type sy-function"), "{}", l[0]);
        // Scope names never reach the page as bare classes (`comment` is also a page class).
        let c = lines("main.rs", "// note\n");
        assert!(c[0].contains("sy-comment") && !c[0].contains("\"comment") && !c[0].contains(" comment"), "{}", c[0]);
        assert!(l[1].ends_with("</span>"), "spans are balanced per line: {}", l[1]);
        assert_eq!(lines("x.unknownext", "a<b\nc"), vec!["a&lt;b", "c"]);
        assert_eq!(language("a/b/lib.rs"), Some("Rust"));
        assert_eq!(language("Makefile"), Some("Makefile"));
        assert_eq!(language("blob.bin"), None);
    }

    /// A minified file is shown plain, at once, its lines still escaped.
    #[test]
    fn a_text_with_a_very_long_line_is_shown_plain() {
        let long = format!("var a=\"<\";{}\nb();\n", "x+".repeat(MAX_HIGHLIGHTED_LINE));
        let started = std::time::Instant::now();
        let l = lines("app.min.js", &long);
        // Highlighting it would take far longer; a debug build on a busy
        // machine takes some of this bound for reading it plain (#327).
        let bound = std::time::Duration::from_millis(if cfg!(debug_assertions) { 3000 } else { 500 });
        assert!(started.elapsed() < bound, "{:?}", started.elapsed());
        assert_eq!(l.len(), 2);
        assert!(l[0].starts_with("var a=&quot;&lt;&quot;;") && !l[0].contains("<span"), "{}", &l[0][..40]);
        assert!(lines("app.js", "var a = 1;\n")[0].contains("<span"), "a normal file is highlighted");
    }
}

1		//! Syntax highlighting with syntect, emitted as classed spans so the
2		//! stylesheet colours them in both themes (`templates/style.css`).
3
4		use std::sync::OnceLock;
5		use syntect::html::{ClassStyle, ClassedHTMLGenerator};
6		use syntect::parsing::SyntaxSet;
7		use syntect::util::LinesWithEndings;
8
9	75×	fn syntaxes() -> &'static SyntaxSet {
10		static SET: OnceLock<SyntaxSet> = OnceLock::new();
11	75×	SET.get_or_init(SyntaxSet::load_defaults_newlines)
12	75×	}
13
14		/// The language name shown for a file, if syntect knows the extension.
15	60×	pub fn language(path: &str) -> Option<&'static str> {
16	60×	let ext = path.rsplit('.').next().unwrap_or("");
17	60×	let name = path.rsplit('/').next().unwrap_or(path);
18	60×	let set = syntaxes();
19	60×	set.find_syntax_by_extension(ext)
20	60×	.or_else(\|\| set.find_syntax_by_extension(name))
21	60×	.or_else(\|\| match name {
22	4×	"Makefile" \| "GNUmakefile" => set.find_syntax_by_name("Makefile"),
23	4×	"Dockerfile" => set.find_syntax_by_name("Dockerfile"),
24	4×	_ => None,
25	4×	})
26	60×	.map(\|s\| s.name.as_str())
27	60×	}
28
29		/// Highlighted files by (file name, text): 64 MiB.
30	44×	fn cache() -> &'static super::cache::Lru<Vec<String>> {
31		static C: OnceLock<super::cache::Lru<Vec<String>>> = OnceLock::new();
32	44×	C.get_or_init(\|\| super::cache::Lru::new(64 << 20))
33	44×	}
34
35		/// (hits, misses, bytes) of the highlighted file cache.
36	2×	pub fn cache_stats() -> (u64, u64, usize) {
37	2×	cache().stats()
38	2×	}
39
40		/// Highlight `text`, returning one HTML fragment per line (no trailing
41		/// newline); plain escaped lines when the language is unknown. Cached by
42		/// the file's name (which picks the syntax) and its text.
43	42×	pub fn lines(path: &str, text: &str) -> Vec<String> {
44	42×	let name = path.rsplit('/').next().unwrap_or(path);
45	42×	let key = super::cache::key(&[b"hl1", name.as_bytes(), text.as_bytes()]);
46	42×	cache().get_or(key, \|\| lines_uncached(path, text)).as_ref().clone()
47	42×	}
48
49		/// The longest line highlighted. syntect's time grows much faster than a
50		/// line's length: a minified 860 KB script of 31 lines took 6.2 s to
51		/// highlight, every time the hub had restarted, for a page nobody reads as
52		/// code. A text with a longer line is shown plain, as other forges do.
53		pub const MAX_HIGHLIGHTED_LINE: usize = 4_000;
54
55	16×	fn lines_uncached(path: &str, text: &str) -> Vec<String> {
56	48×	if text.lines().any(\|l\| l.len() > MAX_HIGHLIGHTED_LINE) {
57	1×	return text.lines().map(super::escape).collect();
58	15×	}
59	15×	let set = syntaxes();
60	15×	let ext = path.rsplit('.').next().unwrap_or("");
61	15×	let name = path.rsplit('/').next().unwrap_or(path);
62	15×	let syntax = set.find_syntax_by_extension(ext).or_else(\|\| set.find_syntax_by_extension(name)).or_else(\|\| match name {
63	1×	"Makefile" \| "GNUmakefile" => set.find_syntax_by_name("Makefile"),
64	1×	_ => None,
65	1×	});
66	15×	let Some(syntax) = syntax else {
67	1×	return text.lines().map(super::escape).collect();
68		};
69	14×	let mut generator = ClassedHTMLGenerator::new_with_class_style(syntax, set, ClassStyle::SpacedPrefixed { prefix: "sy-" });
70	14×	let mut out = Vec::new();
71	45×	for line in LinesWithEndings::from(text) {
72	45×	if generator.parse_html_for_line_which_includes_newline(line).is_err() {
73	0×	return text.lines().map(super::escape).collect();
74	45×	}
75		}
76	14×	let html = generator.finalize();
77		// syntect emits the whole file with spans that may span lines; split
78		// on newlines and keep spans balanced per line.
79	14×	let mut open: Vec<String> = Vec::new();
80	14×	let mut raw_lines: Vec<&str> = html.split('\n').collect();
81		// syntect closes the outermost spans after the final newline; that
82		// segment holds no text and every span is balanced per line below.
83	14×	if raw_lines.last().is_some_and(\|l\| l.replace("</span>", "").trim().is_empty()) {
84	12×	raw_lines.pop();
85	12×	}
86	45×	for raw in raw_lines {
87	45×	let mut line = String::new();
88	75×	for tag in &open {
89	75×	line.push_str(tag);
90	75×	}
91	45×	line.push_str(raw);
92		// Track spans opened and closed on this line.
93	45×	let mut i = 0;
94	540×	while let Some(p) = raw[i..].find('<') {
95	495×	let start = i + p;
96	495×	let Some(end_rel) = raw[start..].find('>') else { break };
97	495×	let tag = &raw[start..start + end_rel + 1];
98	495×	if tag.starts_with("</") {
99	241×	open.pop();
100	254×	} else if tag.starts_with("<span") {
101	254×	open.push(tag.to_string());
102	254×	}
103	495×	i = start + end_rel + 1;
104		}
105	88×	for _ in &open {
106	88×	line.push_str("</span>");
107	88×	}
108	45×	out.push(line);
109		}
110	14×	out
111	16×	}
112
113		#[cfg(test)]
114		mod tests {
115		use super::*;
116
117		#[test]
118	1×	fn highlights_rust_and_falls_back() {
119	1×	let l = lines("main.rs", "fn main() {\n let x = 1;\n}\n");
120	1×	assert_eq!(l.len(), 3);
121	1×	assert!(l[0].contains("<span class=\"sy-source sy-rust\">"), "{}", l[0]);
122	1×	assert!(l[0].contains("sy-storage sy-type sy-function"), "{}", l[0]);
123		// Scope names never reach the page as bare classes (`comment` is also a page class).
124	1×	let c = lines("main.rs", "// note\n");
125	1×	assert!(c[0].contains("sy-comment") && !c[0].contains("\"comment") && !c[0].contains(" comment"), "{}", c[0]);
126	1×	assert!(l[1].ends_with("</span>"), "spans are balanced per line: {}", l[1]);
127	1×	assert_eq!(lines("x.unknownext", "a<b\nc"), vec!["a<b", "c"]);
128	1×	assert_eq!(language("a/b/lib.rs"), Some("Rust"));
129	1×	assert_eq!(language("Makefile"), Some("Makefile"));
130	1×	assert_eq!(language("blob.bin"), None);
131	1×	}
132
133		/// A minified file is shown plain, at once, its lines still escaped.
134		#[test]
135	1×	fn a_text_with_a_very_long_line_is_shown_plain() {
136	1×	let long = format!("var a=\"<\";{}\nb();\n", "x+".repeat(MAX_HIGHLIGHTED_LINE));
137	1×	let started = std::time::Instant::now();
138	1×	let l = lines("app.min.js", &long);
139		// Highlighting it would take far longer; a debug build on a busy
140		// machine takes some of this bound for reading it plain (#327).
141	1×	let bound = std::time::Duration::from_millis(if cfg!(debug_assertions) { 3000 } else { 500 });
142	1×	assert!(started.elapsed() < bound, "{:?}", started.elapsed());
143	1×	assert_eq!(l.len(), 2);
144	1×	assert!(l[0].starts_with("var a="<";") && !l[0].contains("<span"), "{}", &l[0][..40]);
145	1×	assert!(lines("app.js", "var a = 1;\n")[0].contains("<span"), "a normal file is highlighted");
146	1×	}
147		}

`/`	Search
`g` `c`	Code
`g` `h`	History
`g` `b`	Bookmarks
`g` `t`	Trust
`y`	Permalink to this state (files and trees)
`?`	This sheet

Coverage / crates/hub/src/render/highlight.rs 99.1%

Keyboard