markitecture 0.1.15__py3-none-any.whl

markitecture/metrics/badges/shields.py

@@ -0,0 +1,124 @@
+from typing import Dict
+
+from markitecture.metrics.analyzer import ReadabilityMetrics
+
+
+class ShieldsBadgeGenerator:
+    def __init__(self):
+        self.HEIGHT = 20
+        self.FONT_SIZE = 11
+        self.TEXT_MARGIN = 6
+        self.COLORS = {
+            "low": "#7934C5",  # Purple
+            "medium": "#00E5FF",  # Cyan
+            "high": "#FFD700",  # Gold
+        }
+        self.SHIELDS_BG = "#555555"
+
+    def _calculate_width(self, text: str) -> int:
+        return len(text) * 6 + self.TEXT_MARGIN * 2
+
+    def _get_status_color(self, score: float) -> str:
+        if score < 40:
+            return self.COLORS["low"]
+        elif score < 70:
+            return self.COLORS["medium"]
+        return self.COLORS["high"]
+
+    def generate_reading_time_badge(self, minutes: float) -> str:
+        label = "reading time"
+        status = f"{minutes} min"
+        label_width = self._calculate_width(label)
+        status_width = self._calculate_width(status)
+        total_width = label_width + status_width
+        return f'''<svg xmlns="http://www.w3.org/2000/svg" width="{total_width}" height="{self.HEIGHT}">
+  <linearGradient id="smooth" x2="0" y2="100%">
+    <stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
+    <stop offset="1" stop-opacity=".1"/>
+  </linearGradient>
+  <clipPath id="round">
+    <rect width="{total_width}" height="{self.HEIGHT}" rx="3" fill="#fff"/>
+  </clipPath>
+  <g clip-path="url(#round)">
+    <rect width="{label_width}" height="{self.HEIGHT}" fill="{self.SHIELDS_BG}"/>
+    <rect x="{label_width}" width="{status_width}" height="{self.HEIGHT}" fill="#4c1"/>
+    <rect width="{total_width}" height="{self.HEIGHT}" fill="url(#smooth)"/>
+  </g>
+  <g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,Verdana,Geneva,sans-serif" font-size="{self.FONT_SIZE}">
+    <text x="{label_width / 2}" y="15" fill="#010101" fill-opacity=".3">{label}</text>
+    <text x="{label_width / 2}" y="14">{label}</text>
+    <text x="{label_width + status_width / 2}" y="15" fill="#010101" fill-opacity=".3">{status}</text>
+    <text x="{label_width + status_width / 2}" y="14">{status}</text>
+  </g>
+</svg>'''
+
+    def generate_complexity_badge(self, score: float) -> str:
+        label = "complexity"
+        status = f"{score}%"
+        color = self._get_status_color(score)
+        label_width = self._calculate_width(label)
+        status_width = self._calculate_width(status)
+        total_width = label_width + status_width
+        return f'''<svg xmlns="http://www.w3.org/2000/svg" width="{total_width}" height="{self.HEIGHT}">
+  <linearGradient id="smooth" x2="0" y2="100%">
+    <stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
+    <stop offset="1" stop-opacity=".1"/>
+  </linearGradient>
+  <clipPath id="round">
+    <rect width="{total_width}" height="{self.HEIGHT}" rx="3" fill="#fff"/>
+  </clipPath>
+  <g clip-path="url(#round)">
+    <rect width="{label_width}" height="{self.HEIGHT}" fill="{self.SHIELDS_BG}"/>
+    <rect x="{label_width}" width="{status_width}" height="{self.HEIGHT}" fill="{color}"/>
+    <rect width="{total_width}" height="{self.HEIGHT}" fill="url(#smooth)"/>
+  </g>
+  <g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,Verdana,Geneva,sans-serif" font-size="{self.FONT_SIZE}">
+    <text x="{label_width / 2}" y="15" fill="#010101" fill-opacity=".3">{label}</text>
+    <text x="{label_width / 2}" y="14">{label}</text>
+    <text x="{label_width + status_width / 2}" y="15" fill="#010101" fill-opacity=".3">{status}</text>
+    <text x="{label_width + status_width / 2}" y="14">{status}</text>
+  </g>
+</svg>'''
+
+    def generate_stats_badge(self, count: int, label: str, color: str) -> str:
+        status = str(count)
+        label_width = self._calculate_width(label)
+        status_width = self._calculate_width(status)
+        total_width = label_width + status_width
+        return f'''<svg xmlns="http://www.w3.org/2000/svg" width="{total_width}" height="{self.HEIGHT}">
+  <linearGradient id="smooth" x2="0" y2="100%">
+    <stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
+    <stop offset="1" stop-opacity=".1"/>
+  </linearGradient>
+  <clipPath id="round">
+    <rect width="{total_width}" height="{self.HEIGHT}" rx="3" fill="#fff"/>
+  </clipPath>
+  <g clip-path="url(#round)">
+    <rect width="{label_width}" height="{self.HEIGHT}" fill="{self.SHIELDS_BG}"/>
+    <rect x="{label_width}" width="{status_width}" height="{self.HEIGHT}" fill="{color}"/>
+    <rect width="{total_width}" height="{self.HEIGHT}" fill="url(#smooth)"/>
+  </g>
+  <g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,Verdana,Geneva,sans-serif" font-size="{self.FONT_SIZE}">
+    <text x="{label_width / 2}" y="15" fill="#010101" fill-opacity=".3">{label}</text>
+    <text x="{label_width / 2}" y="14">{label}</text>
+    <text x="{label_width + status_width / 2}" y="15" fill="#010101" fill-opacity=".3">{status}</text>
+    <text x="{label_width + status_width / 2}" y="14">{status}</text>
+  </g>
+</svg>'''
+
+    def generate_badges(self, metrics: ReadabilityMetrics) -> Dict[str, str]:
+        return {
+            "reading_time": self.generate_reading_time_badge(metrics.reading_time_mins),
+            "complexity": self.generate_complexity_badge(metrics.complexity_score),
+            "words": self.generate_stats_badge(metrics.word_count, "words", "#1E90FF"),
+            "headings": self.generate_stats_badge(
+                metrics.heading_count, "headings", "#9370DB"
+            ),
+            "code_blocks": self.generate_stats_badge(
+                metrics.code_block_count, "code blocks", "#FF6347"
+            ),
+            "links": self.generate_stats_badge(metrics.link_count, "links", "#20B2AA"),
+            "images": self.generate_stats_badge(
+                metrics.image_count, "images", "#DEB887"
+            ),
+        }

