feat: update to version 0.3.2 with new language detection configuration and enhancements

Author: MR-Addict

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "mdbook-embedify"
-version = "0.3.1"
+version = "0.3.2"
 edition = "2021"
 license = "MIT"
 readme = "README.md"
@@ -24,6 +24,7 @@ regex = "1.12.3"
 rust-embed = "8.11.0"
 serde_json = "1.0.149"
 serde_yaml = "0.9.34"
+serde = { version = "1.0.228", features = ["derive"] }
 
 [dev-dependencies]
 dircmp = "0.2.0"

Cargo.toml

@@ -1,6 +1,6 @@
 function appendVersion() {
   const shield = document.createElement("span");
-  shield.textContent = "0.3.1";
+  shield.textContent = "0.3.2";
   document.querySelector(".menu-title").appendChild(shield);
 }
 

docs/assets/js/patch.js

@@ -47,8 +47,8 @@ footer.enable = true
 footer.message = "Copyright © 2025 • Created with ❤️ by [MR-Addict](https://github.com/MR-Addict)"
 
 announcement-banner.enable = true
-announcement-banner.id = "0.3.1"
-announcement-banner.message = "*New version [0.3.1](https://github.com/MR-Addict/mdbook-embedify/releases/tag/0.3.1) relased*"
+announcement-banner.id = "0.3.2"
+announcement-banner.message = "*New version [0.3.2](https://github.com/MR-Addict/mdbook-embedify/releases/tag/0.3.2) relased*"
 
 giscus.enable = true
 giscus.repo = "MR-Addict/mdbook-embedify"
@@ -60,6 +60,16 @@ giscus.theme = "book"
 giscus.lang = "en"
 giscus.loading = "lazy"
 
+include.languages.dockerfile.extensions = [".dockerfile"]
+include.languages.dockerfile.filenames = [
+  "Dockerfile",
+  "dockerfile",
+  "Containerfile",
+  "Dockerfile.*",
+  "dockerfile.*",
+  "*.dockerfile",
+]
+
 custom-templates-folder = "assets/templates"
 
 # This is for the development environment

docs/book.toml

