rumdl 0.0.111__tar.gz → 0.0.112__tar.gz

{rumdl-0.0.111 → rumdl-0.0.112}/CHANGELOG.md

@@ -7,6 +7,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.112] - 2025-08-08
+
 ## [0.0.110] - 2025-08-08
 
 ## [0.0.110] - 2025-08-08
@@ -302,7 +304,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Initial implementation of remaining rules for markdownlint parity
 
-[Unreleased]: https://github.com/rvben/rumdl/compare/v0.0.110...HEAD
+[Unreleased]: https://github.com/rvben/rumdl/compare/v0.0.112...HEAD
+[0.0.112]: https://github.com/rvben/rumdl/compare/v0.0.111...v0.0.112
 [0.0.110]: https://github.com/rvben/rumdl/compare/v0.0.109...v0.0.110
 [0.0.110]: https://github.com/rvben/rumdl/compare/v0.0.109...v0.0.110
 [0.0.107]: https://github.com/rvben/rumdl/compare/v0.0.106...v0.0.107

{rumdl-0.0.111 → rumdl-0.0.112}/Cargo.lock

@@ -1493,7 +1493,7 @@ checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
 [[package]]
 name = "rumdl"
-version = "0.0.111"
+version = "0.0.112"
 dependencies = [
  "anyhow",
  "assert_cmd",

{rumdl-0.0.111 → rumdl-0.0.112}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rumdl"
-version = "0.0.111"
+version = "0.0.112"
 edition = "2024"
 rust-version = "1.88.0"
 description = "A fast Markdown linter written in Rust (Ru(st) MarkDown Linter)"
@@ -13,6 +13,8 @@ readme = "README.md"
 keywords = ["markdown", "linter", "markdown-linter", "static-analysis", "documentation"]
 categories = ["command-line-utilities", "development-tools", "text-processing"]
 exclude = [".github/", ".gitignore", "*.bak"]
+autobins = false  # Prevent automatic binary discovery in src/bin/
+default-run = "rumdl"  # Default binary for cargo run
 
 [lib]
 name = "rumdl"

{rumdl-0.0.111 → rumdl-0.0.112}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rumdl
-Version: 0.0.111
+Version: 0.0.112
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

rumdl-0.0.112/scripts/generate-downloads-table.sh

@@ -0,0 +1,70 @@
+#!/bin/bash
+# Generate a markdown table for release downloads
+
+VERSION="${1:-}"
+if [ -z "$VERSION" ]; then
+    echo "Usage: $0 <version>"
+    echo "Example: $0 v0.0.111"
+    exit 1
+fi
+
+# Start the markdown table
+cat << 'EOF'
+## Downloads
+
+| File | Platform | Checksum |
+|------|----------|----------|
+EOF
+
+# Generate table rows for each platform
+generate_row() {
+    local target="$1"
+    local platform="$2"
+    
+    # Determine file extension based on platform
+    if [[ "$target" == *"windows"* ]]; then
+        ext="zip"
+    else
+        ext="tar.gz"
+    fi
+    
+    filename="rumdl-${VERSION}-${target}.${ext}"
+    checksum_file="${filename}.sha256"
+    
+    # Generate download URLs
+    download_url="https://github.com/rvben/rumdl/releases/download/${VERSION}/${filename}"
+    checksum_url="https://github.com/rvben/rumdl/releases/download/${VERSION}/${checksum_file}"
+    
+    # Output table row
+    echo "| [${filename}](${download_url}) | ${platform} | [checksum](${checksum_url}) |"
+}
+
+# Generate rows for each platform
+generate_row "x86_64-unknown-linux-gnu" "Linux x86_64" 
+generate_row "x86_64-unknown-linux-musl" "Linux x86_64 (musl)"
+generate_row "aarch64-unknown-linux-gnu" "Linux ARM64"
+generate_row "aarch64-unknown-linux-musl" "Linux ARM64 (musl)"
+generate_row "x86_64-apple-darwin" "macOS x86_64"
+generate_row "aarch64-apple-darwin" "macOS ARM64 (Apple Silicon)"
+generate_row "x86_64-pc-windows-msvc" "Windows x86_64"
+
+echo ""
+echo "## Installation"
+echo ""
+echo "### Using uv (Recommended)"
+echo '```bash'
+echo 'uv tool install rumdl'
+echo '```'
+echo ""
+echo "### Using pip"
+echo '```bash'
+echo 'pip install rumdl'
+echo '```'
+echo ""
+echo "### Using pipx"
+echo '```bash'
+echo 'pipx install rumdl'
+echo '```'
+echo ""
+echo "### Direct Download"
+echo "Download the appropriate binary for your platform from the table above, extract it, and add it to your PATH."

{rumdl-0.0.111 → rumdl-0.0.112}/src/rules/md026_no_trailing_punctuation.rs

@@ -2,6 +2,7 @@
 ///
 /// See [docs/md026.md](../../docs/md026.md) for full documentation, configuration, and examples.
 use crate::rule::{Fix, LintError, LintResult, LintWarning, Rule, Severity};
+use crate::utils::kramdown_utils::has_header_id;
 use crate::utils::range_utils::calculate_match_range;
 use lazy_static::lazy_static;
 use regex::Regex;
@@ -195,6 +196,16 @@ impl MD026NoTrailingPunctuation {
             let space = captures.get(3).unwrap().as_str();
             let content = captures.get(4).unwrap().as_str();
 
+            // If content has a valid Kramdown header ID, don't fix it
+            if has_header_id(content) {
+                // Return the line unchanged
+                if let Some(trailing) = captures.get(5) {
+                    return format!("{}{}{}{}{}", indentation, hashes, space, content, trailing.as_str());
+                }
+                return format!("{indentation}{hashes}{space}{content}");
+            }
+
+            // Otherwise, remove trailing punctuation
             let fixed_content = self.remove_trailing_punctuation(content, re);
 
             // Preserve any trailing hashes if present
@@ -297,10 +308,26 @@ impl Rule for MD026NoTrailingPunctuation {
                     continue;
                 }
 
-                // Check for trailing punctuation
-                if self.has_trailing_punctuation(&heading.text, &re) {
+                // For headers with potential Kramdown syntax, we need to be more careful
+                let text_to_check = if has_header_id(&heading.text) {
+                    // Valid Kramdown ID - skip this header entirely
+                    continue;
+                } else if heading.text.contains("{") && heading.text.trim().ends_with("}") {
+                    // Has curly braces but not a valid Kramdown ID
+                    // Check for punctuation before the opening brace
+                    if let Some(brace_pos) = heading.text.rfind('{') {
+                        heading.text[..brace_pos].trim().to_string()
+                    } else {
+                        heading.text.clone()
+                    }
+                } else {
+                    // Regular header without Kramdown syntax
+                    heading.text.clone()
+                };
+
+                if self.has_trailing_punctuation(&text_to_check, &re) {
                     // Find the trailing punctuation
-                    if let Some(punctuation_match) = re.find(&heading.text) {
+                    if let Some(punctuation_match) = re.find(&text_to_check) {
                         let line = &line_info.content;
 
                         // For ATX headings, find the punctuation position in the line
@@ -316,14 +343,14 @@ impl Rule for MD026NoTrailingPunctuation {
                             punctuation_len,
                         );
 
-                        let last_char = heading.text.chars().last().unwrap_or(' ');
+                        let last_char = text_to_check.chars().last().unwrap_or(' ');
                         warnings.push(LintWarning {
                             rule_name: Some(self.name()),
                             line: start_line,
                             column: start_col,
                             end_line,
                             end_column: end_col,
-                            message: format!("Heading '{}' ends with punctuation '{}'", heading.text, last_char),
+                            message: format!("Heading '{text_to_check}' ends with punctuation '{last_char}'"),
                             severity: Severity::Warning,
                             fix: Some(Fix {
                                 range: self.get_line_byte_range(content, line_num + 1),
@@ -386,8 +413,25 @@ impl Rule for MD026NoTrailingPunctuation {
                     continue;
                 }
 
+                // Handle headers with potential Kramdown syntax
+                let text_to_check = if has_header_id(&heading.text) {
+                    // Valid Kramdown ID - skip this header entirely
+                    continue;
+                } else if heading.text.contains("{") && heading.text.trim().ends_with("}") {
+                    // Has curly braces but not a valid Kramdown ID
+                    // Check for punctuation before the opening brace
+                    if let Some(brace_pos) = heading.text.rfind('{') {
+                        heading.text[..brace_pos].trim().to_string()
+                    } else {
+                        heading.text.clone()
+                    }
+                } else {
+                    // Regular header without Kramdown syntax
+                    heading.text.clone()
+                };
+
                 // Check and fix trailing punctuation
-                if self.has_trailing_punctuation(&heading.text, &re) {
+                if self.has_trailing_punctuation(&text_to_check, &re) {
                     fixed_lines[line_num] = if matches!(heading.style, crate::lint_context::HeadingStyle::ATX) {
                         self.fix_atx_heading(&line_info.content, &re)
                     } else {

{rumdl-0.0.111 → rumdl-0.0.112}/src/rules/md033_no_inline_html.rs

@@ -5,6 +5,7 @@
 
 use crate::rule::{LintError, LintResult, LintWarning, Rule, RuleCategory, Severity};
 use crate::utils::document_structure::{DocumentStructure, DocumentStructureExtensions};
+use crate::utils::kramdown_utils::{is_kramdown_block_attribute, is_kramdown_extension};
 use crate::utils::range_utils::calculate_html_tag_range;
 use crate::utils::regex_cache::*;
 use lazy_static::lazy_static;
@@ -157,7 +158,13 @@ impl MD033NoInlineHtml {
     }
 
     /// Find HTML tags that span multiple lines
-    fn find_multiline_html_tags(&self, content: &str, structure: &DocumentStructure, warnings: &mut Vec<LintWarning>) {
+    fn find_multiline_html_tags(
+        &self,
+        content: &str,
+        structure: &DocumentStructure,
+        nomarkdown_ranges: &[(usize, usize)],
+        warnings: &mut Vec<LintWarning>,
+    ) {
         // Early return: if content has no incomplete tags at line ends, skip processing
         if !content.contains('<') || !content.lines().any(|line| line.trim_end().ends_with('<')) {
             return;
@@ -178,6 +185,14 @@ impl MD033NoInlineHtml {
                 continue;
             }
 
+            // Skip lines inside nomarkdown blocks
+            if nomarkdown_ranges
+                .iter()
+                .any(|(start, end)| line_num >= *start && line_num <= *end)
+            {
+                continue;
+            }
+
             // Early return: skip lines that don't end with incomplete tags
             if !line.contains('<') {
                 continue;
@@ -288,7 +303,37 @@ impl Rule for MD033NoInlineHtml {
         let mut warnings = Vec::new();
         let lines: Vec<&str> = content.lines().collect();
 
-        // First pass: find single-line HTML tags
+        // Track nomarkdown and comment blocks
+        let mut in_nomarkdown = false;
+        let mut in_comment = false;
+        let mut nomarkdown_ranges: Vec<(usize, usize)> = Vec::new();
+        let mut nomarkdown_start = 0;
+        let mut comment_start = 0;
+
+        // First pass: identify nomarkdown and comment blocks
+        for (i, line) in lines.iter().enumerate() {
+            let line_num = i + 1;
+
+            // Check for nomarkdown start
+            if line.trim() == "{::nomarkdown}" {
+                in_nomarkdown = true;
+                nomarkdown_start = line_num;
+            } else if line.trim() == "{:/nomarkdown}" && in_nomarkdown {
+                in_nomarkdown = false;
+                nomarkdown_ranges.push((nomarkdown_start, line_num));
+            }
+
+            // Check for comment blocks
+            if line.trim() == "{::comment}" {
+                in_comment = true;
+                comment_start = line_num;
+            } else if line.trim() == "{:/comment}" && in_comment {
+                in_comment = false;
+                nomarkdown_ranges.push((comment_start, line_num));
+            }
+        }
+
+        // Second pass: find single-line HTML tags
         // To match markdownlint behavior, report one warning per HTML tag
         for (i, line) in lines.iter().enumerate() {
             let line_num = i + 1;
@@ -305,6 +350,19 @@ impl Rule for MD033NoInlineHtml {
                 continue;
             }
 
+            // Skip lines inside nomarkdown blocks
+            if nomarkdown_ranges
+                .iter()
+                .any(|(start, end)| line_num >= *start && line_num <= *end)
+            {
+                continue;
+            }
+
+            // Skip Kramdown extensions and block attributes
+            if is_kramdown_extension(line) || is_kramdown_block_attribute(line) {
+                continue;
+            }
+
             // Find all HTML tags in the line using regex
             for tag_match in HTML_TAG_FINDER.find_iter(line) {
                 let tag = tag_match.as_str();
@@ -356,8 +414,8 @@ impl Rule for MD033NoInlineHtml {
             }
         }
 
-        // Second pass: find multi-line HTML tags
-        self.find_multiline_html_tags(ctx.content, structure, &mut warnings);
+        // Third pass: find multi-line HTML tags
+        self.find_multiline_html_tags(ctx.content, structure, &nomarkdown_ranges, &mut warnings);
 
         Ok(warnings)
     }

{rumdl-0.0.111 → rumdl-0.0.112}/src/rules/md037_spaces_around_emphasis.rs

@@ -4,6 +4,7 @@
 use crate::rule::{Fix, LintError, LintResult, LintWarning, Rule, RuleCategory, Severity};
 use crate::utils::document_structure::{DocumentStructure, DocumentStructureExtensions};
 use crate::utils::emphasis_utils::{EmphasisSpan, find_emphasis_markers, find_emphasis_spans, has_doc_patterns};
+use crate::utils::kramdown_utils::has_span_ial;
 use crate::utils::regex_cache::UNORDERED_LIST_MARKER_REGEX;
 use lazy_static::lazy_static;
 use regex::Regex;
@@ -330,6 +331,16 @@ impl MD037NoSpaceInEmphasis {
                 let full_end = span.closing.end_pos();
                 let full_text = &content[full_start..full_end];
 
+                // Skip if this emphasis has a Kramdown span IAL immediately after it
+                // (no space between emphasis and IAL)
+                if full_end < content.len() {
+                    let remaining = &content[full_end..];
+                    // Check if IAL starts immediately after the emphasis (no whitespace)
+                    if remaining.starts_with('{') && has_span_ial(remaining.split_whitespace().next().unwrap_or("")) {
+                        continue;
+                    }
+                }
+
                 // Create the marker string efficiently
                 let marker_char = span.opening.as_char();
                 let marker_str = if span.opening.count == 1 {

rumdl-0.0.112/src/utils/kramdown_utils.rs

@@ -0,0 +1,252 @@
+//! Utilities for handling Kramdown-specific syntax
+//!
+//! Kramdown is a superset of Markdown that adds additional features like
+//! Inline Attribute Lists (IAL) for adding attributes to elements.
+
+use lazy_static::lazy_static;
+use regex::Regex;
+
+lazy_static! {
+    /// Pattern for Kramdown span IAL: text{:.class #id key="value"}
+    static ref SPAN_IAL_PATTERN: Regex = Regex::new(r"\{[:\.#][^}]*\}$").unwrap();
+
+    /// Pattern for Kramdown header IDs: # Header {#custom-id}
+    static ref HEADER_ID_PATTERN: Regex = Regex::new(r"\s*\{#[a-zA-Z][\w\-:.]*\}\s*$").unwrap();
+
+    /// Pattern for Kramdown extensions opening: {::comment}, {::nomarkdown}, etc.
+    static ref EXTENSION_OPEN_PATTERN: Regex = Regex::new(r"^\s*\{::([a-z]+)(?:\s+[^}]*)?\}\s*$").unwrap();
+
+    /// Pattern for Kramdown extensions closing: {:/comment}, {:/}, etc.
+    static ref EXTENSION_CLOSE_PATTERN: Regex = Regex::new(r"^\s*\{:/([a-z]+)?\}\s*$").unwrap();
+
+    /// Pattern for Kramdown options: {::options key="value" /}
+    static ref OPTIONS_PATTERN: Regex = Regex::new(r"^\s*\{::options\s+[^}]+/\}\s*$").unwrap();
+
+    /// Pattern for footnote references: [^footnote]
+    static ref FOOTNOTE_REF_PATTERN: Regex = Regex::new(r"\[\^[a-zA-Z0-9_\-]+\]").unwrap();
+
+    /// Pattern for footnote definitions: [^footnote]: definition
+    static ref FOOTNOTE_DEF_PATTERN: Regex = Regex::new(r"^\[\^[a-zA-Z0-9_\-]+\]:").unwrap();
+
+    /// Pattern for abbreviations: *[HTML]: HyperText Markup Language
+    static ref ABBREVIATION_PATTERN: Regex = Regex::new(r"^\*\[[^\]]+\]:").unwrap();
+
+    /// Pattern for math blocks: $$ or $
+    static ref MATH_BLOCK_PATTERN: Regex = Regex::new(r"^\$\$").unwrap();
+    static ref MATH_INLINE_PATTERN: Regex = Regex::new(r"\$[^$]+\$").unwrap();
+}
+
+/// Check if a line is a Kramdown block attribute (IAL - Inline Attribute List)
+///
+/// Kramdown IAL syntax allows adding attributes to block elements:
+/// - `{:.class}` - CSS class
+/// - `{:#id}` - Element ID
+/// - `{:attribute="value"}` - Generic attributes
+/// - `{:.class #id attribute="value"}` - Combinations
+///
+/// # Examples
+///
+/// ```
+/// use rumdl::utils::kramdown_utils::is_kramdown_block_attribute;
+///
+/// assert!(is_kramdown_block_attribute("{:.wrap}"));
+/// assert!(is_kramdown_block_attribute("{:#my-id}"));
+/// assert!(is_kramdown_block_attribute("{:.class #id}"));
+/// assert!(is_kramdown_block_attribute("{:style=\"color: red\"}"));
+///
+/// assert!(!is_kramdown_block_attribute("{just text}"));
+/// assert!(!is_kramdown_block_attribute("{}"));
+/// assert!(!is_kramdown_block_attribute("{"));
+/// ```
+pub fn is_kramdown_block_attribute(line: &str) -> bool {
+    let trimmed = line.trim();
+
+    // Must start with { and end with }
+    if !trimmed.starts_with('{') || !trimmed.ends_with('}') || trimmed.len() < 3 {
+        return false;
+    }
+
+    // Check if it matches Kramdown IAL patterns
+    // Valid patterns start with {: or {# or {.
+    let second_char = trimmed.chars().nth(1);
+    matches!(second_char, Some(':') | Some('#') | Some('.'))
+}
+
+/// Check if text ends with a Kramdown span IAL (inline attribute)
+///
+/// # Examples
+/// ```
+/// use rumdl::utils::kramdown_utils::has_span_ial;
+///
+/// assert!(has_span_ial("*emphasized*{:.highlight}"));
+/// assert!(has_span_ial("[link](url){:target=\"_blank\"}"));
+/// assert!(!has_span_ial("regular text"));
+/// ```
+pub fn has_span_ial(text: &str) -> bool {
+    SPAN_IAL_PATTERN.is_match(text.trim())
+}
+
+/// Remove span IAL from text if present
+pub fn remove_span_ial(text: &str) -> &str {
+    if let Some(captures) = SPAN_IAL_PATTERN.find(text) {
+        &text[..captures.start()]
+    } else {
+        text
+    }
+}
+
+/// Check if a heading line has a Kramdown header ID
+///
+/// # Examples
+/// ```
+/// use rumdl::utils::kramdown_utils::has_header_id;
+///
+/// assert!(has_header_id("# Header {#custom-id}"));
+/// assert!(has_header_id("## Section {#section-1}"));
+/// assert!(!has_header_id("# Regular Header"));
+/// ```
+pub fn has_header_id(line: &str) -> bool {
+    HEADER_ID_PATTERN.is_match(line)
+}
+
+/// Remove header ID from a heading line if present
+pub fn remove_header_id(line: &str) -> String {
+    HEADER_ID_PATTERN.replace(line, "").to_string()
+}
+
+/// Check if a line is a Kramdown extension opening tag
+///
+/// Extensions include: comment, nomarkdown, options
+pub fn is_kramdown_extension_open(line: &str) -> bool {
+    EXTENSION_OPEN_PATTERN.is_match(line)
+}
+
+/// Check if a line is a Kramdown extension closing tag
+pub fn is_kramdown_extension_close(line: &str) -> bool {
+    EXTENSION_CLOSE_PATTERN.is_match(line)
+}
+
+/// Check if a line is a Kramdown options directive
+pub fn is_kramdown_options(line: &str) -> bool {
+    OPTIONS_PATTERN.is_match(line)
+}
+
+/// Check if a line is a Kramdown extension (any type)
+pub fn is_kramdown_extension(line: &str) -> bool {
+    is_kramdown_extension_open(line) || is_kramdown_extension_close(line) || is_kramdown_options(line)
+}
+
+/// Check if a line is an End-of-Block (EOB) marker
+///
+/// In Kramdown, a line containing only `^` ends the current block
+pub fn is_eob_marker(line: &str) -> bool {
+    line.trim() == "^"
+}
+
+/// Check if text contains a footnote reference
+pub fn has_footnote_reference(text: &str) -> bool {
+    FOOTNOTE_REF_PATTERN.is_match(text)
+}
+
+/// Check if a line is a footnote definition
+pub fn is_footnote_definition(line: &str) -> bool {
+    FOOTNOTE_DEF_PATTERN.is_match(line.trim_start())
+}
+
+/// Check if a line is an abbreviation definition
+pub fn is_abbreviation_definition(line: &str) -> bool {
+    ABBREVIATION_PATTERN.is_match(line.trim_start())
+}
+
+/// Check if a line starts a math block
+pub fn is_math_block_delimiter(line: &str) -> bool {
+    let trimmed = line.trim();
+    trimmed == "$$" || MATH_BLOCK_PATTERN.is_match(trimmed)
+}
+
+/// Check if text contains inline math
+pub fn has_inline_math(text: &str) -> bool {
+    MATH_INLINE_PATTERN.is_match(text)
+}
+
+/// Check if a line is a definition list item
+///
+/// Definition lists in Kramdown use the pattern:
+/// ```
+/// Term
+/// : Definition
+/// ```
+pub fn is_definition_list_item(line: &str) -> bool {
+    let trimmed = line.trim_start();
+    trimmed.starts_with(": ")
+        || (trimmed.starts_with(':') && trimmed.len() > 1 && trimmed.chars().nth(1).is_some_and(|c| c.is_whitespace()))
+}
+
+/// Check if a line contains any Kramdown-specific syntax
+pub fn has_kramdown_syntax(line: &str) -> bool {
+    is_kramdown_block_attribute(line)
+        || has_span_ial(line)
+        || has_header_id(line)
+        || is_kramdown_extension(line)
+        || is_eob_marker(line)
+        || is_footnote_definition(line)
+        || is_abbreviation_definition(line)
+        || is_math_block_delimiter(line)
+        || is_definition_list_item(line)
+        || has_footnote_reference(line)
+        || has_inline_math(line)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_kramdown_class_attributes() {
+        assert!(is_kramdown_block_attribute("{:.wrap}"));
+        assert!(is_kramdown_block_attribute("{:.class-name}"));
+        assert!(is_kramdown_block_attribute("{:.multiple .classes}"));
+    }
+
+    #[test]
+    fn test_kramdown_id_attributes() {
+        assert!(is_kramdown_block_attribute("{:#my-id}"));
+        assert!(is_kramdown_block_attribute("{:#section-1}"));
+    }
+
+    #[test]
+    fn test_kramdown_generic_attributes() {
+        assert!(is_kramdown_block_attribute("{:style=\"color: red\"}"));
+        assert!(is_kramdown_block_attribute("{:data-value=\"123\"}"));
+    }
+
+    #[test]
+    fn test_kramdown_combined_attributes() {
+        assert!(is_kramdown_block_attribute("{:.class #id}"));
+        assert!(is_kramdown_block_attribute("{:#id .class style=\"color: blue\"}"));
+        assert!(is_kramdown_block_attribute("{:.wrap #my-code .highlight}"));
+    }
+
+    #[test]
+    fn test_non_kramdown_braces() {
+        assert!(!is_kramdown_block_attribute("{just some text}"));
+        assert!(!is_kramdown_block_attribute("{not kramdown}"));
+        assert!(!is_kramdown_block_attribute("{ spaces }"));
+    }
+
+    #[test]
+    fn test_edge_cases() {
+        assert!(!is_kramdown_block_attribute("{}"));
+        assert!(!is_kramdown_block_attribute("{"));
+        assert!(!is_kramdown_block_attribute("}"));
+        assert!(!is_kramdown_block_attribute(""));
+        assert!(!is_kramdown_block_attribute("not braces"));
+    }
+
+    #[test]
+    fn test_whitespace_handling() {
+        assert!(is_kramdown_block_attribute("  {:.wrap}  "));
+        assert!(is_kramdown_block_attribute("\t{:#id}\t"));
+        assert!(is_kramdown_block_attribute(" {:.class #id} "));
+    }
+}