markitecture/metrics/svg_generator.py

@@ -0,0 +1,70 @@
+from typing import Callable, Dict, Tuple
+
+from markitecture.metrics.analyzer import ReadabilityMetrics
+from markitecture.metrics.badges import (
+    BadgeStyle,
+    CompactBadgeGenerator,
+    DetailedBadgeGenerator,
+    MinimalBadgeGenerator,
+    ModernBadgeGenerator,
+    RetroBadgeGenerator,
+    ShieldsBadgeGenerator,
+)
+
+
+class MetricsSvgGenerator:
+    def __init__(self):
+        self.dimensions: Dict[BadgeStyle, Tuple[int, int]] = {
+            BadgeStyle.MODERN: (560, 140),
+            BadgeStyle.COMPACT: (400, 40),
+            BadgeStyle.DETAILED: (600, 200),
+            BadgeStyle.MINIMAL: (300, 80),
+            BadgeStyle.RETRO: (480, 120),
+        }
+        self.generators: Dict[BadgeStyle, Callable[[ReadabilityMetrics], str]] = {
+            BadgeStyle.MODERN: ModernBadgeGenerator().generate,
+            BadgeStyle.COMPACT: CompactBadgeGenerator().generate,
+            BadgeStyle.DETAILED: DetailedBadgeGenerator().generate,
+            BadgeStyle.MINIMAL: MinimalBadgeGenerator().generate,
+            BadgeStyle.RETRO: RetroBadgeGenerator().generate,
+            BadgeStyle.SHIELDS: self._generate_shields_badge,
+        }
+
+    def _get_gradient_colors(self, score: float) -> Tuple[str, str]:
+        if score < 40:
+            return ("#7934C5", "#4158D0")
+        elif score < 70:
+            return ("#00E5FF", "#4158D0")
+        return ("#FFD700", "#FF00FF")
+
+    def _generate_shields_badge(
+        self, metrics: ReadabilityMetrics, color_start: str, color_end: str
+    ) -> str:
+        generator = ShieldsBadgeGenerator()
+        badges = generator.generate_badges(metrics)
+        width = max(self.dimensions.get(BadgeStyle.MODERN, (560,))[0], 560)
+        total_height = (len(badges) * 25) + 20
+        svg = f"""<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 {width} {total_height}">
+  <defs>
+    <style>
+      @font-face {{
+        font-family: "DejaVu Sans";
+        src: url("https://cdn.jsdelivr.net/npm/dejavu-fonts-ttf@2.37.3/ttf/DejaVuSans.ttf");
+      }}
+    </style>
+  </defs>"""
+        y_pos = 10
+        for badge_svg in badges.values():
+            content = badge_svg.split(">", 1)[1].rsplit("</svg>", 1)[0]
+            svg += f'\n  <g transform="translate(10, {y_pos})">\n    {content}\n  </g>'
+            y_pos += 25
+        svg += "\n</svg>"
+        return svg
+
+    def generate_svg(self, metrics: ReadabilityMetrics, style: BadgeStyle) -> str:
+        if style not in self.generators:
+            raise ValueError(f"Style '{style}' not supported.")
+        if style == BadgeStyle.SHIELDS:
+            color_start, color_end = self._get_gradient_colors(metrics.complexity_score)
+            return self.generators[style](metrics, color_start, color_end)
+        return self.generators[style](metrics)

