Support highlighting Cargo.lock and Cargo.toml.orig

This requires passing the full filename into the highlighter so that if
specific files have an overridden syntax definition they will be chosen.
We also need to edit the syntax definition we load so that it includes
all the filenames we need.

Author: Nemo157

build.rs

@@ -186,7 +186,10 @@ fn write_known_targets(out_dir: &Path) -> Result<()> {
 }
 
 fn compile_syntax(out_dir: &Path) -> Result<()> {
-    use syntect::{dumps::dump_to_uncompressed_file, parsing::SyntaxSetBuilder};
+    use syntect::{
+        dumps::dump_to_uncompressed_file,
+        parsing::{SyntaxDefinition, SyntaxSetBuilder},
+    };
 
     fn tracked_add_from_folder(
         builder: &mut SyntaxSetBuilder,
@@ -207,7 +210,16 @@ fn compile_syntax(out_dir: &Path) -> Result<()> {
         &mut builder,
         "assets/syntaxes/Packages/Markdown/Markdown.sublime-syntax",
     )?;
-    tracked_add_from_folder(&mut builder, "assets/syntaxes/Extras/TOML/")?;
+
+    // The TOML syntax already includes `Cargo.lock` in its alternative file extensions, but we
+    // also want to support `Cargo.toml.orig` files.
+    let mut toml = SyntaxDefinition::load_from_str(
+        &tracked::read_to_string("assets/syntaxes/Extras/TOML/TOML.sublime-syntax")?,
+        true,
+        Some("TOML"),
+    )?;
+    toml.file_extensions.push("Cargo.toml.orig".into());
+    builder.add(toml);
 
     dump_to_uncompressed_file(&builder.build(), out_dir.join("syntect.packdump"))?;
 

src/web/highlight.rs

@@ -2,7 +2,7 @@ use crate::error::Result;
 use once_cell::sync::Lazy;
 use syntect::{
     html::{ClassStyle, ClassedHTMLGenerator},
-    parsing::SyntaxSet,
+    parsing::{SyntaxReference, SyntaxSet},
     util::LinesWithEndings,
 };
 
@@ -21,14 +21,7 @@ static SYNTAXES: Lazy<SyntaxSet> = Lazy::new(|| {
     syntaxes
 });
 
-pub fn try_with_lang(lang: Option<&str>, code: &str) -> Result<String> {
-    let syntax = lang
-        .and_then(|lang| SYNTAXES.find_syntax_by_token(lang))
-        .or_else(|| SYNTAXES.find_syntax_by_first_line(code))
-        .unwrap_or_else(|| SYNTAXES.find_syntax_plain_text());
-
-    log::trace!("Using syntax {:?} for language {lang:?}", syntax.name);
-
+fn try_with_syntax(syntax: &SyntaxReference, code: &str) -> Result<String> {
     let mut html_generator = ClassedHTMLGenerator::new_with_class_style(
         syntax,
         &SYNTAXES,
@@ -42,6 +35,25 @@ pub fn try_with_lang(lang: Option<&str>, code: &str) -> Result<String> {
     Ok(html_generator.finalize())
 }
 
+fn select_syntax(name: Option<&str>, code: &str) -> &'static SyntaxReference {
+    name.and_then(|name| {
+        SYNTAXES.find_syntax_by_token(name).or_else(|| {
+            if name.starts_with('.') {
+                None
+            } else {
+                name.rsplit_once('.')
+                    .and_then(|(_, ext)| SYNTAXES.find_syntax_by_token(ext))
+            }
+        })
+    })
+    .or_else(|| SYNTAXES.find_syntax_by_first_line(code))
+    .unwrap_or_else(|| SYNTAXES.find_syntax_plain_text())
+}
+
+pub fn try_with_lang(lang: Option<&str>, code: &str) -> Result<String> {
+    try_with_syntax(select_syntax(lang, code), code)
+}
+
 pub fn with_lang(lang: Option<&str>, code: &str) -> String {
     match try_with_lang(lang, code) {
         Ok(highlighted) => highlighted,
@@ -51,3 +63,16 @@ pub fn with_lang(lang: Option<&str>, code: &str) -> String {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::select_syntax;
+
+    #[test]
+    fn custom_filetypes() {
+        let toml = select_syntax(Some("toml"), "");
+
+        assert_eq!(select_syntax(Some("Cargo.toml.orig"), "").name, toml.name);
+        assert_eq!(select_syntax(Some("Cargo.lock"), "").name, toml.name);
+    }
+}

src/web/source.rs

@@ -24,28 +24,19 @@ struct File {
     name: String,
     /// The mime type of the file
     mime: String,
-    /// The extension of the file, if it has one
-    extension: Option<String>,
 }
 
 impl File {
     fn from_path_and_mime(path: &str, mime: &str) -> File {
-        let (name, mime, extension) = if let Some((dir, _)) = path.split_once('/') {
-            (dir, "dir", None)
+        let (name, mime) = if let Some((dir, _)) = path.split_once('/') {
+            (dir, "dir")
         } else {
-            let extension = if path.starts_with('.') {
-                None
-            } else {
-                path.rsplit_once('.').map(|(_, ext)| ext)
-            };
-
-            (path, mime, extension)
+            (path, mime)
         };
 
         Self {
             name: name.to_owned(),
             mime: mime.to_owned(),
-            extension: extension.map(|s| s.to_owned()),
         }
     }
 }
@@ -438,4 +429,32 @@ mod tests {
             Ok(())
         })
     }
+
+    #[test]
+    fn cargo_special_filetypes_are_highlighted() {
+        wrapper(|env| {
+            env.fake_release()
+                .name("fake")
+                .version("0.1.0")
+                .source_file("Cargo.toml.orig", b"[package]")
+                .source_file("Cargo.lock", b"[dependencies]")
+                .create()?;
+
+            let web = env.frontend();
+
+            let response = web
+                .get("/crate/fake/0.1.0/source/Cargo.toml.orig")
+                .send()?
+                .text()?;
+            assert!(response.contains(r#"<span class="syntax-source syntax-toml">"#));
+
+            let response = web
+                .get("/crate/fake/0.1.0/source/Cargo.lock")
+                .send()?
+                .text()?;
+            assert!(response.contains(r#"<span class="syntax-source syntax-toml">"#));
+
+            Ok(())
+        });
+    }
 }

templates/crate/source.html

@@ -113,7 +113,7 @@
             {# If the file has content, then display it in a codeblock #}
             {%- if file_content -%}
                 <div id="source-code" class="pure-u-1 pure-u-sm-17-24 pure-u-md-19-24">
-                    {{- file_content | highlight(lang=file.extension) -}}
+                    {{- file_content | highlight(lang=file.name) -}}
                 </div>
             {%- endif -%}
         </div>