@@ -22,6 +22,27 @@ The language detection system intelligently identifies programming languages fro
 
 Language definitions are stored in [src/assets/config/languages.yaml](https://github.com/MR-Addict/mdbook-embedify/tree/main/src/assets/config/languages.yaml). Each language entry supports multiple matching strategies.
 
+### Custom Configuration
+
+> Attention 💥
+>
+> Support since [v0.3.2](https://github.com/MR-Addict/mdbook-embedify/releases/tag/v0.3.2).
+
+You can override or extend the language detection rules in your `book.toml`. This is useful when you want to add support for new file extensions or modify existing detection rules without waiting for a new release.
+
+Example `book.toml` configuration:
+
+```toml
+[preprocessor.embedify]
+# Add .dockerfile extension to dockerfile language
+include.languages.dockerfile.extensions = [".dockerfile"]
+# Add specific filenames to dockerfile language
+include.languages.dockerfile.filenames = ["Dockerfile", "*.dockerfile"]
+
+# Add a completely new language
+include.languages.mylang.extensions = [".mlg"]
+```
+
 ### Language Definition Structure
 
 ```yaml

docs/src/development/language-matching.md

@@ -12,7 +12,7 @@ Announcement banner allows you put important messages at the top of the page. It
 ## Example
 
 ```text
-{% embed-ignore announcement-banner id="0.3.1" message="*New version [0.3.1](https://github.com/MR-Addict/mdbook-embedify/releases/tag/0.3.1) relased*" %}
+{% embed-ignore announcement-banner id="0.3.2" message="*New version [0.3.2](https://github.com/MR-Addict/mdbook-embedify/releases/tag/0.3.2) relased*" %}
 ```
 
 This book's announcement banner is enabled, you can see it at the top of this page.

docs/src/local/announcement-banner.md

@@ -6,7 +6,11 @@
 >
 > Language is detected by file extension, which I manually referred, simplified and extended from [linguist](https://github.com/github-linguist/linguist/blob/main/lib/linguist/languages.yml).
 >
-> If you find any issues with the language detection, please open an [issue](https://github.com/MR-Addict/mdbook-embedify/issues). Currenltly language map is under [languages.yaml](https://github.com/MR-Addict/mdbook-embedify/blob/main/src/assets/config/languages.yaml)
+> If you find any issues with the language detection, please open an [issue](https://github.com/MR-Addict/mdbook-embedify/issues). Currenltly language map is under [languages.yaml](https://github.com/MR-Addict/mdbook-embedify/blob/main/src/assets/config/languages.yaml).
+
+> Tip 💡
+>
+> You can customize language detection rules in your `book.toml`. See [Language Matching](../development/language-matching.md#custom-configuration) for details.
 
 The include app is for including source file and wrapping it as markdown code block.
 

docs/src/local/include.md

@@ -106,7 +106,7 @@ pub fn include_script(
 
     // wrap the content in a code block
     let lang_option = parser::get_option("lang", options.clone());
-    let lang_detected = detect_lang::detect_lang(file_path.clone());
+    let lang_detected = detect_lang::detect_lang(file_path.clone(), Some(&ctx.config));
 
     let language = match lang_option {
         Some(option) => option.value,

src/assets/scripts/include.rs

@@ -1,67 +1,20 @@
 use lazy_static::lazy_static;
-use std::collections::HashMap;
+use mdbook_core::config::Config;
+use serde::Deserialize;
+use std::collections::{HashMap, HashSet};
 use std::path::Path;
 
+#[derive(Deserialize, Clone)]
+struct LanguageConfig {
+    name: Option<String>,
+    extensions: Option<Vec<String>>,
+    filenames: Option<Vec<String>>,
+}
+
 lazy_static! {
-    static ref LANGUAGE_MAP: HashMap<String, String> = {
+    static ref STATIC_LANGUAGES: Vec<LanguageConfig> = {
         let yaml_content = include_str!("assets/config/languages.yaml");
-        let languages: Vec<serde_yaml::Value> =
-            serde_yaml::from_str(yaml_content).expect("Failed to parse languages.yaml");
-
-        let mut map = HashMap::new();
-        for lang in languages {
-            if let Some(name) = lang["name"].as_str() {
-                // Handle extensions
-                if let Some(extensions) = lang["extensions"].as_sequence() {
-                    for ext in extensions {
-                        if let Some(extension) = ext.as_str() {
-                            map.insert(extension.to_string(), name.to_string());
-                        }
-                    }
-                }
-
-                // Handle exact filenames (non-pattern entries)
-                if let Some(filenames) = lang["filenames"].as_sequence() {
-                    for filename in filenames {
-                        if let Some(filename_str) = filename.as_str() {
-                            // Only add to exact match map if it doesn't contain wildcards
-                            if !filename_str.contains('*') && !filename_str.contains('?') {
-                                map.insert(filename_str.to_string(), name.to_string());
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        map
-    };
-
-    static ref LANGUAGE_PATTERNS: Vec<(regex::Regex, String)> = {
-        let yaml_content = include_str!("assets/config/languages.yaml");
-        let languages: Vec<serde_yaml::Value> =
-            serde_yaml::from_str(yaml_content).expect("Failed to parse languages.yaml");
-
-        let mut patterns = Vec::new();
-        for lang in languages {
-            if let Some(name) = lang["name"].as_str() {
-                // Handle filename patterns (entries with wildcards)
-                if let Some(filenames) = lang["filenames"].as_sequence() {
-                    for filename in filenames {
-                        if let Some(filename_str) = filename.as_str() {
-                            // Only add to patterns if it contains wildcards
-                            if filename_str.contains('*') || filename_str.contains('?') {
-                                // Convert glob pattern to regex
-                                let regex_pattern = glob_to_regex(filename_str);
-                                if let Ok(regex) = regex::Regex::new(&regex_pattern) {
-                                    patterns.push((regex, name.to_string()));
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        patterns
+        serde_yaml::from_str(yaml_content).expect("Failed to parse languages.yaml")
     };
 }
 
@@ -87,34 +40,112 @@ fn glob_to_regex(glob: &str) -> String {
     regex
 }
 
-pub fn detect_lang(path: String) -> String {
-    let path_obj = Path::new(&path);
+fn get_language_overrides(config: Option<&Config>) -> HashMap<String, LanguageConfig> {
+    if let Some(config) = config {
+        if let Ok(Some(languages)) =
+            config.get::<HashMap<String, LanguageConfig>>("preprocessor.embedify.include.languages")
+        {
+            return languages;
+        }
+    }
+    HashMap::new()
+}
 
-    // Get the filename
-    if let Some(filename) = path_obj.file_name() {
-        if let Some(filename_str) = filename.to_str() {
-            // First, try to match the full filename (exact matches from filenames array)
-            if let Some(language) = LANGUAGE_MAP.get(filename_str) {
-                return language.clone();
+fn match_exact(filename: &str, config: &LanguageConfig) -> bool {
+    if let Some(filenames) = &config.filenames {
+        for pattern in filenames {
+            if !pattern.contains('*') && !pattern.contains('?') {
+                if pattern == filename {
+                    return true;
+                }
             }
+        }
+    }
+    false
+}
 
-            // Then try the file extension (everything after the last dot)
-            if let Some(last_dot_pos) = filename_str.rfind('.') {
-                let extension = &filename_str[last_dot_pos..].to_lowercase();
-                if let Some(language) = LANGUAGE_MAP.get(extension) {
-                    return language.clone();
+fn match_extension(filename: &str, config: &LanguageConfig) -> bool {
+    if let Some(extensions) = &config.extensions {
+        if let Some(last_dot_pos) = filename.rfind('.') {
+            let extension = &filename[last_dot_pos..].to_lowercase();
+            for ext in extensions {
+                if ext.to_lowercase() == *extension {
+                    return true;
                 }
             }
+        }
+    }
+    false
+}
 
-            // Finally try filename patterns (wildcard entries from filenames array)
-            for (pattern, language) in LANGUAGE_PATTERNS.iter() {
-                if pattern.is_match(filename_str) {
-                    return language.clone();
+fn match_pattern(filename: &str, config: &LanguageConfig) -> bool {
+    if let Some(filenames) = &config.filenames {
+        for pattern in filenames {
+            if pattern.contains('*') || pattern.contains('?') {
+                // Wildcard match
+                let regex_pattern = glob_to_regex(pattern);
+                if let Ok(regex) = regex::Regex::new(&regex_pattern) {
+                    if regex.is_match(filename) {
+                        return true;
+                    }
                 }
             }
         }
     }
+    false
+}
+
+pub fn detect_lang(path: String, config: Option<&Config>) -> String {
+    let path_obj = Path::new(&path);
+    let filename = match path_obj.file_name().and_then(|f| f.to_str()) {
+        Some(f) => f,
+        None => return "plaintext".to_string(),
+    };
+
+    let overrides = get_language_overrides(config);
+    let mut languages_check_list: Vec<(&str, &LanguageConfig)> =
+        Vec::with_capacity(STATIC_LANGUAGES.len() + overrides.len());
+    let mut processed_overrides = HashSet::new();
+
+    // 1. Add static languages (checking for overrides)
+    for config in STATIC_LANGUAGES.iter() {
+        if let Some(name) = &config.name {
+            if let Some(override_config) = overrides.get(name) {
+                languages_check_list.push((name, override_config));
+                processed_overrides.insert(name);
+            } else {
+                languages_check_list.push((name, config));
+            }
+        }
+    }
+
+    // 2. Add remaining overrides
+    for (name, config) in &overrides {
+        if !processed_overrides.contains(name) {
+            languages_check_list.push((name, config));
+        }
+    }
+
+    // Pass 1: Check Exact Filenames
+    for (name, config) in &languages_check_list {
+        if match_exact(filename, config) {
+            return name.to_string();
+        }
+    }
+
+    // Pass 2: Check Extensions
+    for (name, config) in &languages_check_list {
+        if match_extension(filename, config) {
+            return name.to_string();
+        }
+    }
+
+    // Pass 3: Check Patterns
+    for (name, config) in &languages_check_list {
+        if match_pattern(filename, config) {
+            return name.to_string();
+        }
+    }
 
-    // If no extension found or extension not in map, return "plaintext"
     "plaintext".to_string()
 }

src/detect_lang.rs

@@ -1,4 +1,8 @@
-use mdbook_embedify::detect_lang::detect_lang;
+use mdbook_embedify::detect_lang;
+
+fn detect_lang(path: String) -> String {
+    detect_lang::detect_lang(path, None)
+}
 
 #[cfg(test)]
 mod basic_language_detection_tests {
@@ -521,3 +525,45 @@ mod wildcard_pattern_tests {
         assert_eq!(detect_lang("notmakefile".to_string()), "plaintext");
     }
 }
+
+#[cfg(test)]
+mod config_detection_tests {
+    use mdbook_embedify::detect_lang;
+    use mdbook_core::config::Config;
+
+    #[test]
+    fn test_config_overrides() {
+         // Construct context
+         let mut config = Config::default();
+         // Set include.languages.dockerfile.extensions = [".mydev"]
+         config.set("preprocessor.embedify.include.languages.dockerfile.extensions", vec![".mydev"]).unwrap();
+           
+         assert_eq!(detect_lang::detect_lang("test.mydev".to_string(), Some(&config)), "dockerfile");
+    }
+
+    #[test]
+    fn test_config_filenames() {
+         let mut config = Config::default();
+         config.set("preprocessor.embedify.include.languages.makefile.filenames", vec!["MyMake"]).unwrap();
+           
+         assert_eq!(detect_lang::detect_lang("MyMake".to_string(), Some(&config)), "makefile");
+    }
+
+    #[test]
+    fn test_config_patterns() {
+         let mut config = Config::default();
+         // Test wildcard pattern configuration
+         config.set("preprocessor.embedify.include.languages.python.filenames", vec!["config_*.script"]).unwrap();
+           
+         assert_eq!(detect_lang::detect_lang("config_test.script".to_string(), Some(&config)), "python");
+    }
+
+    #[test]
+    fn test_add_new_language() {
+         let mut config = Config::default();
+         // Add a completely new language
+         config.set("preprocessor.embedify.include.languages.mylang.extensions", vec![".mlg"]).unwrap();
+           
+         assert_eq!(detect_lang::detect_lang("test.mlg".to_string(), Some(&config)), "mylang");
+    }
+}