Struct Codetag 

pub struct Codetag {
    pub hide_mnemonic: bool,
    /* private fields */
}

A finder that extracts codetags (TODO, FIXME, etc.) from text.

Codetags are special comments in source code that mark areas needing attention. This finder supports all mnemonics defined in PEP 350, plus common variants.

Usage

1. Create a default instance or configure with specific mnemonics
2. Optionally call Codetag::build_mnemonics_regex to build the matching tables eagerly (Finder::find builds them lazily otherwise)
3. Use the Finder::find method to extract codetags

Example

use squeeze::{codetag::Codetag, Finder};

let mut finder = Codetag::default();
finder.build_mnemonics_regex().unwrap();

let text = "// FIXME(john): this is broken";
if let Some(range) = finder.find(text) {
    println!("Found: {}", &text[range]);
}

Fields

hide_mnemonic: bool

When true, the mnemonic (e.g., “TODO:”) is excluded from the result.

Implementations

impl Codetag

pub fn add_mnemonic(&mut self, mnemonic: &str)

Adds a custom mnemonic to search for.

When at least one mnemonic is added, only those mnemonics will be matched. If no mnemonics are added, all default PEP 350 mnemonics are used.

Mnemonic matching is case-insensitive. Surrounding whitespace is trimmed; empty and whitespace-only mnemonics are ignored, as they would otherwise match every word:.

pub fn build_mnemonics_regex(&mut self) -> Result<(), Infallible>

Builds the matching tables for the configured mnemonics.

Calling this is optional: Finder::find builds them lazily on first use. The name is kept from the regex-based implementation; it cannot fail.

Trait Implementations

impl Default for Codetag

fn default() -> Self

Returns the “default value” for a type.

impl Finder for Codetag

fn id(&self) -> &'static str

Returns a unique identifier for this finder.

fn dispatchable(&self) -> bool

Whether this finder supports dispatch-mode scanning via try_at.

fn could_start_at(&self, byte: u8) -> bool

Whether the given byte could be the first byte of a match. Only meaningful when dispatchable returns true.

fn could_start_after(&self, prev: u8, cur: u8) -> bool

Whether a match could be attempted at byte cur when the byte immediately before it is prev: a dispatch-mode start, or a trigger-mode trigger byte.

fn could_continue_with(&self, cur: u8, next: u8) -> bool

Whether an attempt at byte cur could succeed when the byte immediately after it is next. Same contract as could_start_after.

fn run_rules(&self) -> Vec<RunRule>

Rules on the digit or hex run starting at a candidate position, evaluated with RunRule::allow before try_at is called. Same contract as could_start_after: when the rules reject a position, try_at must return None there. The scanner measures the runs once per position for all finders.

fn try_at(&self, input: &[u8], pos: usize) -> Option<Range<usize>>

Try to find a match starting exactly at pos in the full input. Only called when dispatchable returns true.

fn prefixes(&self) -> Vec<Vec<u8>>

Byte strings, ASCII case ignored, one of which starts the input at every position where try_at can match (todo for --todo codetags). A finder that would otherwise need the block classifier is then found by searching for them. Empty when unknown.

fn find(&self, s: &str) -> Option<Range<usize>>

Finds the first match in the given string.

fn try_at_memo( &self, input: &[u8], pos: usize, memo: &mut Memo, ) -> Option<Range<usize>>

try_at with a per-line Memo; the scanner calls this variant. Finders whose attempts can rescan the same bytes override it to remember what already failed. Must return exactly what try_at returns.

fn try_trigger_at_memo( &self, input: &[u8], pos: usize, memo: &mut Memo, ) -> Option<Range<usize>>

try_trigger_at with a per-line Memo, same contract as try_at_memo.

fn line_agnostic(&self) -> bool

Whether try_at/try_trigger_at give the same answer on a whole buffer as on the line alone: \n and \r never belong to a match, and every walk treats them exactly like the end of the input (as a boundary), so a match never depends on what surrounds its line. A finder that matches “up to the end of the line” (codetag), accepts line terminators as whitespace (JSON, phone) or otherwise looks at the line as a whole must keep the default. Line-agnostic finders are run over whole buffers with absolute positions, which lets the scanner skip resolving the line of every candidate; property tests compare both modes. Defaults to false.

fn anchor(&self) -> Option<Anchor>

Bytes every match of this dispatch finder contains (bytes), and the bytes that can separate a match start from the first of them (walk). When every finder of a scanner declares an anchor (or is a trigger finder) and the anchor bytes number three or fewer, the scanner searches for those bytes with memchr, walks back over walk and tries the dispatch positions in order, so lines without an anchor byte cost nothing.

fn triggerable(&self) -> bool

Whether this finder supports trigger-mode scanning.

fn could_trigger_at(&self, _byte: u8) -> bool

Whether the given byte could trigger a match for this finder. Only meaningful when triggerable returns true.

fn has_trigger_context(&self) -> bool

Whether the trigger context gate constrains anything: the scanner then tabulates trigger_context over the 65536 pairs of previous bytes and trigger_context_exempt over the next bytes, once, and consults them before calling the finder. Defaults to false.

fn trigger_context(&self, _prev2: u8, _prev1: u8) -> bool

Whether a match may be triggered at a byte preceded by prev2 and prev1, unless the byte after the trigger is exempt (trigger_context_exempt): a necessary condition for try_trigger_at to match at that position. The scanner passes a space for a missing previous byte (the trigger sits in the first two bytes of the input). Defaults to true.

fn trigger_context_exempt(&self, _next: Option<u8>) -> bool

Whether a trigger followed by next (None at the end of the input) escapes the previous-bytes condition: the URI finder needs a registered scheme before a colon unless // follows. Defaults to false.

fn try_trigger_at(&self, _input: &[u8], _pos: usize) -> Option<Range<usize>>

Try to find a match triggered by pos in the full input. Only called when triggerable returns true.