Struct LintContext 

pub struct LintContext<'a> {
    pub content: &'a str,
    pub line_offsets: Vec<usize>,
    pub code_blocks: Vec<(usize, usize)>,
    pub code_block_details: Vec<CodeBlockDetail>,
    pub strong_spans: Vec<StrongSpanDetail>,
    pub lines: Vec<LineInfo>,
    pub list_blocks: Vec<ListBlock>,
    pub char_frequency: CharFrequency,
    pub table_blocks: Vec<TableBlock>,
    pub flavor: MarkdownFlavor,
    /* private fields */
}

Fields

content: &'a str

line_offsets: Vec<usize>

code_blocks: Vec<(usize, usize)>

code_block_details: Vec<CodeBlockDetail>

strong_spans: Vec<StrongSpanDetail>

lines: Vec<LineInfo>

list_blocks: Vec<ListBlock>

char_frequency: CharFrequency

table_blocks: Vec<TableBlock>

flavor: MarkdownFlavor

Implementations

impl<'a> LintContext<'a>

pub fn source_file(&self) -> Option<&Path>

The native source path available to filesystem-aware rules.

Virtual adapters intentionally leave this unset even when they provide a logical path for configuration matching.

pub fn new( content: &'a str, flavor: MarkdownFlavor, source_file: Option<PathBuf>, ) -> Self

pub fn front_matter_end_line(&self) -> usize

The 1-indexed line number where front matter ends (the closing delimiter line), or 0 when the document has no front matter. Computed once in new(); rules must use this instead of re-scanning the content with FrontMatterUtils.

pub fn is_in_code_span_byte(&self, pos: usize) -> bool

Check if a byte position is within a code span. O(log n).

pub fn is_in_link(&self, pos: usize) -> bool

Check if pos is inside any link byte range. O(log n).

pub fn is_in_bare_url(&self, pos: usize) -> bool

Check if `pos`` is within a bare URL

pub fn inline_config(&self) -> &InlineConfig

Get parsed inline configuration state.

pub fn colon_fence_details(&self) -> &[CodeBlockDetail]

Azure DevOps colon code fences (:::lang … :::), each with its byte range and the opener’s info string. These are detected outside the CommonMark parse, so they never appear in code_block_details. Empty for all other flavors.

pub fn raw_lines(&self) -> &[&'a str]

Get pre-split content lines, avoiding repeated content.lines().collect() allocations.

Lines are 0-indexed (line 0 corresponds to line number 1 in the document).

pub fn is_rule_disabled(&self, rule_name: &str, line_number: usize) -> bool

Check if a rule is disabled at a specific line number (1-indexed)

This method checks both persistent disable comments () and line-specific comments (, ).

pub fn code_spans(&self) -> Arc<Vec<CodeSpan>>

Get code spans - computed lazily on first access

pub fn math_byte_ranges(&self) -> &[(usize, usize)]

Math byte ranges ($...$ inline and $$...$$ display), computed once and cached. Used by is_in_math_context; without the cache that helper rescanned the whole document on every call.

pub fn math_spans(&self) -> Arc<Vec<MathSpan>>

Get math spans - computed lazily on first access

pub fn is_in_math_span(&self, byte_pos: usize) -> bool

Check if a byte position is within a math span (inline $…$ or display $$…$$)

pub fn html_comment_ranges(&self) -> &[ByteRange]

Get HTML comment ranges - pre-computed during LintContext construction

pub fn unterminated_html_comment(&self) -> Option<usize>

Byte offset of a <!-- that no --> closes, if the document has one.

Everything after it is inside the comment as far as the parser is concerned, so no rule sees that text.

pub fn unterminated_obsidian_comment(&self) -> Option<usize>

Byte offset of a %% that no second %% closes, if the document has one. Always None outside the Obsidian flavor, where %% is ordinary text rather than a comment delimiter.

pub fn is_in_obsidian_comment(&self, byte_pos: usize) -> bool

Check if a byte position is inside an Obsidian comment

Returns false for non-Obsidian flavors.

pub fn is_position_in_obsidian_comment( &self, line_num: usize, col: usize, ) -> bool

Check if a line/column position is inside an Obsidian comment

Line number is 1-indexed, column is 1-indexed. Returns false for non-Obsidian flavors.

pub fn myst_directive_ranges(&self) -> &[(usize, usize)]

Get byte ranges of MyST colon directive blocks

pub fn is_in_myst_role(&self, byte_pos: usize) -> bool

Check if a byte position is inside a MyST role ({role}content``)

pub fn is_in_myst_comment(&self, byte_pos: usize) -> bool

Check if a byte position is inside a MyST comment (% comment)

pub fn is_myst_colon_directive_opener_line(&self, line_num: usize) -> bool

Check if a line (1-indexed) is a MyST colon-fence directive opener (:::{name} ...).

The text after {name} on an opener is the directive’s argument (an opaque path, URL, or label), not markdown prose. Rules that reformat prose should skip these lines. Returns false for non-MyST flavors and for directive body or closer lines.

pub fn html_tags(&self) -> Arc<Vec<HtmlTag>>

Get HTML tags - computed lazily on first access.

JSX component tags (e.g. <Card .../>) are excluded so HTML-specific rules keep ignoring them; use Self::jsx_component_tags to access those. The single underlying parse populates both caches at once.

pub fn jsx_component_tags(&self) -> Arc<Vec<HtmlTag>>

Get JSX component tags (e.g. <Card .../>) - computed lazily, sharing the HTML-tag parse. Always empty for flavors without JSX support.

pub fn emphasis_spans(&self) -> Arc<Vec<EmphasisSpan>>

Get emphasis spans - pre-computed during construction

pub fn bare_urls(&self) -> Arc<Vec<BareUrl>>

Get bare URLs - computed lazily on first access

pub fn lazy_continuation_lines(&self) -> Arc<Vec<LazyContLine>>

Get lazy continuation lines - computed lazily on first access

pub fn has_mixed_list_nesting(&self) -> bool

Check if document has mixed ordered/unordered list nesting. Result is cached after first computation (document-level invariant). This is used by MD007 for smart style auto-detection.

pub fn offset_to_line_col(&self, offset: usize) -> (usize, usize)

Map a byte offset to (line, column).

The column is a 1-indexed character offset within the line (rumdl’s diagnostic convention), not a byte offset, so it is correct on lines containing multi-byte UTF-8 characters.

pub fn line_start_byte(&self, line_number: usize) -> Option<usize>

Return the byte offset at which a 1-indexed source line starts.

This is the inverse-facing half of Self::offset_to_line_col. Keeping both conversions on the document prevents rules from depending on the line-index representation or reconstructing it independently.

pub fn line_column_byte_range( &self, line_number: usize, column: usize, ) -> Range<usize>

Return an empty byte range at a 1-indexed line and character column.

Columns are character offsets, not UTF-8 byte offsets. Positions past the end of a line clamp to the end of its content; missing lines clamp to the end of the document.

pub fn line_column_byte_range_with_length( &self, line_number: usize, column: usize, length: usize, ) -> Range<usize>

Return a byte range beginning at a 1-indexed line and character column.

length is measured in characters. The result never crosses the line’s content boundary and excludes its line ending.

pub fn whole_line_byte_range(&self, line_number: usize) -> Range<usize>

Return the byte range of a complete 1-indexed line, including its line ending when one is present.

pub fn line_text_byte_range( &self, line_number: usize, start_column: usize, end_column: usize, ) -> Range<usize>

Return the byte range between two 1-indexed character columns on a line.

The range excludes the line ending and clamps both columns to valid character boundaries in the line content.

pub fn line_content_byte_range(&self, line_number: usize) -> Range<usize>

Return the byte range of a 1-indexed line’s content, excluding its line ending.

pub fn line_span_byte_range( &self, start_line: usize, end_line: usize, ) -> Range<usize>

Return the byte range spanning complete 1-indexed lines, inclusive.

pub fn is_in_code_block_or_span(&self, pos: usize) -> bool

Check if a position is within a code block or code span. O(log n).

pub fn line_info(&self, line_num: usize) -> Option<&LineInfo>

Get line information by line number (1-indexed)

pub fn links(&self) -> &[ParsedLink<'a>]

Parsed links in document order.

pub fn images(&self) -> &[ParsedImage<'a>]

Parsed images in document order.

pub fn broken_links(&self) -> &[BrokenLinkInfo]

Broken or undefined reference links in document order.

pub fn footnote_references(&self) -> &[FootnoteRef]

Parsed footnote references in document order.

pub fn reference_definitions(&self) -> &[ReferenceDef]

Parsed reference definitions in document order.

pub fn links_on_line(&self, line_number: usize) -> &[ParsedLink<'a>]

Links whose opening delimiter starts on line_number (1-indexed).

pub fn images_on_line(&self, line_number: usize) -> &[ParsedImage<'a>]

Images whose opening delimiter starts on line_number (1-indexed).

pub fn link_starting_at(&self, byte_offset: usize) -> Option<&ParsedLink<'a>>

Find the link that starts at an exact byte offset. O(log n).

pub fn image_starting_at(&self, byte_offset: usize) -> Option<&ParsedImage<'a>>

Find the image that starts at an exact byte offset. O(log n).

pub fn link_containing(&self, byte_offset: usize) -> Option<&ParsedLink<'a>>

Find the parsed link containing byte_offset. O(log n).

pub fn image_containing(&self, byte_offset: usize) -> Option<&ParsedImage<'a>>

Find the parsed image containing byte_offset. O(log n).

pub fn links_starting_before_or_at( &self, byte_offset: usize, ) -> &[ParsedLink<'a>]

Links that start at or before byte_offset, in document order. O(log n).

pub fn reference_definition(&self, ref_id: &str) -> Option<&ReferenceDef>

Find a reference definition by its case-insensitive identifier.

pub fn get_reference_url(&self, ref_id: &str) -> Option<&str>

Get URL for a reference link/image by its ID (O(1) lookup via HashMap)

pub fn is_in_list_block(&self, line_num: usize) -> bool

Check if a line is part of a list block

pub fn is_in_html_block(&self, line_num: usize) -> bool

Check if a line is within an HTML block

pub fn is_in_table_block(&self, line_num: usize) -> bool

Check if a 1-indexed line number is inside a GFM table block.

Returns true for the header line, delimiter line, and all body rows. TableBlock spans are stored 0-indexed; this helper accepts the 1-indexed line numbers used elsewhere in the rule API.

pub fn is_in_code_span(&self, line_num: usize, col: usize) -> bool

Check if a line and column is within a code span

pub fn is_byte_offset_in_code_span(&self, byte_offset: usize) -> bool

Check if a byte offset is within a code span. O(log n).

pub fn is_in_reference_def(&self, byte_pos: usize) -> bool

Check if a byte position is within a reference definition. O(log n).

pub fn is_in_html_comment(&self, byte_pos: usize) -> bool

Check if a byte position is within an HTML comment. O(log n).

pub fn is_in_html_tag(&self, byte_pos: usize) -> bool

Check if a byte position is within an HTML tag (including multiline tags). Uses the pre-parsed html_tags which correctly handles tags spanning multiple lines. O(log n).

pub fn is_in_jsx_component_tag(&self, byte_pos: usize) -> bool

Check if a byte position is within a JSX component tag (e.g. <Card .../>), including its attribute values and multiline tags. Always false for flavors without JSX support. O(log n).

pub fn is_in_jinja_range(&self, byte_pos: usize) -> bool

Check if a byte position is within a Jinja template ({{ }} or {% %}). O(log n).

pub fn is_in_jsx_expression(&self, byte_pos: usize) -> bool

Check if a byte position is within a JSX expression (MDX: {expression}). O(log n).

pub fn is_in_mdx_comment(&self, byte_pos: usize) -> bool

Check if a byte position is within an MDX comment ({/* … */}). O(log n).

pub fn is_in_citation(&self, byte_pos: usize) -> bool

Check if a byte position is within a Pandoc/Quarto citation (@key or [@key]). Active for Pandoc-compatible flavors. O(log n).

pub fn citation_ranges(&self) -> &[ByteRange]

Pre-computed Pandoc/Quarto citation ranges.

pub fn is_in_div_block(&self, byte_pos: usize) -> bool

Check if a byte position is within a Pandoc/Quarto div block (::: ... :::). Active for Pandoc-compatible flavors. O(log n) via binary search over sorted ranges.

pub fn is_in_inline_footnote(&self, byte_pos: usize) -> bool

Check if a byte position is within a Pandoc inline footnote (^[note text]). Active for Pandoc-compatible flavors. O(log n).

pub fn is_in_example_list_marker(&self, byte_pos: usize) -> bool

Check if a byte position is within a Pandoc example-list marker ((@) / (@label) at line start). Active for Pandoc-compatible flavors. O(log n).

pub fn is_in_example_reference(&self, byte_pos: usize) -> bool

Check if a byte position is within a Pandoc example reference ((@label) inline). Active for Pandoc-compatible flavors. O(log n).

pub fn is_in_subscript_or_superscript(&self, byte_pos: usize) -> bool

Check if a byte position is within a Pandoc subscript (~x~) or superscript (^x^) span. Active for Pandoc-compatible flavors. O(log n).

pub fn is_in_inline_code_attr(&self, byte_pos: usize) -> bool

Check if a byte position is within a Pandoc inline-code attribute block ({.lang} immediately following `code`). Active for Pandoc-compatible flavors. O(log n).

pub fn is_in_bracketed_span(&self, byte_pos: usize) -> bool

Check if a byte position is within a Pandoc bracketed span ([text]{attrs}). Active for Pandoc-compatible flavors. O(log n).

pub fn is_in_line_block(&self, byte_pos: usize) -> bool

Returns true if byte_pos falls inside a Pandoc line block (| text). Active for Pandoc-compatible flavors. O(log n).

pub fn is_in_pipe_table_caption(&self, byte_pos: usize) -> bool

Returns true if byte_pos falls inside a Pandoc pipe-table caption (: caption adjacent to a pipe table). Active for Pandoc-compatible flavors. O(log n).

pub fn is_in_pandoc_metadata(&self, byte_pos: usize) -> bool

Returns true if byte_pos falls inside a Pandoc YAML metadata block. Active for Pandoc-compatible flavors. O(log n).

pub fn is_in_grid_table(&self, byte_pos: usize) -> bool

Returns true if byte_pos falls inside a Pandoc grid table. Active for Pandoc-compatible flavors. O(log n).

pub fn is_in_multi_line_table(&self, byte_pos: usize) -> bool

Returns true if byte_pos falls inside a Pandoc multi-line table. Active for Pandoc-compatible flavors. O(log n).

pub fn matches_implicit_header_reference(&self, link_text: &str) -> bool

Returns true if link_text, after Pandoc slugification, matches a heading in the document. Returns false for non-Pandoc-compatible flavors because the pandoc_header_slugs set is empty when the pre-pass detector is gated off. Use this when the caller has raw bracketed text ([Section name]).

pub fn has_pandoc_slug(&self, slug: &str) -> bool

Returns true if slug (already in Pandoc-slug form) matches a heading in the document. Returns false for non-Pandoc-compatible flavors because the pandoc_header_slugs set is empty when the pre-pass detector is gated off. Use this when the caller already has a slug (e.g. the fragment of a URL after #). O(1).

pub fn is_in_shortcode(&self, byte_pos: usize) -> bool

Check if a byte position is within a Hugo/Quarto shortcode ({{< … >}} or {{% … %}}). O(log n).

pub fn shortcode_ranges(&self) -> &[(usize, usize)]

Pre-computed Hugo/Quarto shortcode ranges.

pub fn is_in_link_title(&self, byte_pos: usize) -> bool

Check if a byte position is within a link reference definition title. O(log n).

pub fn has_char(&self, ch: char) -> bool

Check if content has any instances of a specific character (fast)

pub fn char_count(&self, ch: char) -> usize

Get count of a specific character (fast)

pub fn likely_has_headings(&self) -> bool

Check if content likely contains headings (fast)

pub fn likely_has_lists(&self) -> bool

Check if content likely contains lists (fast)

pub fn likely_has_emphasis(&self) -> bool

Check if content likely contains emphasis (fast)

pub fn likely_has_tables(&self) -> bool

Check if content likely contains tables (fast)

pub fn likely_has_blockquotes(&self) -> bool

Check if content likely contains blockquotes (fast)

pub fn likely_has_code(&self) -> bool

Check if content likely contains code (fast)

pub fn likely_has_links_or_images(&self) -> bool

Check if content likely contains links or images (fast)

pub fn likely_has_html(&self) -> bool

Check if content likely contains HTML (fast)

pub fn blockquote_prefix_for_blank_line(&self, line_idx: usize) -> String

Get the blockquote prefix for inserting a blank line at the given line index. Returns the prefix without trailing content (e.g., “>” or “>>”). This is needed because blank lines inside blockquotes must preserve the blockquote structure. Returns an empty string if the line is not inside a blockquote.

pub fn valid_headings(&self) -> ValidHeadingsIter<'_>

Get an iterator over valid headings (skipping invalid ones like #NoSpace)

Valid headings have proper spacing after the # markers (or are level > 1). This is the standard iterator for rules that need to process headings.

Examples

use rumdl_lib::lint_context::LintContext;
use rumdl_lib::config::MarkdownFlavor;

let content = "# Valid Heading\n#NoSpace\n## Another Valid";
let ctx = LintContext::new(content, MarkdownFlavor::Standard, None);

for heading in ctx.valid_headings() {
    println!("Line {}: {} (level {})", heading.line_num, heading.heading.text, heading.heading.level);
}
// Only prints valid headings, skips `#NoSpace`

pub fn has_valid_headings(&self) -> bool

Check if the document contains any valid CommonMark headings

Returns true if there is at least one heading with proper space after #.

pub fn list_items(&self) -> ParsedListItemsIter<'_>

Iterate over every parsed list item in source order.

pub fn list_item_on_line(&self, line_num: usize) -> Option<ParsedListItem<'_>>

Return the parsed list item on a 1-indexed source line, if any.

pub fn parsed_list_blocks(&self) -> ParsedListBlocks<'_>

Borrow the document’s parsed list blocks and their item iterators.

pub fn list_block_item_groups(&self, block: &ListBlock) -> Vec<Vec<usize>>

The item lines of block grouped into the lists they form, one group per list as CommonMark nests them, in source order, so siblings can be compared without the nested items that sit between them.

pub fn has_list_items(&self) -> bool

Whether the document contains any parsed list items.

pub fn has_unordered_list_items(&self) -> bool

Whether the document contains any parsed unordered-list items.

pub fn commonmark_ordered_lists(&self) -> CommonMarkOrderedLists<'_>

Borrow ordered lists using the membership and start values determined by CommonMark.

pub fn headings(&self) -> ParsedHeadingsIter<'_>

Iterate over every heading recognized in the rendered document.

This includes top-level ATX and Setext headings, ATX headings nested in blockquotes, and malformed top-level ATX headings retained for diagnostics. Code blocks, front matter, raw HTML blocks, and flavor-specific non-Markdown regions are excluded during parsing; explicitly Markdown-enabled HTML containers remain eligible.

pub fn heading_on_line(&self, line_num: usize) -> Option<ParsedHeading<'_>>

Return the parsed heading on a 1-indexed source line, if any.

Trait Implementations

impl<'a> FilteredLinesExt for LintContext<'a>

fn filtered_lines(&self) -> FilteredLinesBuilder<'_>

Start building a filtered lines iterator

fn content_lines(&self) -> FilteredLinesIter<'_>

Get an iterator over content lines only