Hello World
+ +
+
+"#;
+ let config = make_test_config(true, false);
+ let rule = MD089EmbeddedHtmlFmt::from_config(&config);
+ let ctx = LintContext::new(content, MarkdownFlavor::Standard, None);
+ let formatted = rule.fix(&ctx).unwrap();
+ let lines: Vec<&str> = formatted.lines().collect();
+ assert_eq!(lines[0], r#""#);
+ assert_eq!(lines[1], " ");
+ }
+
+ #[test]
+ fn test_html_comment_format_as_markdown() {
+ let content = r#"This is a very long line of text inside an HTML block that should be wrapped to 40 columns by the HTML formatter because we configured it to do so.
+\n This is a very long line"), + "HTML paragraph content should be wrapped, got:\n{formatted}" + ); + } +} diff --git a/src/rules/mod.rs b/src/rules/mod.rs index 00b5003e..daa093a5 100644 --- a/src/rules/mod.rs +++ b/src/rules/mod.rs @@ -78,6 +78,8 @@ mod md085_paragraph_continuation_indent; mod md086_no_unclosed_comments; mod md087_unused_disable_comment; mod md088_quotes_dashes; +#[cfg(feature = "html-fmt")] +mod md089_embedded_html_fmt; pub use code_fence_utils::CodeFenceStyle; pub use md001_heading_increment::MD001HeadingIncrement; @@ -158,6 +160,8 @@ pub use md085_paragraph_continuation_indent::MD085ParagraphContinuationIndent; pub use md086_no_unclosed_comments::MD086NoUnclosedComments; pub use md087_unused_disable_comment::MD087UnusedDisableComment; pub use md088_quotes_dashes::MD088QuotesDashes; +#[cfg(feature = "html-fmt")] +pub use md089_embedded_html_fmt::MD089EmbeddedHtmlFmt; mod md012_no_multiple_blanks; pub use md012_no_multiple_blanks::MD012NoMultipleBlanks; @@ -613,6 +617,12 @@ const RULES: &[RuleEntry] = &[ ctor: crate::rules::md088_quotes_dashes::MD088QuotesDashes::from_config, opt_in: true, }, + #[cfg(feature = "html-fmt")] + RuleEntry { + name: "MD089", + ctor: MD089EmbeddedHtmlFmt::from_config, + opt_in: false, + }, ]; /// Returns all rule instances (including opt-in) for config validation and CLI diff --git a/src/utils/code_block_utils.rs b/src/utils/code_block_utils.rs index e0515221..4355c2d2 100644 --- a/src/utils/code_block_utils.rs +++ b/src/utils/code_block_utils.rs @@ -213,6 +213,20 @@ impl CodeBlockUtils { Self::is_in_code_block(blocks, pos) } + /// Check if an HTML block is a JSX block (starts with uppercase tag or fragment). + pub fn is_jsx_block(html: &str) -> bool { + let trimmed = html.trim_start(); + if trimmed.starts_with("<>") { + return true; + } + if let Some(stripped) = trimmed.strip_prefix('<') + && let Some(first_char) = stripped.chars().next() + { + return first_char.is_ascii_uppercase(); + } + false + } + /// Check if a byte position falls within any of the given sorted, non-overlapping ranges. /// /// Uses binary search on the sorted block ranges for O(log n) lookup. diff --git a/src/utils/range_utils.rs b/src/utils/range_utils.rs index 8338fbea..2e60427c 100644 --- a/src/utils/range_utils.rs +++ b/src/utils/range_utils.rs @@ -88,6 +88,24 @@ impl<'a> LineIndex<'a> { index } + /// Convert a global byte offset into 1-indexed (line, column). + /// Column is character-based, not byte-based. + pub fn byte_to_line_col(&self, byte_offset: usize) -> (usize, usize) { + let snapped_offset = find_char_boundary(self.content, byte_offset); + let line_idx = match self.line_starts.binary_search(&snapped_offset) { + Ok(idx) => idx, + Err(idx) => idx.saturating_sub(1), + }; + let line_start = self.line_starts[line_idx]; + let line_content = &self.content[line_start..snapped_offset]; + // Strip trailing newlines just in case + let line_content = line_content.strip_suffix('\n').unwrap_or(line_content); + let line_content = line_content.strip_suffix('\r').unwrap_or(line_content); + + let col = line_content.chars().count() + 1; + (line_idx + 1, col) + } + /// Create a `LineIndex` from pre-computed line starts and code block byte ranges. /// /// Instead of re-scanning content to find code blocks, this converts @@ -933,4 +951,38 @@ mod tests { assert_eq!(end_line, 1); assert!(end_col > start_col); } + + #[test] + fn test_byte_to_line_col() { + let content = "Hello\nWorld\nδ½ ε₯½\n"; + let line_index = LineIndex::new(content); + + // "Hello\n" is 6 bytes. + // "World\n" is 6 bytes. + // "δ½ ε₯½\n" is 7 bytes (each Chinese char is 3 bytes, plus \n). + + // Offset 0 -> Line 1, Col 1 (H) + assert_eq!(line_index.byte_to_line_col(0), (1, 1)); + // Offset 4 -> Line 1, Col 5 (o) + assert_eq!(line_index.byte_to_line_col(4), (1, 5)); + // Offset 5 -> Line 1, Col 6 (\n - stripped, so it behaves as Col 6) + assert_eq!(line_index.byte_to_line_col(5), (1, 6)); + + // Offset 6 -> Line 2, Col 1 (W) + assert_eq!(line_index.byte_to_line_col(6), (2, 1)); + + // Offset 12 -> Line 3, Col 1 (δ½ ) + assert_eq!(line_index.byte_to_line_col(12), (3, 1)); + // Offset 15 -> Line 3, Col 2 (ε₯½ - 3 bytes after start of line 3) + assert_eq!(line_index.byte_to_line_col(15), (3, 2)); + } + + #[test] + fn test_byte_to_line_col_mid_char() { + let content = "δ½ ε₯½\n"; + let line_index = LineIndex::new(content); + // This offset is in the middle of 'δ½ ' (bytes 0..3) + // It shouldn't panic, it should snap to nearest boundary or handle it. + let _ = line_index.byte_to_line_col(1); + } } diff --git a/tests/cli/cli_lsp_fix_consistency.rs b/tests/cli/cli_lsp_fix_consistency.rs index 87e60765..e65cc7c0 100644 --- a/tests/cli/cli_lsp_fix_consistency.rs +++ b/tests/cli/cli_lsp_fix_consistency.rs @@ -355,6 +355,8 @@ fn get_test_content_for_rule(rule_name: &str) -> Option<&'static str> { "MD086" => Some(""), "MD088" => Some("Text with \u{201C}quotes\u{201D} and dashes\u{2010}"), + #[cfg(feature = "html-fmt")] + "MD089" => Some("
Unformatted HTML
\ndon't create block context - // So > after them should flag - let content = "
\n> After self-closing\n"; + // Self-closing tags like
don't create block context across blank lines + let content = "
\n\n> After self-closing\n"; let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None); let result = rule.check(&ctx).unwrap(); - // Self-closing tag doesn't create block context, so this should flag + // Self-closing tag doesn't create block context across blank lines, so this should flag assert_eq!(result.len(), 1, "Content after self-closing tag should flag"); } @@ -174,9 +173,8 @@ fn test_md027_style_tag_allows_blanks() { let content = "\n> After style\n"; let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None); let result = rule.check(&ctx).unwrap(); - // Style tag context should continue through blank lines - // And content after (no blank) should not flag - assert!(result.is_empty(), "Content after style tag should not flag"); + // Content after is outside the style block, so the blockquote with multiple spaces is flagged + assert_eq!(result.len(), 1, "Content after style tag should flag"); } // ============================================================================= @@ -264,6 +262,6 @@ fn test_md027_script_tag_allows_blanks() { let content = "\n> After script\n"; let ctx = LintContext::new(content, rumdl_lib::config::MarkdownFlavor::Standard, None); let result = rule.check(&ctx).unwrap(); - // Script tag context should continue through blank lines - assert!(result.is_empty(), "Content after script tag should not flag"); + // Content after is outside the script block, so the blockquote with multiple spaces is flagged + assert_eq!(result.len(), 1, "Content after script tag should flag"); } diff --git a/tests/rules/md034_comprehensive_test.rs b/tests/rules/md034_comprehensive_test.rs index 13a463ea..55754ad3 100644 --- a/tests/rules/md034_comprehensive_test.rs +++ b/tests/rules/md034_comprehensive_test.rs @@ -328,7 +328,7 @@ fn test_urls_in_multiline_html_comments() { fn test_url_after_html_comment_is_flagged() { let rule = MD034NoBareUrls; - let content = " https://example.com"; + let content = "\nhttps://example.com"; let ctx = LintContext::new(content, MarkdownFlavor::Standard, None); let result = rule.check(&ctx).unwrap(); assert_eq!(result.len(), 1, "URL after HTML comment should be flagged");