markitecture/processing/link_validator.py

@@ -0,0 +1,133 @@
+"""Scan documents for broken links in markdown files."""
+
+import os
+import re
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+from typing import Dict, List, Tuple
+from urllib.parse import urlparse
+
+import requests
+
+
+class LinkValidator:
+    """ "
+    Check links in markdown files for accessibility.
+    """
+
+    def __init__(self, timeout: int = 10, max_workers: int = 5):
+        """
+        Initialize the link checker with configurable timeout and concurrency.
+
+        Args:
+            timeout (int): Seconds to wait for each HTTP request
+            max_workers (int): Maximum number of concurrent requests
+        """
+        self.timeout = timeout
+        self.max_workers = max_workers
+        self.inline_link_pattern = re.compile(r"\[([^\]]+)\]\(([^)]+)\)")
+        self.ref_link_pattern = re.compile(r"\[([^\]]+)\]:\s*(\S+)")
+
+    def extract_links(self, content: str) -> List[Tuple[str, str, int]]:
+        """
+        Extract inline and reference links from markdown content.
+
+        Args:
+            content (str): Markdown content
+
+        Returns:
+            List[Tuple[str, str, int]]: List of (text, url, line_number)
+        """
+        links = []
+
+        # Extract inline links
+        for line_num, line in enumerate(content.splitlines(), 1):
+            links.extend(
+                (match.group(1), match.group(2).strip(), line_num)
+                for match in self.inline_link_pattern.finditer(line)
+            )
+
+        # Extract reference links
+        links.extend(
+            (match.group(1), match.group(2).strip(), line_num)
+            for line_num, line in enumerate(content.splitlines(), 1)
+            for match in self.ref_link_pattern.finditer(line)
+        )
+
+        return links
+
+    def check_link(self, url: str) -> Dict:
+        """
+        Check if a link is accessible.
+
+        Args:
+            url (str): URL to check
+
+        Returns:
+            Dict: Dictionary with status and error information
+        """
+        result = {"url": url, "status": "unknown", "error": None}
+
+        if url.startswith("#"):  # Skip internal links
+            result["status"] = "internal"
+            return result
+
+        if not urlparse(url).scheme:  # Handle local file paths
+            if os.path.exists(url):
+                result["status"] = "ok"
+            else:
+                result["status"] = "error"
+                result["error"] = "File not found"
+            return result
+
+        try:
+            response = requests.head(url, timeout=self.timeout, allow_redirects=True)
+            if response.status_code == 405:
+                response = requests.get(url, timeout=self.timeout)
+
+            if response.status_code == 200:
+                result["status"] = "ok"
+            else:
+                result["status"] = "error"
+                result["error"] = f"HTTP {response.status_code}"
+        except requests.RequestException as e:
+            result["status"] = "error"
+            result["error"] = str(e)
+
+        return result
+
+    def check_markdown_file(self, filepath: str) -> List[Dict[str, str]]:
+        """
+        Check all links in a markdown file.
+
+        Args:
+            filepath (str): Path to the markdown file
+
+        Returns:
+            List[Dict]: List of results for each link check
+        """
+        try:
+            content = Path(filepath).read_text(encoding="utf-8")
+        except OSError as e:
+            return [{"error": f"Failed to read file: {e}"}]
+
+        links = self.extract_links(content)
+        results = []
+
+        with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
+            futures = {
+                executor.submit(self.check_link, url): (text, url, line)
+                for text, url, line in links
+            }
+            for future in futures:
+                text, url, line = futures[future]
+                result = future.result()
+                results.append({
+                    "text": text,
+                    "url": url,
+                    "line": line,
+                    "status": result["status"],
+                    "error": result.get("error"),
+                })
+
+        return results

