markdown-table-fixer 0.1.2__tar.gz → 0.1.3__tar.gz

{markdown_table_fixer-0.1.2 → markdown_table_fixer-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: markdown-table-fixer
-Version: 0.1.2
+Version: 0.1.3
 Summary: Markdown table formatter and linter with GitHub integration
 Project-URL: Homepage, https://github.com/lfit/markdown-table-fixer
 Project-URL: Repository, https://github.com/lfit/markdown-table-fixer.git
@@ -25,6 +25,7 @@ Requires-Python: <3.14,>=3.10
 Requires-Dist: aiolimiter>=1.2.0
 Requires-Dist: httpx[http2]>=0.28.0
 Requires-Dist: pydantic>=2.10.3
+Requires-Dist: pyyaml>=6.0.0
 Requires-Dist: rich>=13.9.4
 Requires-Dist: tenacity>=9.0.0
 Requires-Dist: typer>=0.15.0
@@ -37,6 +38,7 @@ Requires-Dist: pytest-cov>=6.0.0; extra == 'dev'
 Requires-Dist: pytest-mock>=3.14.0; extra == 'dev'
 Requires-Dist: pytest>=8.3.4; extra == 'dev'
 Requires-Dist: ruff>=0.8.4; extra == 'dev'
+Requires-Dist: types-pyyaml>=6.0.0; extra == 'dev'
 Description-Content-Type: text/markdown
 
 <!--

{markdown_table_fixer-0.1.2 → markdown_table_fixer-0.1.3}/pyproject.toml

@@ -38,6 +38,7 @@ dependencies = [
     "aiolimiter>=1.2.0",
     "tenacity>=9.0.0",
     "wcwidth>=0.2.13",
+    "pyyaml>=6.0.0",
 ]
 
 [project.optional-dependencies]
@@ -49,6 +50,7 @@ dev = [
     "mypy>=1.13.0",
     "ruff>=0.8.4",
     "pre-commit>=4.0.1",
+    "types-PyYAML>=6.0.0",
 ]
 
 [project.urls]

{markdown_table_fixer-0.1.2 → markdown_table_fixer-0.1.3}/src/markdown_table_fixer/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.1.2'
-__version_tuple__ = version_tuple = (0, 1, 2)
+__version__ = version = '0.1.3'
+__version_tuple__ = version_tuple = (0, 1, 3)
 
 __commit_id__ = commit_id = None

{markdown_table_fixer-0.1.2 → markdown_table_fixer-0.1.3}/src/markdown_table_fixer/cli.py

@@ -27,7 +27,6 @@ from .models import (
     OutputFormat,
     PRInfo,
     ScanResult,
-    TableViolation,
 )
 from .pr_fixer import PRFixer
 from .pr_scanner import PRScanner
@@ -172,7 +171,6 @@ def lint(
         console.print(f"🔍 Scanning: {scan_path}")
         if should_fix:
             console.print("🔧 Auto-fix enabled")
-        console.print()
 
     try:
         scanner = MarkdownFileScanner(scan_path)
@@ -206,6 +204,9 @@ def lint(
         if (check or fail_on_error) and scan_result.files_with_issues > 0:
             raise typer.Exit(1)
 
+    except typer.Exit:
+        # Re-raise typer.Exit without catching it as a general exception
+        raise
     except Exception as e:
         console.print(f"[red]Error:[/red] {e}")
         raise typer.Exit(1) from e
@@ -736,36 +737,30 @@ def _output_text_results(result: ScanResult, quiet: bool) -> None:
             console.print(f"  ... and {len(result.errors) - 5} more errors")
         console.print()
 
-    # Show sample violations
-    if result.files_with_issues > 0:
+    # Show all files with violations or errors
+    if result.files_with_issues > 0 or result.errors:
         console.print("[bold yellow]Files with issues:[/bold yellow]")
-        for file_result in result.file_results[:3]:
-            if file_result.has_violations:
-                console.print(f"{file_result.file_path}")
-
-                # Group violations by table
-                violations_by_table: dict[int, list[TableViolation]] = {}
-                for violation in file_result.violations:
-                    table_line = violation.table_start_line
-                    if table_line not in violations_by_table:
-                        violations_by_table[table_line] = []
-                    violations_by_table[table_line].append(violation)
-
-                # Show summary per table
-                for table_line in sorted(violations_by_table.keys()):
-                    violations = violations_by_table[table_line]
-                    # Count unique rows with violations
-                    unique_rows = len({v.line_number for v in violations})
-                    console.print(
-                        f"  Markdown table at line {table_line} has {unique_rows} "
-                        f"row(s) with formatting issues"
-                    )
-                console.print()
 
-        if result.files_with_issues > 3:
-            console.print(
-                f"... and {result.files_with_issues - 3} more files with issues"
-            )
+        # Collect files with issues (violations or errors)
+        files_to_show = []
+        for file_result in result.file_results:
+            if file_result.has_violations or file_result.error:
+                files_to_show.append(file_result)
+
+        # Display each file with its issue count
+        for file_result in files_to_show:
+            if file_result.has_violations:
+                # Count total violations for this file
+                violation_count = len(file_result.violations)
+                error_word = "Error" if violation_count == 1 else "Errors"
+                console.print(
+                    f"  {file_result.file_path} [{violation_count} {error_word}]"
+                )
+            elif file_result.error:
+                # File has a parsing or processing error
+                console.print(
+                    f"  {file_result.file_path} [Parse Error: {file_result.error}]"
+                )
 
 
 if __name__ == "__main__":

{markdown_table_fixer-0.1.2 → markdown_table_fixer-0.1.3}/src/markdown_table_fixer/models.py

@@ -7,6 +7,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass, field
 from enum import Enum
+import html
 from pathlib import Path
 from typing import Any
 
@@ -47,12 +48,19 @@ class TableCell:
 
         Uses wcwidth to properly calculate display width for Unicode characters,
         including emojis which display as 2 characters wide but count as 1 in len().
+        Also handles HTML entities (e.g., | for |, 😀 for 😀).
         """
         stripped = self.content.strip()
-        width = wcwidth.wcswidth(stripped)
+
+        # Decode HTML entities to their actual characters
+        # This properly handles both named entities (<) and numeric entities (|, 😀)
+        # so that wide characters like emojis get their correct display width
+        decoded = html.unescape(stripped)
+
+        width = wcwidth.wcswidth(decoded)
         # wcswidth returns -1 if string contains non-printable characters
         # Fall back to len() in that case
-        return width if width >= 0 else len(stripped)
+        return width if width >= 0 else len(decoded)
 
 
 @dataclass

{markdown_table_fixer-0.1.2 → markdown_table_fixer-0.1.3}/src/markdown_table_fixer/table_fixer.py

@@ -5,8 +5,12 @@
 
 from __future__ import annotations
 
+import json
+import re
 from typing import TYPE_CHECKING
 
+import yaml
+
 if TYPE_CHECKING:
     from pathlib import Path
 
@@ -86,8 +90,11 @@ class TableFixer:
     def _calculate_column_widths(self) -> list[int]:
         """Calculate the maximum width needed for each column.
 
+        For MD060 compliance, we need to align pipes by character position.
+        This uses string length, not display width or byte length.
+
         Returns:
-            List of column widths
+            List of column widths (in characters)
         """
         if not self.table.rows:
             return []
@@ -105,6 +112,7 @@ class TableFixer:
                     if row.is_separator:
                         content_width = 3  # Minimum "---"
                     else:
+                        # Use character length for MD060 compliance (pipe alignment)
                         content_width = len(cell.content.strip())
                     max_width = max(max_width, content_width)
             widths.append(max_width)
@@ -116,7 +124,7 @@ class TableFixer:
 
         Args:
             row: The row to format
-            column_widths: Width of each column
+            column_widths: Width of each column (in characters)
 
         Returns:
             Formatted row string
@@ -129,7 +137,8 @@ class TableFixer:
                 column_widths[idx] if idx < len(column_widths) else len(content)
             )
 
-            # Pad content to column width
+            # Pad content to column width based on character length
+            # This ensures pipes align by character position (MD060 compliance)
             padded = content.ljust(width)
             parts.append(f" {padded} ")
 
@@ -142,7 +151,7 @@ class TableFixer:
 
         Args:
             row: The separator row to format
-            column_widths: Width of each column
+            column_widths: Width of each column (in characters)
 
         Returns:
             Formatted separator row string
@@ -188,6 +197,202 @@ class FileFixer:
         """
         self.file_path = file_path
         self.max_line_length = max_line_length
+        self._md013_enabled = self._check_md013_enabled()
+        self._md060_enabled = self._check_md060_enabled()
+
+    def _remove_jsonc_comments(self, content: str) -> str:
+        """Remove comments from JSONC content.
+
+        This is a simple implementation that removes // comments while being
+        aware of strings. It's not perfect but handles most common cases.
+
+        Args:
+            content: JSONC content string
+
+        Returns:
+            Content with comments removed
+        """
+        lines = []
+        for line in content.split("\n"):
+            # Track if we're inside a string
+            in_string = False
+            escape_next = False
+            processed = []
+
+            i = 0
+            while i < len(line):
+                char = line[i]
+
+                if escape_next:
+                    processed.append(char)
+                    escape_next = False
+                    i += 1
+                    continue
+
+                if char == "\\":
+                    processed.append(char)
+                    escape_next = True
+                    i += 1
+                    continue
+
+                if char == '"':
+                    in_string = not in_string
+                    processed.append(char)
+                    i += 1
+                    continue
+
+                # Check for comment start (only outside strings)
+                if (
+                    not in_string
+                    and i < len(line) - 1
+                    and line[i : i + 2] == "//"
+                ):
+                    # Rest of line is a comment
+                    break
+
+                processed.append(char)
+                i += 1
+
+            lines.append("".join(processed))
+
+        return "\n".join(lines)
+
+    def _check_rule_enabled(self, rule_name: str) -> bool:
+        """Check if a markdownlint rule is enabled in config.
+
+        Args:
+            rule_name: Name of the rule (e.g., "MD013", "MD060")
+
+        Returns:
+            True if rule checking is enabled, False otherwise
+        """
+        # Look for markdownlint config files in parent directories
+        current_dir = self.file_path.parent
+        config_names = [
+            ".markdownlint.json",
+            ".markdownlint.jsonc",
+            ".markdownlint.yaml",
+            ".markdownlint.yml",
+            ".markdownlintrc",
+        ]
+
+        # Search up to 5 levels up
+        for _ in range(5):
+            for config_name in config_names:
+                config_path = current_dir / config_name
+                if config_path.exists():
+                    try:
+                        with open(config_path, encoding="utf-8") as f:
+                            if config_name.endswith((".yaml", ".yml")):
+                                config = yaml.safe_load(f)
+                                # yaml.safe_load returns None for empty files
+                                if config is None:
+                                    config = {}
+                            elif config_name.endswith(
+                                (".json", ".jsonc", "rc")
+                            ):
+                                content = f.read()
+                                if config_name.endswith(".jsonc"):
+                                    content = self._remove_jsonc_comments(
+                                        content
+                                    )
+                                config = json.loads(content)
+                            else:
+                                continue
+
+                            # Check if rule is explicitly disabled
+                            if rule_name in config:
+                                return config[rule_name] is not False
+                            # If not specified, assume enabled (markdownlint default)
+                            return True
+                    except (json.JSONDecodeError, yaml.YAMLError, OSError):
+                        # If config can't be read, assume rule is enabled
+                        pass
+
+            # Move up one directory
+            if current_dir.parent == current_dir:
+                break  # Reached root
+            current_dir = current_dir.parent
+
+        # No config found, assume rule is enabled by default
+        return True
+
+    def _check_md013_enabled(self) -> bool:
+        """Check if MD013 is enabled in markdownlint config.
+
+        Returns:
+            True if MD013 checking is enabled, False otherwise
+        """
+        return self._check_rule_enabled("MD013")
+
+    def _check_md060_enabled(self) -> bool:
+        """Check if MD060 is enabled in markdownlint config.
+
+        Returns:
+            True if MD060 checking is enabled, False otherwise
+        """
+        return self._check_rule_enabled("MD060")
+
+    def _table_has_emojis(self, table: MarkdownTable) -> bool:
+        """Check if table contains emoji characters.
+
+        Emojis cause alignment issues because they take 1 character position
+        but display as 2 characters wide, making MD060 compliance impossible.
+
+        Args:
+            table: The table to check
+
+        Returns:
+            True if table contains emojis
+        """
+        # Emoji pattern - matches most common emoji ranges
+        emoji_pattern = re.compile(
+            "["
+            "\U0001f600-\U0001f64f"  # emoticons
+            "\U0001f300-\U0001f5ff"  # symbols & pictographs
+            "\U0001f680-\U0001f6ff"  # transport & map symbols
+            "\U0001f1e0-\U0001f1ff"  # flags (iOS)
+            "\U00002702-\U000027b0"  # dingbats
+            "\U000024c2-\U0001f251"  # enclosed characters
+            "\U0001f900-\U0001f9ff"  # supplemental symbols
+            "\U0001fa00-\U0001faff"  # extended pictographs
+            "]+",
+            flags=re.UNICODE,
+        )
+
+        for row in table.rows:
+            for cell in row.cells:
+                if emoji_pattern.search(cell.content):
+                    return True
+        return False
+
+    def _parse_markdownlint_comment(
+        self, line: str, comment_type: str
+    ) -> set[str]:
+        """Parse markdownlint comment to extract rule names.
+
+        Args:
+            line: The line to parse
+            comment_type: Either "disable" or "enable"
+
+        Returns:
+            Set of rule names found in the comment (e.g., {"MD013", "MD060"})
+        """
+        # Match markdownlint comments with word boundaries for rule names
+        # Examples:
+        #   <!-- markdownlint-disable MD013 MD060 -->
+        #   <!-- markdownlint-enable MD013 -->
+        pattern = rf"<!--\s*markdownlint-{comment_type}\s+(.*?)\s*-->"
+        match = re.search(pattern, line)
+        if not match:
+            return set()
+
+        # Extract the rules part and split by whitespace
+        rules_text = match.group(1)
+        # Match MD followed by digits, using word boundaries to avoid false matches
+        rule_pattern = r"\bMD\d+\b"
+        rules = re.findall(rule_pattern, rules_text)
+        return set(rules)
 
     def fix_file(
         self, tables: list[MarkdownTable], dry_run: bool = False
@@ -232,7 +437,10 @@ class FileFixer:
         # Build a map of all tables that need MD013 comments
         tables_needing_md013: dict[int, tuple[MarkdownTable, list[str]]] = {}
 
-        # Check all tables for line length violations (not just fixed ones)
+        # Build a map of tables needing MD060 comments (tables with emojis)
+        tables_needing_md060: dict[int, tuple[MarkdownTable, list[str]]] = {}
+
+        # Check all tables for line length violations and emoji issues
         for table in all_tables:
             # Get the table content (either fixed or original)
             table_lines = []
@@ -261,24 +469,50 @@ class FileFixer:
             if needs_md013:
                 tables_needing_md013[table.start_line] = (table, table_lines)
 
+            # Check if table has emojis (causes MD060 violations)
+            if self._md060_enabled and self._table_has_emojis(table):
+                tables_needing_md060[table.start_line] = (table, table_lines)
+
         # Create a unified list of all table modifications to apply
-        # This includes both fixes and MD013-only tables
-        all_modifications: list[tuple[int, int, list[str], bool]] = []
+        # This includes fixes, MD013-only tables, and MD060-only tables
+        all_modifications: list[tuple[int, int, list[str], bool, bool]] = []
 
         # Add fixes to modifications list
         for fix in fixes:
             fixed_lines = fix.fixed_content.split("\n")
             needs_md013 = fix.start_line in tables_needing_md013
+            needs_md060 = fix.start_line in tables_needing_md060
             all_modifications.append(
-                (fix.start_line, fix.end_line, fixed_lines, needs_md013)
+                (
+                    fix.start_line,
+                    fix.end_line,
+                    fixed_lines,
+                    needs_md013,
+                    needs_md060,
+                )
             )
 
         # Add tables that need MD013 but have no fixes
         for start_line, (table, table_lines) in tables_needing_md013.items():
             # Check if already in fixes
             if not any(mod[0] == start_line for mod in all_modifications):
+                needs_md060 = start_line in tables_needing_md060
                 all_modifications.append(
-                    (table.start_line, table.end_line, table_lines, True)
+                    (
+                        table.start_line,
+                        table.end_line,
+                        table_lines,
+                        True,
+                        needs_md060,
+                    )
+                )
+
+        # Add tables that need MD060 but have no fixes or MD013
+        for start_line, (table, table_lines) in tables_needing_md060.items():
+            # Check if already in fixes or MD013 list
+            if not any(mod[0] == start_line for mod in all_modifications):
+                all_modifications.append(
+                    (table.start_line, table.end_line, table_lines, False, True)
                 )
 
         # Apply all modifications in reverse order to maintain line numbers
@@ -286,22 +520,37 @@ class FileFixer:
         if not all_modifications:
             return
 
-        for start_line, end_line, content_lines, needs_md013 in sorted(
-            all_modifications, key=lambda x: x[0], reverse=True
-        ):
+        for (
+            start_line,
+            end_line,
+            content_lines,
+            needs_md013,
+            needs_md060,
+        ) in sorted(all_modifications, key=lambda x: x[0], reverse=True):
             start_idx = start_line - 1
             end_idx = end_line
 
             # Prepare the lines to insert
             new_lines = [line + "\n" for line in content_lines]
 
-            # Add MD013 comments if needed
-            if needs_md013:
+            # Collect all disable/enable rules needed
+            disable_rules = []
+            if needs_md013 and self._md013_enabled:
+                disable_rules.append("MD013")
+            if needs_md060 and self._md060_enabled:
+                disable_rules.append("MD060")
+
+            # Add markdownlint comments if needed
+            if disable_rules:
+                disable_comment = " ".join(disable_rules)
                 # Check if disable comment already exists within 3 lines before the table
                 has_disable = False
                 check_start = max(0, start_idx - 3)
                 for i in range(check_start, start_idx):
-                    if "markdownlint-disable MD013" in lines[i]:
+                    found_rules = self._parse_markdownlint_comment(
+                        lines[i], "disable"
+                    )
+                    if all(rule in found_rules for rule in disable_rules):
                         has_disable = True
                         break
 
@@ -309,7 +558,10 @@ class FileFixer:
                 has_enable = False
                 check_end = min(len(lines), end_idx + 3)
                 for i in range(end_idx, check_end):
-                    if "markdownlint-enable MD013" in lines[i]:
+                    found_rules = self._parse_markdownlint_comment(
+                        lines[i], "enable"
+                    )
+                    if all(rule in found_rules for rule in disable_rules):
                         has_enable = True
                         break
 
@@ -320,13 +572,15 @@ class FileFixer:
                         # No blank line, add both blank line and comment
                         new_lines.insert(0, "\n")
                         new_lines.insert(
-                            1, "<!-- markdownlint-disable MD013 -->\n"
+                            1,
+                            f"<!-- markdownlint-disable {disable_comment} -->\n",
                         )
                         new_lines.insert(2, "\n")
                     else:
                         # Blank line exists, just add comment
                         new_lines.insert(
-                            0, "<!-- markdownlint-disable MD013 -->\n"
+                            0,
+                            f"<!-- markdownlint-disable {disable_comment} -->\n",
                         )
                         new_lines.insert(1, "\n")
 
@@ -334,7 +588,9 @@ class FileFixer:
                 if not has_enable:
                     # Always add blank line and enable comment
                     new_lines.append("\n")
-                    new_lines.append("<!-- markdownlint-enable MD013 -->\n")
+                    new_lines.append(
+                        f"<!-- markdownlint-enable {disable_comment} -->\n"
+                    )
 
             # Replace the section
             lines[start_idx:end_idx] = new_lines

{markdown_table_fixer-0.1.2 → markdown_table_fixer-0.1.3}/src/markdown_table_fixer/table_parser.py

@@ -170,9 +170,9 @@ class TableParser:
         if stripped.endswith("|"):
             stripped = stripped[:-1]
 
-        # Split by pipe to get cells
+        # Split by pipe to get cells, but handle escaped pipes and HTML entities
         # We need to track column positions for alignment checking
-        parts = stripped.split("|")
+        parts = self._split_by_unescaped_pipes(stripped)
 
         current_col = 1  # Start after first pipe
         for part in parts:
@@ -189,6 +189,49 @@ class TableParser:
 
         return cells
 
+    def _split_by_unescaped_pipes(self, text: str) -> list[str]:
+        """Split text by pipes, but not escaped pipes or HTML entities.
+
+        Args:
+            text: Text to split
+
+        Returns:
+            List of cell contents
+        """
+        parts = []
+        current = []
+        i = 0
+
+        while i < len(text):
+            # Check for backslash-escaped pipe
+            if i < len(text) - 1 and text[i : i + 2] == r"\|":
+                # Keep the escaped pipe in the content
+                current.append(text[i : i + 2])
+                i += 2
+            # Check for HTML entity for pipe (&#124;)
+            elif i < len(text) - 5 and text[i : i + 6] == "&#124;":
+                # Keep the HTML entity in the content
+                current.append(text[i : i + 6])
+                i += 6
+            # Check for unescaped pipe (cell separator)
+            elif text[i] == "|":
+                # This is a cell separator
+                parts.append("".join(current))
+                current = []
+                i += 1
+            else:
+                # Regular character
+                current.append(text[i])
+                i += 1
+
+        # Add the last cell
+        if (
+            current or parts
+        ):  # Include empty last cell if there were previous parts
+            parts.append("".join(current))
+
+        return parts
+
 
 class MarkdownFileScanner:
     """Scanner for finding markdown files."""

{markdown_table_fixer-0.1.2 → markdown_table_fixer-0.1.3}/src/markdown_table_fixer/table_validator.py

@@ -188,8 +188,11 @@ class TableValidator:
     def _calculate_column_widths(self) -> list[int]:
         """Calculate the maximum width needed for each column.
 
+        For MD060 compliance, we calculate widths based on character length.
+        This uses string length, not display width or byte length.
+
         Returns:
-            List of column widths
+            List of column widths (in characters)
         """
         if not self.table.rows:
             return []
@@ -203,6 +206,7 @@ class TableValidator:
             for row in self.table.rows:
                 if col_idx < len(row.cells):
                     cell = row.cells[col_idx]
+                    # Use character length for MD060 compliance (pipe alignment)
                     content_width = len(cell.content.strip())
                     max_width = max(max_width, content_width)
             widths.append(max_width)
@@ -213,10 +217,10 @@ class TableValidator:
         """Calculate expected positions of pipes based on column widths.
 
         Args:
-            column_widths: Width of each column
+            column_widths: Width of each column (in characters)
 
         Returns:
-            List of pipe positions
+            List of pipe positions (in characters)
         """
         positions: list[int] = [0]  # Starting pipe at position 0
         current_pos = 0
@@ -237,13 +241,22 @@ class TableValidator:
             row: The row to analyze
 
         Returns:
-            List of pipe positions
+            List of pipe positions (in characters)
         """
         positions: list[int] = []
         line = row.raw_line
 
         for idx, char in enumerate(line):
             if char == "|":
+                # Skip escaped pipes (preceded by an odd number of backslashes)
+                backslash_count = 0
+                j = idx - 1
+                while j >= 0 and line[j] == "\\":
+                    backslash_count += 1
+                    j -= 1
+                if backslash_count % 2 == 1:
+                    # Odd number of backslashes means the pipe is escaped
+                    continue
                 positions.append(idx)
 
         return positions