use crate::linguist_data::{default_alias, resolve_canonical}; use crate::rule::{Fix, LintError, LintResult, LintWarning, Rule, RuleCategory, Severity}; use crate::rule_config_serde::load_rule_config; use crate::utils::range_utils::calculate_line_range; use std::collections::HashMap; /// The whitespace CommonMark strips around a fence's info string: spaces and tabs. /// A U+00A0 or other Unicode space is part of the info string, so treating it as /// whitespace would let the fix replace it. const FENCE_SPACE: [char; 2] = [' ', '\t']; /// Rule MD040: Fenced code blocks should have a language /// /// See [docs/md040.md](../../docs/md040.md) for full documentation, configuration, and examples. pub mod md040_config; use crate::utils::fence_language::{FenceLanguage, classify}; use md040_config::{LanguageStyle, MD040Config, UnknownLanguageAction}; struct FencedCodeBlock { /// 0-indexed line number where the code block starts line_idx: usize, /// The language/info string (empty if no language specified) language: String, /// The fence marker used (``` or ~~~) fence_marker: String, } #[derive(Debug, Clone, Default)] pub struct MD040FencedCodeLanguage { config: MD040Config, } impl MD040FencedCodeLanguage { pub fn with_config(config: MD040Config) -> Self { Self { config } } /// The language a fence label names, or `None` when nothing recognizes it. /// /// Linguist stays authoritative, so a label it resolves keeps its canonical /// name and its aliases. `custom-languages` answers for the labels Linguist /// has no entry for, which lets a project name the languages it actually /// uses instead of accepting every unknown label. fn resolve_language(&self, label: &str) -> Option<&str> { resolve_canonical(label).or_else(|| self.config.custom_language(label)) } /// Validate the configuration and return any errors fn validate_config(&self) -> Vec { let mut errors = Vec::new(); // A fence label is the first whitespace-separated word of the info // string, so an entry holding whitespace anywhere, surrounding it // included, could never match one. for declared in &self.config.custom_languages { if declared.trim().is_empty() { errors.push("Empty entry in custom-languages.".to_string()); } else if declared.chars().any(char::is_whitespace) { errors.push(format!( "Custom language '{declared}' contains whitespace, so no fence label can match it." )); } } errors.extend( self.config .preferred_aliases .iter() .filter_map(|(language, alias)| self.config.preferred_alias_problem(language, alias)), ); errors } /// Whether an inline comment turns this rule off for the block's fence line. /// /// A fence the rule is disabled for takes no part in the document's choice of /// label, so this is asked while counting labels. Raw findings are still reported. fn is_disabled_at(&self, ctx: &crate::lint_context::LintContext, block: &FencedCodeBlock) -> bool { ctx.is_rule_disabled(self.name(), block.line_idx + 1) } /// Determine the preferred label for each canonical language in the document fn compute_preferred_labels( &self, ctx: &crate::lint_context::LintContext, blocks: &[FencedCodeBlock], ) -> HashMap { // Group labels by canonical language let mut by_canonical: HashMap> = HashMap::new(); for block in blocks { if self.is_disabled_at(ctx, block) { continue; } if block.language.is_empty() { continue; } if let Some(canonical) = self.resolve_language(&block.language) { by_canonical .entry(canonical.to_string()) .or_default() .push(&block.language); } } // Determine winning label for each canonical language let mut result = HashMap::new(); for (canonical, labels) in by_canonical { // Check for user override first (case-insensitive lookup) let winner = if let Some(preferred) = self.config.preferred_label(&canonical) { preferred.to_string() } else { // Find most prevalent label let mut counts: HashMap<&str, usize> = HashMap::new(); for label in &labels { *counts.entry(*label).or_default() += 1; } let max_count = counts.values().max().copied().unwrap_or(0); let winners: Vec<_> = counts .iter() .filter(|(_, c)| **c == max_count) .map(|(l, _)| *l) .collect(); if winners.len() == 1 { winners[0].to_string() } else { // Tie-break: use the curated default (or, for a custom // language, its declared spelling), otherwise alphabetically first default_alias(&canonical) .or_else(|| self.config.custom_language(&canonical)) .filter(|default| winners.contains(default)) .map_or_else( || winners.into_iter().min().unwrap().to_string(), std::string::ToString::to_string, ) } }; result.insert(canonical, winner); } result } /// Check if a language is allowed based on config fn check_language_allowed(&self, canonical: Option<&str>, original_label: &str) -> Option { // Allowlist takes precedence if !self.config.allowed_languages.is_empty() { let allowed = self.config.allowed_languages.join(", "); let Some(canonical) = canonical else { return Some(format!( "Language '{original_label}' is not in the allowed list: {allowed}" )); }; if !self .config .allowed_languages .iter() .any(|a| a.eq_ignore_ascii_case(canonical)) { return Some(format!( "Language '{original_label}' ({canonical}) is not in the allowed list: {allowed}" )); } } else if !self.config.disallowed_languages.is_empty() && canonical.is_some_and(|canonical| { self.config .disallowed_languages .iter() .any(|d| d.eq_ignore_ascii_case(canonical)) }) { let canonical = canonical.unwrap_or("unknown"); return Some(format!("Language '{original_label}' ({canonical}) is disallowed")); } None } /// Check for unknown language based on config fn check_unknown_language(&self, label: &str) -> Option<(String, Severity)> { // GitHub accepts names, aliases, AND file extensions as fence labels // (```pytb highlights via the .pytb extension), so the unknown check // consults the full accept-set, not just resolvable aliases. if crate::linguist_data::is_known_language(label) || self.config.custom_language(label).is_some() { return None; } match self.config.unknown_language_action { UnknownLanguageAction::Ignore => None, UnknownLanguageAction::Warn => Some(( format!( "Unknown language '{label}' (not in GitHub Linguist). Syntax highlighting may not work. Add it to custom-languages to accept it." ), Severity::Warning, )), UnknownLanguageAction::Error => Some(( format!( "Unknown language '{label}' (not in GitHub Linguist). Add it to custom-languages to accept it." ), Severity::Error, )), } } } impl Rule for MD040FencedCodeLanguage { fn native_format_policy(&self) -> Option { (self.config == Default::default()).then_some(crate::format_proof::NativeFormatPolicy::for_rule::(40)) } fn name(&self) -> &'static str { "MD040" } fn description(&self) -> &'static str { "Code blocks should have a language specified" } fn check(&self, ctx: &crate::lint_context::LintContext) -> LintResult { let mut warnings = Vec::new(); // Validate config and emit warnings for invalid configuration for error in self.validate_config() { warnings.push(LintWarning { rule_name: Some(self.name().to_string()), line: 1, column: 1, end_line: 1, end_column: 1, message: format!("[config error] {error}"), severity: Severity::Error, fix: None, }); } // Derive fenced code blocks from pre-computed context let fenced_blocks = derive_fenced_code_blocks(ctx); // Compute preferred labels for consistent mode let preferred_labels = if self.config.style == LanguageStyle::Consistent { self.compute_preferred_labels(ctx, &fenced_blocks) } else { HashMap::new() }; let lines = ctx.raw_lines(); for block in &fenced_blocks { // Get the actual line content for additional checks. Strip any // blockquote prefix so the info string after the fence is recognized // inside blockquotes the same way it is at the top level. let line = lines.get(block.line_idx).unwrap_or(&""); let fence_line = crate::utils::blockquote::strip_blockquote_prefix(line).trim_matches(FENCE_SPACE); let after_fence = fence_marker_offset(fence_line, &block.fence_marker) .map_or(block.language.as_str(), |offset| { fence_line[offset + block.fence_marker.len()..].trim_matches(FENCE_SPACE) }); let classification = classify(after_fence, ctx.flavor); if matches!(classification, FenceLanguage::Exempt | FenceLanguage::CodeSyntax) { continue; } if classification == FenceLanguage::Missing { let (start_line, start_col, end_line, end_col) = calculate_line_range(block.line_idx + 1, line); let fix = fence_marker_offset(line, &block.fence_marker).map(|marker_offset| { let line_start_byte = ctx.line_offsets.get(block.line_idx).copied().unwrap_or(0); let fence_end_byte = line_start_byte + marker_offset + block.fence_marker.len(); // Replace from after fence marker to end of line content, // so trailing whitespace is cleaned up while any existing // info string / attributes are preserved via the replacement. let line_end_byte = line_start_byte + line.len(); let after_fence_trimmed = line[marker_offset + block.fence_marker.len()..].trim_matches(FENCE_SPACE); let replacement = if after_fence_trimmed.is_empty() { "text".to_string() } else { format!("text {after_fence_trimmed}") }; Fix::new(fence_end_byte..line_end_byte, replacement) }); warnings.push(LintWarning { rule_name: Some(self.name().to_string()), line: start_line, column: start_col, end_line, end_column: end_col, message: "Code block (```) missing language".to_string(), severity: Severity::Warning, fix, }); continue; } let canonical = self.resolve_language(&block.language); // Check language restrictions (allowlist/denylist) if let Some(msg) = self.check_language_allowed(canonical, &block.language) { let (start_line, start_col, end_line, end_col) = calculate_line_range(block.line_idx + 1, line); warnings.push(LintWarning { rule_name: Some(self.name().to_string()), line: start_line, column: start_col, end_line, end_column: end_col, message: msg, severity: Severity::Warning, fix: None, }); continue; } // Check for unknown language (only if not handled by allowlist) if canonical.is_none() { if let Some((msg, severity)) = self.check_unknown_language(&block.language) { let (start_line, start_col, end_line, end_col) = calculate_line_range(block.line_idx + 1, line); warnings.push(LintWarning { rule_name: Some(self.name().to_string()), line: start_line, column: start_col, end_line, end_column: end_col, message: msg, severity, fix: None, }); } continue; } // Check consistency if self.config.style == LanguageStyle::Consistent && let Some(preferred) = preferred_labels.get(canonical.unwrap()) && &block.language != preferred { let (start_line, start_col, end_line, end_col) = calculate_line_range(block.line_idx + 1, line); let fix = find_label_span(line, &block.fence_marker).map(|(label_start, label_end)| { let line_start_byte = ctx.line_offsets.get(block.line_idx).copied().unwrap_or(0); Fix::new( (line_start_byte + label_start)..(line_start_byte + label_end), preferred.clone(), ) }); let lang = &block.language; let canonical = canonical.unwrap(); warnings.push(LintWarning { rule_name: Some(self.name().to_string()), line: start_line, column: start_col, end_line, end_column: end_col, message: format!("Inconsistent language label '{lang}' for {canonical} (use '{preferred}')"), severity: Severity::Warning, fix, }); } } // In Markdown with Gherkin an info string is the Doc String media type. // Keep every MD040 diagnostic, but never invent or normalize that // domain value during formatting. if ctx.flavor == crate::config::MarkdownFlavor::MDG { for warning in &mut warnings { warning.fix = None; } } Ok(warnings) } fn fixes_from_diagnostics(&self) -> bool { true } fn fix(&self, ctx: &crate::lint_context::LintContext) -> Result { if self.should_skip(ctx) { return Ok(ctx.content.to_string()); } let warnings = self.check(ctx)?; if warnings.is_empty() { return Ok(ctx.content.to_string()); } let warnings = crate::utils::fix_utils::filter_warnings_by_inline_config(warnings, ctx.inline_config(), self.name()); crate::utils::fix_utils::apply_warning_fixes(ctx.content, &warnings).map_err(LintError::InvalidInput) } /// Get the category of this rule for selective processing fn category(&self) -> RuleCategory { RuleCategory::CodeBlock } /// Check if this rule should be skipped fn should_skip(&self, ctx: &crate::lint_context::LintContext) -> bool { ctx.content.is_empty() || (!ctx.likely_has_code() && !ctx.has_char('~')) } fn as_any(&self) -> &dyn std::any::Any { self } crate::impl_rule_config_sections!(MD040Config); fn from_config(config: &crate::config::Config) -> Box where Self: Sized, { let rule_config: MD040Config = load_rule_config(config); Box::new(MD040FencedCodeLanguage::with_config(rule_config)) } } /// Derive fenced code blocks from pre-computed CodeBlockDetail data fn derive_fenced_code_blocks(ctx: &crate::lint_context::LintContext) -> Vec { let content = ctx.content; let line_offsets = &ctx.line_offsets; let ambiguity_limit = super::code_fence_utils::fence_ambiguity_limit(ctx); ctx.code_block_details .iter() .filter(|d| d.is_fenced && !ctx.is_inside_template_code(d.start) && !ctx.is_inside_mdx_code(d.start)) .filter(|d| ambiguity_limit.is_none_or(|limit| d.start < limit)) .map(|detail| { let line_idx = match line_offsets.binary_search(&detail.start) { Ok(idx) => idx, Err(idx) => idx.saturating_sub(1), }; // Determine fence marker from the actual line content let line_start = line_offsets.get(line_idx).copied().unwrap_or(0); let line_end = line_offsets.get(line_idx + 1).copied().unwrap_or(content.len()); let line = content.get(line_start..line_end).unwrap_or(""); let fence_marker = find_fence_marker(line).map_or_else(|| "```".to_string(), |(_, marker)| marker.to_string()); let language = detail .info_string .split(FENCE_SPACE) .find(|word| !word.is_empty()) .unwrap_or("") .to_string(); FencedCodeBlock { line_idx, language, fence_marker, } }) .collect() } /// Locate the fence marker on a fence-opening line: its byte offset and the run /// of fence characters itself. /// /// A fence opener can carry a blockquote prefix, indentation and one or more /// list markers (`- `, `1. `, and nested combinations). Rather than enumerating /// those prefixes, locate the marker itself: none of them can hold a backtick or /// a tilde, so the first run of either is the fence. fn find_fence_marker(line: &str) -> Option<(usize, &str)> { let bytes = line.as_bytes(); let start = bytes.iter().position(|&b| b == b'`' || b == b'~')?; let fence_char = bytes[start]; let len = bytes[start..].iter().take_while(|&&b| b == fence_char).count(); Some((start, &line[start..start + len])) } /// Byte offset within `line` where `fence_marker` begins. /// /// Returns `None` when the line's fence run is not the expected marker, so /// callers offer no fix rather than one anchored at a guessed position. fn fence_marker_offset(line: &str, fence_marker: &str) -> Option { let (start, marker) = find_fence_marker(line)?; (marker == fence_marker).then_some(start) } /// Find the byte span of the language label in a fence line. fn find_label_span(line: &str, fence_marker: &str) -> Option<(usize, usize)> { let marker_offset = fence_marker_offset(line, fence_marker)?; let after_fence = &line[marker_offset + fence_marker.len()..]; let label_start_rel = after_fence .char_indices() .find(|&(_, ch)| !FENCE_SPACE.contains(&ch)) .map(|(idx, _)| idx)?; let after_label = &after_fence[label_start_rel..]; let label_end_rel = after_label .char_indices() .find(|&(_, ch)| FENCE_SPACE.contains(&ch)) .map_or(after_fence.len(), |(idx, _)| label_start_rel + idx); Some(( marker_offset + fence_marker.len() + label_start_rel, marker_offset + fence_marker.len() + label_end_rel, )) } #[cfg(test)] mod tests { use super::*; use crate::lint_context::LintContext; fn run_check(content: &str) -> LintResult { let rule = MD040FencedCodeLanguage::default(); let ctx = LintContext::new(content, crate::config::MarkdownFlavor::Standard, None); rule.check(&ctx) } fn run_check_with_config(content: &str, config: MD040Config) -> LintResult { let rule = MD040FencedCodeLanguage::with_config(config); crate::lint( content, &[Box::new(rule)], false, crate::config::MarkdownFlavor::Standard, None, None, ) } fn run_fix(content: &str) -> Result { let rule = MD040FencedCodeLanguage::default(); let ctx = LintContext::new(content, crate::config::MarkdownFlavor::Standard, None); rule.fix(&ctx) } fn run_fix_with_config(content: &str, config: MD040Config) -> Result { let rule = MD040FencedCodeLanguage::with_config(config); let ctx = LintContext::new(content, crate::config::MarkdownFlavor::Standard, None); rule.fix(&ctx) } fn run_check_mkdocs(content: &str) -> LintResult { let rule = MD040FencedCodeLanguage::default(); let ctx = LintContext::new(content, crate::config::MarkdownFlavor::MkDocs, None); rule.check(&ctx) } // ========================================================================= // Basic functionality tests // ========================================================================= #[test] fn test_code_blocks_with_language_specified() { let content = r#"# Test ```python print("Hello, world!") ``` ```javascript console.log("Hello!"); ``` "#; let result = run_check(content).unwrap(); assert!(result.is_empty(), "No warnings expected for code blocks with language"); } #[test] fn test_code_blocks_without_language() { let content = r#"# Test ``` print("Hello, world!") ``` "#; let result = run_check(content).unwrap(); assert_eq!(result.len(), 1); assert_eq!(result[0].message, "Code block (```) missing language"); assert_eq!(result[0].line, 3); } #[test] fn test_fix_method_adds_text_language() { let content = r#"# Test ``` code without language ``` ```python already has language ``` ``` another block without ``` "#; let fixed = run_fix(content).unwrap(); assert!(fixed.contains("```text")); assert!(fixed.contains("```python")); assert_eq!(fixed.matches("```text").count(), 2); } #[test] fn test_fix_preserves_indentation() { let content = r#"# Test - List item ``` indented code block ``` "#; let fixed = run_fix(content).unwrap(); assert!(fixed.contains(" ```text")); } #[test] fn test_fix_blockquote_empty_fence() { // An empty fence inside a blockquote must become a valid `> ```text` // fence, not a corrupted `> `text `` inline span. MD040 only touches the // fence lines, so the indented content is preserved verbatim. let content = "# Title\n\n> ```\n> root/\n> └── nested/\n> └── file.txt\n> ```\n"; let fixed = run_fix(content).unwrap(); let expected = "# Title\n\n> ```text\n> root/\n> └── nested/\n> └── file.txt\n> ```\n"; assert_eq!(fixed, expected); } #[test] fn test_fix_blockquote_tilde_and_longer_fences() { // Tilde fences and fences longer than three characters inside a // blockquote must be detected by their actual marker, not the default. let tilde = run_fix("> ~~~\n> code\n> ~~~\n").unwrap(); assert_eq!(tilde, "> ~~~text\n> code\n> ~~~\n"); let longer = run_fix("> ~~~~\n> code\n> ~~~~\n").unwrap(); assert_eq!(longer, "> ~~~~text\n> code\n> ~~~~\n"); let longer_backtick = run_fix("> ````\n> code\n> ````\n").unwrap(); assert_eq!(longer_backtick, "> ````text\n> code\n> ````\n"); } #[test] fn test_fix_nested_blockquote_empty_fence() { // Compact and spaced nested blockquotes both carry their prefix into the // fence line; the fix must place `text` after the real fence marker. let compact = run_fix(">> ```\n>> code\n>> ```\n").unwrap(); assert_eq!(compact, ">> ```text\n>> code\n>> ```\n"); let spaced = run_fix("> > ```\n> > code\n> > ```\n").unwrap(); assert_eq!(spaced, "> > ```text\n> > code\n> > ```\n"); } #[test] fn test_fix_list_marker_empty_fence() { // A fence opened on a list marker line must become `- ```text`, not a // corrupted `` - `text `` `` inline span. The marker sits after the list // bullet, so the fix has to locate it rather than assume it starts at the // first non-whitespace byte. let content = "# Title\n\n- ```\n root/\n └── nested/\n └── file.txt\n ```\n"; let fixed = run_fix(content).unwrap(); let expected = "# Title\n\n- ```text\n root/\n └── nested/\n └── file.txt\n ```\n"; assert_eq!(fixed, expected); } #[test] fn test_fix_list_marker_fence_across_marker_styles() { // Every list marker form pushes the fence a different distance into the // line, including nested markers on one line and a marker inside a // blockquote. for (input, expected) in [ ("- ```\n code\n ```\n", "- ```text\n code\n ```\n"), ("* ```\n code\n ```\n", "* ```text\n code\n ```\n"), ("+ ```\n code\n ```\n", "+ ```text\n code\n ```\n"), ("1. ```\n code\n ```\n", "1. ```text\n code\n ```\n"), ("1) ```\n code\n ```\n", "1) ```text\n code\n ```\n"), (" - ```\n code\n ```\n", " - ```text\n code\n ```\n"), ("- - ```\n code\n ```\n", "- - ```text\n code\n ```\n"), ("> - ```\n> code\n> ```\n", "> - ```text\n> code\n> ```\n"), ] { assert_eq!(run_fix(input).unwrap(), expected, "input: {input:?}"); } } #[test] fn test_fix_list_marker_tilde_and_longer_fences() { // The marker is derived from the line, so a tilde fence or a run longer // than three characters must be measured at its real position instead of // falling back to a three-backtick default. let tilde = run_fix("- ~~~\n code\n ~~~\n").unwrap(); assert_eq!(tilde, "- ~~~text\n code\n ~~~\n"); let longer_tilde = run_fix("- ~~~~\n code\n ~~~~\n").unwrap(); assert_eq!(longer_tilde, "- ~~~~text\n code\n ~~~~\n"); let longer_backtick = run_fix("- ````\n code\n ````\n").unwrap(); assert_eq!(longer_backtick, "- ````text\n code\n ````\n"); } #[test] fn test_fix_list_marker_fence_is_idempotent() { let content = "- ```\n root/\n nested\n ```\n"; let once = run_fix(content).unwrap(); let twice = run_fix(&once).unwrap(); assert_eq!(once, twice); assert_eq!(once, "- ```text\n root/\n nested\n ```\n"); } #[test] fn test_fix_list_marker_fence_with_language_untouched() { let content = "- ```rust\n code\n ```\n"; assert!(run_check(content).unwrap().is_empty()); assert_eq!(run_fix(content).unwrap(), content); } #[test] fn test_fix_blockquote_empty_fence_is_idempotent() { // Re-running the fix on its own output must be a no-op. let content = "> ```\n> root/\n> nested\n> ```\n"; let once = run_fix(content).unwrap(); let twice = run_fix(&once).unwrap(); assert_eq!(once, twice); assert_eq!(once, "> ```text\n> root/\n> nested\n> ```\n"); } // ========================================================================= // Consistent mode tests // ========================================================================= #[test] fn test_consistent_mode_detects_inconsistency() { let content = r#"```bash echo hi ``` ```sh echo there ``` ```bash echo again ``` "#; let config = MD040Config { style: LanguageStyle::Consistent, ..Default::default() }; let result = run_check_with_config(content, config).unwrap(); assert_eq!(result.len(), 1); assert!(result[0].message.contains("Inconsistent")); assert!(result[0].message.contains("sh")); assert!(result[0].message.contains("bash")); } #[test] fn test_consistent_mode_fix_normalizes() { let content = r#"```bash echo hi ``` ```sh echo there ``` ```bash echo again ``` "#; let config = MD040Config { style: LanguageStyle::Consistent, ..Default::default() }; let fixed = run_fix_with_config(content, config).unwrap(); assert_eq!(fixed.matches("```bash").count(), 3); assert_eq!(fixed.matches("```sh").count(), 0); } #[test] fn test_consistent_mode_tie_break_uses_curated_default() { // When there's a tie (1 bash, 1 sh), should use curated default (bash) let content = r#"```bash echo hi ``` ```sh echo there ``` "#; let config = MD040Config { style: LanguageStyle::Consistent, ..Default::default() }; let fixed = run_fix_with_config(content, config).unwrap(); // bash is the curated default for Shell assert_eq!(fixed.matches("```bash").count(), 2); } #[test] fn test_consistent_mode_with_preferred_alias() { let content = r#"```bash echo hi ``` ```sh echo there ``` "#; let mut preferred = HashMap::new(); preferred.insert("Shell".to_string(), "sh".to_string()); let config = MD040Config { style: LanguageStyle::Consistent, preferred_aliases: preferred, ..Default::default() }; let fixed = run_fix_with_config(content, config).unwrap(); assert_eq!(fixed.matches("```sh").count(), 2); assert_eq!(fixed.matches("```bash").count(), 0); } #[test] fn test_consistent_mode_fix_inside_blockquote() { // Consistent-mode normalization must reach fences inside blockquotes. // With one `bash` and one `sh`, the curated default `bash` wins. let content = "> ```bash\n> echo hi\n> ```\n>\n> ```sh\n> echo there\n> ```\n"; let config = MD040Config { style: LanguageStyle::Consistent, ..Default::default() }; let fixed = run_fix_with_config(content, config).unwrap(); assert_eq!( fixed, "> ```bash\n> echo hi\n> ```\n>\n> ```bash\n> echo there\n> ```\n" ); } #[test] fn test_consistent_mode_ignores_disabled_blocks() { let content = r#"```bash echo hi ``` ```sh echo there ``` ```sh echo again ``` "#; let config = MD040Config { style: LanguageStyle::Consistent, ..Default::default() }; let result = run_check_with_config(content, config).unwrap(); assert!(result.is_empty(), "Disabled blocks should not affect consistency"); } #[test] fn test_disable_comment_naming_the_rule_by_alias_disables_it() { let content = r#"```bash echo hi ``` ```sh echo there ``` ```sh echo again ``` "#; let config = MD040Config { style: LanguageStyle::Consistent, ..Default::default() }; let result = run_check_with_config(content, config.clone()).unwrap(); assert!( result.is_empty(), "an alias names the same rule as the ID does: {result:?}" ); let names_another_rule = content.replace("fenced-code-language", "line-length"); let result = run_check_with_config(&names_another_rule, config).unwrap(); assert_eq!( result.len(), 1, "a directive naming another rule leaves the sh blocks voting: {result:?}" ); } #[test] fn test_a_line_scoped_directive_takes_the_fence_out_of_the_vote() { let directive = "\n"; let content = format!("```bash\necho one\n```\n\n{directive}```sh\necho two\n```\n\n{directive}```sh\necho three\n```\n"); let config = MD040Config { style: LanguageStyle::Consistent, ..Default::default() }; let without_directives = content.replace(directive, ""); assert_eq!( run_check_with_config(&without_directives, config.clone()) .unwrap() .len(), 1, "control: two sh fences outvote the bash one" ); // A fence the rule is disabled for cannot decide the label for the fences // that are still checked, so bash stands alone and is left as it is. let result = run_check_with_config(&content, config).unwrap(); assert!(result.is_empty(), "a disabled fence casts no vote: {result:?}"); } #[test] fn test_a_directive_shown_inside_a_code_block_disables_nothing() { // A document explaining the directive quotes it as sample text. Quoted or // not, the sh blocks outvote the bash one, so the bash fence is reported. let sample = "```text\n\n```\n"; let blocks = "\n```bash\necho one\n```\n\n```sh\necho two\n```\n\n```sh\necho three\n```\n"; let config = MD040Config { style: LanguageStyle::Consistent, ..Default::default() }; let without_sample = run_check_with_config(blocks, config.clone()).unwrap(); assert_eq!(without_sample.len(), 1, "control: the bash fence is reported"); for name in ["MD040", "fenced-code-language"] { let content = format!("{}{blocks}", sample.replace("RULE", name)); let result = run_check_with_config(&content, config.clone()).unwrap(); assert_eq!( result.len(), 1, "`{name}` inside a code block is sample text, not a directive: {result:?}" ); } } #[test] fn test_fix_preserves_attributes() { let content = "```sh {.highlight}\ncode\n```\n\n```bash\nmore\n```"; let config = MD040Config { style: LanguageStyle::Consistent, ..Default::default() }; let fixed = run_fix_with_config(content, config).unwrap(); assert!(fixed.contains("```bash {.highlight}")); } #[test] fn test_fix_preserves_spacing_before_label() { let content = "```bash\ncode\n```\n\n``` sh {.highlight}\ncode\n```"; let config = MD040Config { style: LanguageStyle::Consistent, ..Default::default() }; let fixed = run_fix_with_config(content, config).unwrap(); assert!(fixed.contains("``` bash {.highlight}")); assert!(!fixed.contains("``` sh {.highlight}")); } // ========================================================================= // Allowlist/denylist tests // ========================================================================= #[test] fn test_allowlist_blocks_unlisted() { let content = "```java\ncode\n```"; let config = MD040Config { allowed_languages: vec!["Python".to_string(), "Shell".to_string()], ..Default::default() }; let result = run_check_with_config(content, config).unwrap(); assert_eq!(result.len(), 1); assert!(result[0].message.contains("not in the allowed list")); } #[test] fn test_allowlist_allows_listed() { let content = "```python\ncode\n```"; let config = MD040Config { allowed_languages: vec!["Python".to_string()], ..Default::default() }; let result = run_check_with_config(content, config).unwrap(); assert!(result.is_empty()); } #[test] fn test_allowlist_blocks_unknown_language() { let content = "```mysterylang\ncode\n```"; let config = MD040Config { allowed_languages: vec!["Python".to_string()], ..Default::default() }; let result = run_check_with_config(content, config).unwrap(); assert_eq!(result.len(), 1); assert!(result[0].message.contains("allowed list")); } #[test] fn test_allowlist_case_insensitive() { let content = "```python\ncode\n```"; let config = MD040Config { allowed_languages: vec!["PYTHON".to_string()], ..Default::default() }; let result = run_check_with_config(content, config).unwrap(); assert!(result.is_empty()); } #[test] fn test_denylist_blocks_listed() { let content = "```java\ncode\n```"; let config = MD040Config { disallowed_languages: vec!["Java".to_string()], ..Default::default() }; let result = run_check_with_config(content, config).unwrap(); assert_eq!(result.len(), 1); assert!(result[0].message.contains("disallowed")); } #[test] fn test_denylist_allows_unlisted() { let content = "```python\ncode\n```"; let config = MD040Config { disallowed_languages: vec!["Java".to_string()], ..Default::default() }; let result = run_check_with_config(content, config).unwrap(); assert!(result.is_empty()); } #[test] fn test_allowlist_takes_precedence_over_denylist() { let content = "```python\ncode\n```"; let config = MD040Config { allowed_languages: vec!["Python".to_string()], disallowed_languages: vec!["Python".to_string()], // Should be ignored ..Default::default() }; let result = run_check_with_config(content, config).unwrap(); assert!(result.is_empty()); } // ========================================================================= // Unknown language tests // ========================================================================= #[test] fn test_unknown_language_ignore_default() { let content = "```mycustomlang\ncode\n```"; let result = run_check(content).unwrap(); assert!(result.is_empty(), "Unknown languages ignored by default"); } #[test] fn test_unknown_language_warn() { let content = "```mycustomlang\ncode\n```"; let config = MD040Config { unknown_language_action: UnknownLanguageAction::Warn, ..Default::default() }; let result = run_check_with_config(content, config).unwrap(); assert_eq!(result.len(), 1); assert!(result[0].message.contains("Unknown language")); assert!(result[0].message.contains("mycustomlang")); assert_eq!(result[0].severity, Severity::Warning); } /// Regression test for a category of bugs, not one instance: rumdl's generated /// Linguist alias table must recognize every high-traffic language alias, not /// just the exact one reported (`py`). Each alias below is confirmed present in /// GitHub Linguist's current `aliases:` list for its language (`py` and `py3` /// were added upstream after the `e51c2270` generation pin, see the header /// comment in `src/linguist_data.rs`); none of them should ever trigger an /// unknown-language warning. #[test] fn test_unknown_language_warn_known_aliases_not_flagged() { let known_aliases = [ "py", "python", "sh", "bash", "shell", "zsh", "js", "javascript", "ts", "typescript", "rb", "ruby", "rs", "rust", "yml", "yaml", "cpp", "c++", "csharp", "golang", "dockerfile", "jsonc", "kotlin", ]; for alias in known_aliases { let content = format!("```{alias}\ncode\n```"); let config = MD040Config { unknown_language_action: UnknownLanguageAction::Warn, ..Default::default() }; let result = run_check_with_config(&content, config).unwrap(); assert!( result.is_empty(), "known Linguist alias '{alias}' should not be flagged as unknown: {result:?}" ); } } /// GitHub also accepts file extensions as fence labels (a ```pytb block /// renders with the Python-traceback grammar even though `pytb` appears /// only in Linguist's `extensions:`, never `aliases:`), so extension /// labels must not be flagged as unknown either. #[test] fn test_unknown_language_extension_labels_not_flagged() { for label in ["pytb", "cs", "kt", "pl", "pyi", "cjs", "mts"] { let content = format!("```{label}\ncode\n```"); let config = MD040Config { unknown_language_action: UnknownLanguageAction::Error, ..Default::default() }; let result = run_check_with_config(&content, config).unwrap(); assert!( result.is_empty(), "Linguist file extension '{label}' should not be flagged as unknown: {result:?}" ); } } #[test] fn test_unknown_language_error() { let content = "```mycustomlang\ncode\n```"; let config = MD040Config { unknown_language_action: UnknownLanguageAction::Error, ..Default::default() }; let result = run_check_with_config(content, config).unwrap(); assert_eq!(result.len(), 1); assert!(result[0].message.contains("Unknown language")); assert_eq!(result[0].severity, Severity::Error); } // ========================================================================= // Config validation tests // ========================================================================= #[test] fn test_invalid_preferred_alias_detected() { let mut preferred = HashMap::new(); preferred.insert("Shell".to_string(), "invalid_alias".to_string()); let config = MD040Config { style: LanguageStyle::Consistent, preferred_aliases: preferred, ..Default::default() }; let rule = MD040FencedCodeLanguage::with_config(config); let errors = rule.validate_config(); assert_eq!(errors.len(), 1); assert!(errors[0].contains("Invalid alias")); assert!(errors[0].contains("invalid_alias")); } #[test] fn test_invalid_preferred_alias_is_not_normalized_to() { // An alias the language does not have is a configuration error, so // fixing to it would rewrite valid labels into an invalid one. let content = "```sh\necho one\n```\n\n```bash\necho two\n```\n"; let ctx = LintContext::new(content, crate::config::MarkdownFlavor::Standard, None); let rule = MD040FencedCodeLanguage::with_config(MD040Config { style: LanguageStyle::Consistent, preferred_aliases: HashMap::from([("Shell".to_string(), "invalid_alias".to_string())]), ..Default::default() }); let fixed = rule.fix(&ctx).unwrap(); assert!( !fixed.contains("invalid_alias"), "an invalid alias must not reach the document, got:\n{fixed}" ); assert!( rule.check(&ctx) .unwrap() .iter() .any(|w| w.message.contains("Invalid alias")), "the invalid alias is still reported" ); // Control: a valid alias for the same language is still normalized to. let rule = MD040FencedCodeLanguage::with_config(MD040Config { style: LanguageStyle::Consistent, preferred_aliases: HashMap::from([("Shell".to_string(), "zsh".to_string())]), ..Default::default() }); assert_eq!( rule.fix(&ctx).unwrap(), "```zsh\necho one\n```\n\n```zsh\necho two\n```\n" ); } #[test] fn test_unknown_language_in_preferred_aliases_detected() { let mut preferred = HashMap::new(); preferred.insert("NotARealLanguage".to_string(), "nope".to_string()); let config = MD040Config { style: LanguageStyle::Consistent, preferred_aliases: preferred, ..Default::default() }; let rule = MD040FencedCodeLanguage::with_config(config); let errors = rule.validate_config(); assert_eq!(errors.len(), 1); assert!(errors[0].contains("Unknown language")); } #[test] fn test_valid_preferred_alias_accepted() { let mut preferred = HashMap::new(); preferred.insert("Shell".to_string(), "bash".to_string()); preferred.insert("JavaScript".to_string(), "js".to_string()); let config = MD040Config { style: LanguageStyle::Consistent, preferred_aliases: preferred, ..Default::default() }; let rule = MD040FencedCodeLanguage::with_config(config); let errors = rule.validate_config(); assert!(errors.is_empty()); } #[test] fn test_config_error_uses_valid_line_column() { let config = md040_config::MD040Config { preferred_aliases: { let mut map = std::collections::HashMap::new(); map.insert("Shell".to_string(), "invalid_alias".to_string()); map }, ..Default::default() }; let rule = MD040FencedCodeLanguage::with_config(config); let content = "```shell\necho hello\n```"; let ctx = crate::lint_context::LintContext::new(content, crate::config::MarkdownFlavor::Standard, None); let result = rule.check(&ctx).unwrap(); // Find the config error warning let config_error = result.iter().find(|w| w.message.contains("[config error]")); assert!(config_error.is_some(), "Should have a config error warning"); let warning = config_error.unwrap(); // Line and column should be 1-indexed (not 0) assert!( warning.line >= 1, "Config error line should be >= 1, got {}", warning.line ); assert!( warning.column >= 1, "Config error column should be >= 1, got {}", warning.column ); } // ========================================================================= // custom-languages tests // ========================================================================= fn custom_languages_config(declared: &[&str]) -> MD040Config { MD040Config { unknown_language_action: UnknownLanguageAction::Error, custom_languages: declared.iter().map(|s| (*s).to_string()).collect(), ..Default::default() } } #[test] fn test_declared_custom_language_is_not_unknown() { let content = "```cddl\nfoo = tstr\n```\n"; let flagged = run_check_with_config(content, custom_languages_config(&[])).unwrap(); assert_eq!(flagged.len(), 1, "an undeclared unknown label must still be reported"); assert!(flagged[0].message.contains("Unknown language 'cddl'")); let accepted = run_check_with_config(content, custom_languages_config(&["cddl"])).unwrap(); assert!(accepted.is_empty(), "a declared label must be accepted: {accepted:?}"); } #[test] fn test_custom_language_matches_a_label_case_insensitively() { let content = "```CDDL\nfoo = tstr\n```\n"; let result = run_check_with_config(content, custom_languages_config(&["cddl"])).unwrap(); assert!(result.is_empty(), "label case must not matter: {result:?}"); } #[test] fn test_custom_language_does_not_shadow_linguist() { // Declaring a label Linguist knows leaves Linguist's answer in place, so // `sh` still resolves to Shell and normalizes with the rest of that language. let content = "```sh\necho hi\n```\n\n```bash\necho there\n```\n\n```bash\necho again\n```\n"; let config = MD040Config { style: LanguageStyle::Consistent, custom_languages: vec!["sh".to_string()], ..Default::default() }; let result = run_check_with_config(content, config.clone()).unwrap(); assert_eq!(result.len(), 1, "sh must still be judged against Shell: {result:?}"); assert!(result[0].message.contains("use 'bash'")); let fixed = run_fix_with_config(content, config).unwrap(); assert!(!fixed.contains("```sh\n")); } #[test] fn test_custom_language_normalizes_under_consistent_style() { let content = "```cddl\nfoo = tstr\n```\n\n```CDDL\nbar = int\n```\n"; let config = MD040Config { style: LanguageStyle::Consistent, custom_languages: vec!["cddl".to_string()], ..Default::default() }; let result = run_check_with_config(content, config.clone()).unwrap(); assert_eq!(result.len(), 1, "the two spellings are one language: {result:?}"); // Both spellings appear once, and the declared spelling breaks the tie. let fixed = run_fix_with_config(content, config).unwrap(); assert!(fixed.contains("```cddl")); assert!(!fixed.contains("```CDDL")); } #[test] fn test_custom_language_participates_in_allowed_and_disallowed_lists() { let content = "```cddl\nfoo = tstr\n```\n"; let allowed = run_check_with_config( content, MD040Config { allowed_languages: vec!["cddl".to_string()], custom_languages: vec!["cddl".to_string()], ..Default::default() }, ) .unwrap(); assert!(allowed.is_empty(), "an allowed custom language passes: {allowed:?}"); let disallowed = run_check_with_config( content, MD040Config { disallowed_languages: vec!["cddl".to_string()], custom_languages: vec!["cddl".to_string()], ..Default::default() }, ) .unwrap(); assert_eq!(disallowed.len(), 1, "a disallowed custom language is reported"); assert!(disallowed[0].message.contains("is disallowed")); } #[test] fn test_undeclared_language_is_not_allowed_by_the_allowlist() { // Without a declaration the label resolves to nothing, so the allowlist // cannot admit it even when its own name is on the list. let result = run_check_with_config( "```cddl\nfoo = tstr\n```\n", MD040Config { allowed_languages: vec!["cddl".to_string()], ..Default::default() }, ) .unwrap(); assert_eq!(result.len(), 1); assert!(result[0].message.contains("is not in the allowed list")); } #[test] fn test_unusable_custom_language_entries_are_config_errors() { let rule = MD040FencedCodeLanguage::with_config(custom_languages_config(&["c ddl", "cddl ", " cddl", " ", "cddl"])); let errors = rule.validate_config(); assert_eq!(errors.len(), 4, "only the unusable entries are reported: {errors:?}"); assert_eq!( errors.iter().filter(|e| e.contains("contains whitespace")).count(), 3, "whitespace around an entry is as unmatchable as whitespace inside it: {errors:?}" ); assert!(errors.iter().any(|e| e.contains("Empty entry in custom-languages"))); } #[test] fn test_custom_language_with_surrounding_whitespace_does_not_match_a_label() { let content = "```cddl\nfoo = int\n```"; let result = run_check_with_config(content, custom_languages_config(&["cddl "])).unwrap(); assert_eq!( result.len(), 2, "the label stays unknown and the entry is reported: {result:?}" ); assert!(result[0].message.contains("[config error]")); assert!(result[0].message.contains("contains whitespace")); assert!(result[1].message.contains("Unknown language 'cddl'")); } #[test] fn test_preferred_alias_for_a_custom_language() { let accepted = MD040FencedCodeLanguage::with_config(MD040Config { preferred_aliases: HashMap::from([("CDDL".to_string(), "cddl".to_string())]), custom_languages: vec!["cddl".to_string()], ..Default::default() }); assert!( accepted.validate_config().is_empty(), "a spelling of the declared name is a valid preference" ); let rejected = MD040FencedCodeLanguage::with_config(MD040Config { preferred_aliases: HashMap::from([("cddl".to_string(), "cbor-dl".to_string())]), custom_languages: vec!["cddl".to_string()], ..Default::default() }); let errors = rejected.validate_config(); assert_eq!(errors.len(), 1, "a custom language has no aliases: {errors:?}"); assert!(errors[0].contains("Invalid alias 'cbor-dl' for custom language 'cddl'")); // The rejected preference does not reach the document either: labels // normalize to the declared spelling, not to the invalid alias. let ctx = LintContext::new( "```cddl\nfoo = tstr\n```\n\n```CDDL\nbar = int\n```\n", crate::config::MarkdownFlavor::Standard, None, ); let rejected = MD040FencedCodeLanguage::with_config(MD040Config { style: LanguageStyle::Consistent, preferred_aliases: HashMap::from([("cddl".to_string(), "cbor-dl".to_string())]), custom_languages: vec!["cddl".to_string()], ..Default::default() }); assert_eq!( rejected.fix(&ctx).unwrap(), "```cddl\nfoo = tstr\n```\n\n```cddl\nbar = int\n```\n" ); // Control: an accepted preference does drive normalization. let accepted = MD040FencedCodeLanguage::with_config(MD040Config { style: LanguageStyle::Consistent, preferred_aliases: HashMap::from([("cddl".to_string(), "CDDL".to_string())]), custom_languages: vec!["cddl".to_string()], ..Default::default() }); assert_eq!( accepted.fix(&ctx).unwrap(), "```CDDL\nfoo = tstr\n```\n\n```CDDL\nbar = int\n```\n" ); } // ========================================================================= // Linguist resolution tests // ========================================================================= #[test] fn test_linguist_resolution() { assert_eq!(resolve_canonical("bash"), Some("Shell")); assert_eq!(resolve_canonical("sh"), Some("Shell")); assert_eq!(resolve_canonical("zsh"), Some("Shell")); assert_eq!(resolve_canonical("js"), Some("JavaScript")); assert_eq!(resolve_canonical("python"), Some("Python")); assert_eq!(resolve_canonical("unknown_lang"), None); } #[test] fn test_linguist_resolution_case_insensitive() { assert_eq!(resolve_canonical("BASH"), Some("Shell")); assert_eq!(resolve_canonical("Bash"), Some("Shell")); assert_eq!(resolve_canonical("Python"), Some("Python")); assert_eq!(resolve_canonical("PYTHON"), Some("Python")); } #[test] fn test_alias_validation() { use crate::linguist_data::is_valid_alias; assert!(is_valid_alias("Shell", "bash")); assert!(is_valid_alias("Shell", "sh")); assert!(is_valid_alias("Shell", "zsh")); assert!(!is_valid_alias("Shell", "python")); assert!(!is_valid_alias("Shell", "invalid")); } #[test] fn test_default_alias() { assert_eq!(default_alias("Shell"), Some("bash")); assert_eq!(default_alias("JavaScript"), Some("js")); assert_eq!(default_alias("Python"), Some("python")); } // ========================================================================= // Edge case tests // ========================================================================= #[test] fn test_mixed_case_labels_normalized() { let content = r#"```BASH echo hi ``` ```Bash echo there ``` ```bash echo again ``` "#; let config = MD040Config { style: LanguageStyle::Consistent, ..Default::default() }; // All should resolve to Shell, most prevalent should win let result = run_check_with_config(content, config).unwrap(); // "bash" appears 1x, "Bash" appears 1x, "BASH" appears 1x // All are different strings, so there's a 3-way tie // Should pick curated default "bash" or alphabetically first assert!(result.len() >= 2, "Should flag at least 2 inconsistent labels"); } #[test] fn test_multiple_languages_independent() { let content = r#"```bash shell code ``` ```python python code ``` ```sh more shell ``` ```python3 more python ``` "#; let config = MD040Config { style: LanguageStyle::Consistent, ..Default::default() }; let result = run_check_with_config(content, config).unwrap(); // Should have 2 warnings: one for sh (inconsistent with bash) and one for python3 (inconsistent with python) assert_eq!(result.len(), 2); } #[test] fn test_tilde_fences() { let content = r#"~~~bash echo hi ~~~ ~~~sh echo there ~~~ "#; let config = MD040Config { style: LanguageStyle::Consistent, ..Default::default() }; let result = run_check_with_config(content, config.clone()).unwrap(); assert_eq!(result.len(), 1); let fixed = run_fix_with_config(content, config).unwrap(); assert!(fixed.contains("~~~bash")); assert!(!fixed.contains("~~~sh")); } #[test] fn test_longer_fence_markers_preserved() { let content = "````sh\ncode\n````\n\n```bash\ncode\n```"; let config = MD040Config { style: LanguageStyle::Consistent, ..Default::default() }; let fixed = run_fix_with_config(content, config).unwrap(); assert!(fixed.contains("````bash")); assert!(fixed.contains("```bash")); } #[test] fn test_empty_document() { let result = run_check("").unwrap(); assert!(result.is_empty()); } #[test] fn test_no_code_blocks() { let content = "# Just a heading\n\nSome text."; let result = run_check(content).unwrap(); assert!(result.is_empty()); } #[test] fn test_single_code_block_no_inconsistency() { let content = "```bash\necho hi\n```"; let config = MD040Config { style: LanguageStyle::Consistent, ..Default::default() }; let result = run_check_with_config(content, config).unwrap(); assert!(result.is_empty(), "Single block has no inconsistency"); } #[test] fn test_idempotent_fix() { let content = r#"```bash echo hi ``` ```sh echo there ``` "#; let config = MD040Config { style: LanguageStyle::Consistent, ..Default::default() }; let fixed1 = run_fix_with_config(content, config.clone()).unwrap(); let fixed2 = run_fix_with_config(&fixed1, config).unwrap(); assert_eq!(fixed1, fixed2, "Fix should be idempotent"); } // ========================================================================= // MkDocs superfences tests // ========================================================================= #[test] fn test_mkdocs_superfences_attribute_in_blockquote() { // A superfences attribute fence (no language) inside a blockquote must be // recognized just like a top-level one and not flagged as missing language. let content = "> ```title=\"Example\"\n> echo hi\n> ```\n"; let result = run_check_mkdocs(content).unwrap(); assert!( result.is_empty(), "MkDocs superfences attribute inside a blockquote should not require language: {result:?}" ); } #[test] fn test_mkdocs_superfences_title_only() { // title= attribute without language should not warn in MkDocs flavor let content = r#"```title="Example" echo hi ``` "#; let result = run_check_mkdocs(content).unwrap(); assert!( result.is_empty(), "MkDocs superfences with title= should not require language" ); } #[test] fn test_mkdocs_superfences_hl_lines() { // hl_lines= attribute without language should not warn let content = r#"```hl_lines="1 2" line 1 line 2 ``` "#; let result = run_check_mkdocs(content).unwrap(); assert!( result.is_empty(), "MkDocs superfences with hl_lines= should not require language" ); } #[test] fn test_mkdocs_superfences_linenums() { // linenums= attribute without language should not warn let content = r#"```linenums="1" line 1 line 2 ``` "#; let result = run_check_mkdocs(content).unwrap(); assert!( result.is_empty(), "MkDocs superfences with linenums= should not require language" ); } #[test] fn test_mkdocs_superfences_class() { // Custom class (starting with .) should not warn let content = r#"```.my-class some text ``` "#; let result = run_check_mkdocs(content).unwrap(); assert!( result.is_empty(), "MkDocs superfences with .class should not require language" ); } #[test] fn test_mkdocs_superfences_id() { // Custom ID (starting with #) should not warn let content = r#"```#my-id some text ``` "#; let result = run_check_mkdocs(content).unwrap(); assert!( result.is_empty(), "MkDocs superfences with #id should not require language" ); } #[test] fn test_mkdocs_superfences_with_language() { // Language with superfences attributes should work fine let content = r#"```python title="Example" hl_lines="1" print("hello") ``` "#; let result = run_check_mkdocs(content).unwrap(); assert!(result.is_empty(), "Code block with language and attrs should pass"); } #[test] fn test_standard_flavor_no_special_handling() { // In Standard flavor, title= should still warn let content = r#"```title="Example" echo hi ``` "#; let result = run_check(content).unwrap(); assert_eq!( result.len(), 1, "Standard flavor should warn about title= without language" ); } #[test] fn test_pandoc_raw_block_skipped_under_pandoc_flavor() { // ```{=html} raw blocks are valid Pandoc syntax and should not trigger MD040 // under Pandoc flavor. let rule = MD040FencedCodeLanguage::default(); let content = "```{=html}\n
raw html
\n```\n"; let ctx = crate::lint_context::LintContext::new(content, crate::config::MarkdownFlavor::Pandoc, None); let result = rule.check(&ctx).unwrap(); assert!( result.is_empty(), "MD040 should skip Pandoc raw blocks ({{=html}}) under Pandoc flavor: {result:?}" ); } #[test] fn test_pandoc_raw_block_skipped_under_quarto_flavor() { // ```{=html} raw blocks are also valid under Quarto (which is Pandoc-compatible). let rule = MD040FencedCodeLanguage::default(); let content = "```{=html}\n
raw html
\n```\n"; let ctx = crate::lint_context::LintContext::new(content, crate::config::MarkdownFlavor::Quarto, None); let result = rule.check(&ctx).unwrap(); assert!( result.is_empty(), "MD040 should skip Pandoc raw blocks ({{=html}}) under Quarto flavor: {result:?}" ); } /// Pandoc raw blocks like ```` ```{=html} ```` declare an output target, /// not a missing language. MD040 must accept them under Pandoc. #[test] fn test_pandoc_accepts_raw_html_block() { use crate::config::MarkdownFlavor; let rule = MD040FencedCodeLanguage::default(); let content = "```{=html}\n
raw
\n```\n"; let ctx = LintContext::new(content, MarkdownFlavor::Pandoc, None); let result = rule.check(&ctx).unwrap(); assert!(result.is_empty(), "MD040 should accept ```{{=html}}```: {result:?}"); } /// Under Pandoc (not Quarto), `{r}` is NOT a valid raw-format declaration — /// it's a Quarto-only execution syntax that should be flagged as missing language. #[test] fn test_pandoc_rejects_quarto_exec_blocks() { use crate::config::MarkdownFlavor; let rule = MD040FencedCodeLanguage::default(); let content = "```{r}\nsummary(data)\n```\n"; let ctx = LintContext::new(content, MarkdownFlavor::Pandoc, None); let result = rule.check(&ctx).unwrap(); assert!( !result.is_empty(), "MD040 under Pandoc should flag `{{r}}` (Quarto-only)" ); } /// Under Quarto, `{r}` IS valid — Quarto exec syntax. Must not be flagged. #[test] fn test_quarto_still_accepts_exec_block() { use crate::config::MarkdownFlavor; let rule = MD040FencedCodeLanguage::default(); let content = "```{r}\nsummary(data)\n```\n"; let ctx = LintContext::new(content, MarkdownFlavor::Quarto, None); let result = rule.check(&ctx).unwrap(); assert!( result.is_empty(), "MD040 under Quarto should accept `{{r}}`: {result:?}" ); } #[test] fn test_quarto_exec_block_skipped_under_quarto_only() { // ```{r} exec chunks are Quarto-specific syntax accepted only under the Quarto flavor. // Under Pandoc flavor, `{r}` is not a valid Pandoc raw-format declaration (those use // `{=format}` syntax), so MD040 flags it as missing a real language identifier. let rule = MD040FencedCodeLanguage::default(); let content = "```{r}\n1 + 1\n```\n"; let ctx_quarto = crate::lint_context::LintContext::new(content, crate::config::MarkdownFlavor::Quarto, None); let result_quarto = rule.check(&ctx_quarto).unwrap(); assert!( result_quarto.is_empty(), "MD040 should skip Quarto exec chunks under Quarto flavor: {result_quarto:?}" ); // Under Pandoc, `{r}` is unrecognized brace syntax — not a valid Pandoc raw block. // MD040 treats it as a missing language. let ctx_pandoc = crate::lint_context::LintContext::new(content, crate::config::MarkdownFlavor::Pandoc, None); let result_pandoc = rule.check(&ctx_pandoc).unwrap(); assert!( !result_pandoc.is_empty(), "MD040 should flag `{{r}}` under Pandoc as missing a real language" ); } /// Pandoc code-attribute syntax `{.lang}` declares the language and is valid under /// both Pandoc and Quarto. MD040 must accept it. #[test] fn test_pandoc_class_attr_accepted_as_language() { use crate::config::MarkdownFlavor; let rule = MD040FencedCodeLanguage::default(); let content = "```{.python}\nprint(\"hi\")\n```\n"; let ctx_pandoc = LintContext::new(content, MarkdownFlavor::Pandoc, None); let result_pandoc = rule.check(&ctx_pandoc).unwrap(); assert!( result_pandoc.is_empty(), "MD040 under Pandoc should accept ```{{.python}}``` as language declaration: {result_pandoc:?}" ); let ctx_quarto = LintContext::new(content, MarkdownFlavor::Quarto, None); let result_quarto = rule.check(&ctx_quarto).unwrap(); assert!( result_quarto.is_empty(), "MD040 under Quarto should accept ```{{.python}}``` as language declaration: {result_quarto:?}" ); } /// Pandoc code attributes can include multiple classes plus key=value pairs. /// The first class is the language; trailing attributes (e.g. `.numberLines`) are decoration. #[test] fn test_pandoc_class_attr_with_extra_attributes_accepted() { use crate::config::MarkdownFlavor; let rule = MD040FencedCodeLanguage::default(); let content = "```{.haskell .numberLines}\nmain = putStrLn \"hi\"\n```\n"; let ctx_pandoc = LintContext::new(content, MarkdownFlavor::Pandoc, None); let result_pandoc = rule.check(&ctx_pandoc).unwrap(); assert!( result_pandoc.is_empty(), "MD040 under Pandoc should accept ```{{.haskell .numberLines}}```: {result_pandoc:?}" ); let ctx_quarto = LintContext::new(content, MarkdownFlavor::Quarto, None); let result_quarto = rule.check(&ctx_quarto).unwrap(); assert!( result_quarto.is_empty(), "MD040 under Quarto should accept ```{{.haskell .numberLines}}```: {result_quarto:?}" ); } /// Pandoc code attributes can include id (`#myid`) and key=value attributes. /// As long as a `.class` is present, the block declares a language. #[test] fn test_pandoc_class_attr_with_id_and_keyvalue_accepted() { use crate::config::MarkdownFlavor; let rule = MD040FencedCodeLanguage::default(); let content = "```{#snippet .python startFrom=\"10\"}\nprint(1)\n```\n"; let ctx_pandoc = LintContext::new(content, MarkdownFlavor::Pandoc, None); let result_pandoc = rule.check(&ctx_pandoc).unwrap(); assert!( result_pandoc.is_empty(), "MD040 under Pandoc should accept ```{{#snippet .python …}}```: {result_pandoc:?}" ); } /// Standard flavor knows nothing about Pandoc code attributes — they remain /// unrecognized brace syntax and must still be flagged as missing-language. #[test] fn test_standard_still_flags_pandoc_class_attr() { use crate::config::MarkdownFlavor; let rule = MD040FencedCodeLanguage::default(); let content = "```{.python}\nprint(\"hi\")\n```\n"; let ctx_standard = LintContext::new(content, MarkdownFlavor::Standard, None); let result_standard = rule.check(&ctx_standard).unwrap(); assert!( !result_standard.is_empty(), "MD040 under Standard should still flag ```{{.python}}``` (no Pandoc support)" ); } /// A brace block with only an id (`{#myid}`) and no class declares no language. /// Even under Pandoc this must remain flagged. #[test] fn test_pandoc_id_only_attr_still_flagged() { use crate::config::MarkdownFlavor; let rule = MD040FencedCodeLanguage::default(); let content = "```{#myid}\ncode here\n```\n"; let ctx_pandoc = LintContext::new(content, MarkdownFlavor::Pandoc, None); let result_pandoc = rule.check(&ctx_pandoc).unwrap(); assert!( !result_pandoc.is_empty(), "MD040 under Pandoc should flag ```{{#myid}}``` — id without class declares no language" ); } /// Empty `{}` braces declare nothing and must still be flagged under any flavor. #[test] fn test_pandoc_empty_braces_still_flagged() { use crate::config::MarkdownFlavor; let rule = MD040FencedCodeLanguage::default(); let content = "```{}\ncode here\n```\n"; let ctx_pandoc = LintContext::new(content, MarkdownFlavor::Pandoc, None); let result_pandoc = rule.check(&ctx_pandoc).unwrap(); assert!( !result_pandoc.is_empty(), "MD040 under Pandoc should flag ```{{}}``` (no language declared)" ); } #[test] fn test_mdg_reports_doc_string_media_type_without_fixing_it() { use crate::config::MarkdownFlavor; // A language label becomes the Doc String media type. MD040 still // reports an omitted value under MDG, but must not invent `text` and // change the Gherkin AST. let rule = MD040FencedCodeLanguage::default(); for content in [ "* Given the following message:\n\n ```\n hello\n ```\n", "* Given the following message:\n\n ~~~\n hello\n ~~~\n", ] { let mdg_ctx = LintContext::new(content, MarkdownFlavor::MDG, None); let standard_ctx = LintContext::new(content, MarkdownFlavor::Standard, None); let warnings = rule.check(&mdg_ctx).unwrap(); assert_eq!(warnings.len(), 1, "MDG must still flag {content:?}"); assert!(warnings[0].message.contains("missing language")); assert!(warnings[0].fix.is_none(), "MDG must not offer a media-type fix"); assert_eq!(rule.fix(&mdg_ctx).unwrap(), content, "MDG must preserve {content:?}"); let standard_warnings = rule.check(&standard_ctx).unwrap(); assert_eq!(standard_warnings.len(), 1); assert!(standard_warnings[0].fix.is_some(), "Standard keeps the existing fix"); assert_eq!( rule.fix(&standard_ctx).unwrap(), content .replacen("```\n", "```text\n", 1) .replacen("~~~\n", "~~~text\n", 1), "Standard still adds its default language label" ); } } #[test] fn test_mdg_reports_inconsistent_media_type_without_normalizing_it() { use crate::config::MarkdownFlavor; let config = MD040Config { style: LanguageStyle::Consistent, preferred_aliases: HashMap::from([("JavaScript".to_string(), "javascript".to_string())]), ..MD040Config::default() }; let rule = MD040FencedCodeLanguage::with_config(config); let content = "* Given this script:\n\n ```js\n alert('ok')\n ```\n"; let mdg_ctx = LintContext::new(content, MarkdownFlavor::MDG, None); let mdg = rule.check(&mdg_ctx).unwrap(); assert_eq!(mdg.len(), 1); assert!(mdg[0].message.contains("Inconsistent language label")); assert!(mdg[0].fix.is_none()); assert_eq!(rule.fix(&mdg_ctx).unwrap(), content); let standard_ctx = LintContext::new(content, MarkdownFlavor::Standard, None); let standard = rule.check(&standard_ctx).unwrap(); assert_eq!(standard.len(), 1); assert!(standard[0].fix.is_some()); assert!(rule.fix(&standard_ctx).unwrap().contains("```javascript")); } #[test] fn test_unicode_space_around_the_info_string_is_not_trimmed() { // U+00A0 is not fence whitespace: it is part of the info string, which is // a language label here, so nothing is added or rewritten. let content = "```\u{a0}\ncode\n```\n"; let fixed = run_fix(content).unwrap(); assert!(fixed.contains('\u{a0}'), "{fixed:?}"); assert_eq!(run_fix(&fixed).unwrap(), fixed); } #[test] fn test_ascii_space_around_the_info_string_is_still_trimmed() { let content = "``` \ncode\n```\n"; assert_eq!(run_check(content).unwrap().len(), 1); assert_eq!(run_fix(content).unwrap(), "```text\ncode\n```\n"); } #[test] fn test_consistent_mode_keeps_text_after_a_unicode_space() { let config = || MD040Config { style: LanguageStyle::Consistent, ..Default::default() }; // The label ends at a space or tab: with U+00A0 the whole word is the // (unknown) label, so there is nothing to normalize and nothing is cut. let nbsp = "```bash\na\n```\n\n```bash\nb\n```\n\n```sh\u{a0}keep\nc\n```\n"; assert_eq!(run_fix_with_config(nbsp, config()).unwrap(), nbsp); // Positive control: with an ASCII space the label is `sh` and is rewritten. let ascii = nbsp.replace('\u{a0}', " "); assert_eq!( run_fix_with_config(&ascii, config()).unwrap(), ascii.replace("```sh keep", "```bash keep") ); } }