markitecture/processing/reflink_converter.py

@@ -0,0 +1,198 @@
+"""Reference link handling with sectional placement support."""
+
+import re
+from dataclasses import dataclass
+from enum import StrEnum, auto
+from pathlib import Path
+from typing import Dict, List, Optional
+
+
+class ReferencePlacement(StrEnum):
+    """Controls where reference links are placed in the document."""
+
+    END = auto()
+    SECTION = auto()
+
+
+@dataclass
+class Section:
+    """Represents a markdown section with its references."""
+
+    content: str
+    level: int
+    references: Dict[str, str]
+    start: int
+    end: int
+
+
+class ReferenceLinkConverter:
+    """converter for managing reference-style links with section support."""
+
+    def __init__(self) -> None:
+        """Initialize patterns for finding links and headers."""
+        self.link_pattern = r"\[([^\]]+)\]\(([^\)]+)\)"
+        self.header_pattern = r"^(#{1,6})\s+(.+?)(?:\s+<!--.*?-->)*\s*$"
+
+    def _extract_sections(self, content: str) -> List[Section]:
+        """Extract document sections based on headers."""
+        sections: List[Section] = []
+        lines = content.splitlines()
+        current_section: Optional[Section] = None
+
+        for i, line in enumerate(lines):
+            header_match = re.match(self.header_pattern, line)
+
+            if header_match:
+                # If we have a previous section, finalize it
+                if current_section:
+                    current_section.end = i
+                    sections.append(current_section)
+
+                # Start new section
+                level = len(header_match.group(1))
+                current_section = Section(
+                    content="", level=level, references={}, start=i, end=-1
+                )
+
+        # Handle the last section
+        if current_section:
+            current_section.end = len(lines)
+            sections.append(current_section)
+
+        # If no sections found, treat entire document as one section
+        if not sections:
+            sections = [
+                Section(
+                    content=content, level=0, references={}, start=0, end=len(lines)
+                )
+            ]
+
+        return sections
+
+    def _process_section_content(
+        self, content: str, section: Section, used_refs: Dict[str, str]
+    ) -> str:
+        """Process content for a single section, adding references if needed."""
+        lines = content.splitlines()
+        section_lines = lines[section.start : section.end]
+
+        # Find all link matches in this section
+        matches = list(re.finditer(self.link_pattern, "\n".join(section_lines)))
+        if not matches:
+            return content
+
+        # Convert links and track references for this section
+        modified_lines = section_lines.copy()
+        references = {}
+
+        for match in matches:
+            original = match.group(0)
+            text = match.group(1)
+            url = match.group(2)
+
+            # Generate reference ID
+            ref_id = self._generate_reference_id(text, used_refs)
+            used_refs[ref_id] = text
+            references[ref_id] = url
+
+            # Create reference style link
+            is_image = text.startswith("!")
+            ref_link = f"![{text[1:]}][{ref_id}]" if is_image else f"[{text}][{ref_id}]"
+
+            # Replace in content
+            for i, line in enumerate(modified_lines):
+                if original in line:
+                    modified_lines[i] = line.replace(original, ref_link)
+
+        # Store references for this section
+        section.references = references
+
+        # Update content with modified lines
+        lines[section.start : section.end] = modified_lines
+        return "\n".join(lines)
+
+    def _generate_reference_id(self, text: str, used_refs: Dict[str, str]) -> str:
+        """Generate a unique reference ID based on the link text."""
+        text = text.lstrip("!")
+        ref = re.sub(r"[^\w\s-]", "", text.lower())
+        ref = re.sub(r"[-\s]+", "-", ref).strip("-")
+
+        if not ref:
+            ref = "link"
+
+        base_ref = ref
+        counter = 1
+        while ref in used_refs and used_refs[ref] != text:
+            ref = f"{base_ref}-{counter}"
+            counter += 1
+
+        return ref
+
+    def convert_to_reflinks(
+        self, content: str, placement: ReferencePlacement = ReferencePlacement.END
+    ) -> str:
+        """Convert inline links to reference style with configurable placement."""
+        sections = self._extract_sections(content)
+        used_refs: Dict[str, str] = {}
+        processed_content = content
+
+        # Process each section
+        for section in sections:
+            processed_content = self._process_section_content(
+                processed_content, section, used_refs
+            )
+
+        # Add references based on placement preference
+        if placement == ReferencePlacement.END:
+            # Add all references at end of document
+            all_refs = {}
+            for section in sections:
+                all_refs.update(section.references)
+
+            if all_refs:
+                ref_section = "\n\n---\n\n<!-- REFERENCE LINKS -->\n"
+                for ref_id, url in sorted(all_refs.items()):
+                    ref_section += f"[{ref_id}]: {url}\n"
+                processed_content = processed_content.rstrip() + ref_section + "\n"
+
+        else:  # ReferencePlacement.SECTION
+            # Add references at the end of each section
+            lines = processed_content.splitlines()
+
+            for section in reversed(
+                sections
+            ):  # Process in reverse to maintain positions
+                reflink_comment = "REFERENCE LINKS"
+                header_match = re.match(self.header_pattern, lines[section.start])
+                if header_match:
+                    reflink_comment = (
+                        f"{header_match.group(2).upper()} {reflink_comment}"
+                    )
+                if section.references:
+                    ref_text = f"<!-- {reflink_comment} -->\n"
+                    for ref_id, url in sorted(section.references.items()):
+                        ref_text += f"[{ref_id}]: {url}\n"
+
+                    # Insert references at section end
+                    lines.insert(section.end, f"{ref_text}\n---\n")
+
+            processed_content = "\n".join(lines)
+
+        return processed_content
+
+    def process_file(
+        self,
+        input_path: str | Path,
+        output_path: str | Path | None = None,
+        placement: ReferencePlacement = ReferencePlacement.END,
+    ) -> None:
+        """Process a markdown file and save to a new file."""
+        input_path = Path(input_path)
+        if not input_path.exists():
+            raise FileNotFoundError(f"Input file not found: {input_path}")
+
+        content = input_path.read_text(encoding="utf-8")
+        modified_content = self.convert_to_reflinks(content, placement)
+
+        output_path = Path(output_path) if output_path else input_path
+        output_path.write_text(modified_content, encoding="utf-8")

markitecture/processing/reflink_extractor.py

@@ -0,0 +1,82 @@
+"""Extract and manage reference-style links in Markdown content."""
+
+import re
+from typing import Dict
+
+
+class ReferenceLinkExtractor:
+    """
+    Handles extraction and management of reference-style links in Markdown.
+
+    This class provides functionality to extract reference-style links from markdown
+    content and track which references are actually used within specific sections.
+    """
+
+    def __init__(self, markdown_text: str) -> None:
+        """
+        Initialize the ReferenceLinkExtractor with the entire markdown content.
+
+        Args:
+            markdown_text: The full markdown content as a string.
+        """
+        self.markdown_text = markdown_text
+        self.references = self._extract_references()
+
+    def _extract_references(self) -> dict[str, str]:
+        """
+        Extract reference-style links from the markdown text.
+
+        A reference link follows the pattern:
+        [refname]: http://example.com
+
+        Returns:
+            Dictionary mapping reference names to their URLs.
+        """
+        # Extract references that appear after reference marker comments
+        ref_sections = re.split(r"<!--\s*REFERENCE\s+LINKS\s*-->", self.markdown_text)
+
+        references: dict[str, str] = {}
+        ref_pattern = re.compile(r"^\[([^\]]+)\]:\s*(.+?)\s*$", re.MULTILINE)
+
+        for section in ref_sections:
+            for match in ref_pattern.finditer(section):
+                ref_name = match.group(1).strip()
+                ref_link = match.group(2).strip()
+                references[ref_name] = ref_link
+
+        return references
+
+    def find_used_references(self, section_content: str) -> dict[str, str]:
+        """
+        Find which references are actually used within a given section.
+
+        A reference is considered used if it appears in the form [refname]
+        within the section content, excluding the reference definitions themselves.
+
+        Args:
+            section_content: The markdown content of a section to analyze.
+
+        Returns:
+            Dictionary of references that are actually used in the section,
+            mapping reference names to their URLs.
+        """
+        used_refs: Dict[str, str] = {}
+
+        # Remove any existing reference definitions from the content
+        content_without_refs = re.sub(
+            r"\n*<!--\s*REFERENCE\s+LINKS\s*-->\n*.*$",
+            "",
+            section_content,
+            flags=re.DOTALL,
+        )
+
+        # Find all reference usages, excluding image or link definitions
+        ref_usage_pattern = re.compile(r"\[([^\]]+)\](?!\(|\:)")
+        found = ref_usage_pattern.findall(content_without_refs)
+
+        # Only include references that exist and are actually used
+        for ref in found:
+            if ref in self.references:
+                used_refs[ref] = self.references[ref]
+
+        return used_refs