docspan 0.1.0__py3-none-any.whl

docspan/backends/confluence/markdown/extensions/__init__.py

@@ -0,0 +1,5 @@
+"""
+Markdown extensions module.
+
+This module provides extensions for the Markdown parser.
+"""

docspan/backends/confluence/markdown/extensions/frontmatter.py

@@ -0,0 +1,80 @@
+"""
+Frontmatter parser extension.
+"""
+
+import re
+from typing import Any, Dict, Optional, Tuple
+
+
+class FrontmatterParser:
+    """
+    Parser for YAML frontmatter in Markdown files.
+    """
+
+    @staticmethod
+    def extract(content: str) -> Tuple[Dict[str, Any], str]:
+        """
+        Extract YAML frontmatter from content.
+
+        Args:
+            content: Markdown content with frontmatter
+
+        Returns:
+            Tuple of (frontmatter dict, content without frontmatter)
+        """
+        frontmatter_pattern = re.compile(r"^---\s*\n(.*?)\n---\s*\n", re.DOTALL)
+        match = frontmatter_pattern.match(content)
+
+        if match:
+            try:
+                import yaml
+
+                frontmatter = yaml.safe_load(match.group(1)) or {}
+                # Remove frontmatter from content
+                remaining_content = content[match.end() :]
+                return frontmatter, remaining_content
+            except (yaml.YAMLError, ImportError):
+                # Invalid YAML or yaml module not available
+                pass
+
+        return {}, content
+
+    @staticmethod
+    def get_title(frontmatter: Dict[str, Any], default: Optional[str] = None) -> Optional[str]:
+        """
+        Get title from frontmatter.
+
+        Args:
+            frontmatter: Frontmatter dictionary
+            default: Default value if title not found
+
+        Returns:
+            Title or default value
+        """
+        return frontmatter.get("connie-title", frontmatter.get("title", default))
+
+    @staticmethod
+    def get_page_id(frontmatter: Dict[str, Any]) -> Optional[str]:
+        """
+        Get Confluence page ID from frontmatter.
+
+        Args:
+            frontmatter: Frontmatter dictionary
+
+        Returns:
+            Page ID or None
+        """
+        return frontmatter.get("connie-page-id")
+
+    @staticmethod
+    def should_publish(frontmatter: Dict[str, Any]) -> bool:
+        """
+        Check if page should be published based on frontmatter.
+
+        Args:
+            frontmatter: Frontmatter dictionary
+
+        Returns:
+            True if page should be published, False otherwise
+        """
+        return frontmatter.get("connie-publish", True)

docspan/backends/confluence/markdown/extensions/mermaid.py

@@ -0,0 +1,64 @@
+"""
+Mermaid diagram parser extension.
+"""
+
+import re
+import uuid
+from typing import List, Optional, Tuple
+
+from docspan.backends.confluence.markdown.ast import MarkdownNode, MermaidNode
+
+
+class MermaidParser:
+    """
+    Parser for Mermaid diagram code blocks.
+    """
+
+    @staticmethod
+    def parse(content: str) -> List[Tuple[str, MarkdownNode]]:
+        """
+        Parse Mermaid diagrams in content and return list of replacements.
+
+        Args:
+            content: Markdown content to parse
+
+        Returns:
+            List of tuples (original text, MermaidNode)
+        """
+        pattern = r"```mermaid\n([\s\S]+?)\n```"
+        matches = re.finditer(pattern, content)
+
+        replacements = []
+        for match in matches:
+            original = match.group(0)
+            code = match.group(1).strip()
+
+            node = MermaidNode(code=code)
+            node.attrs["id"] = str(uuid.uuid4())
+
+            replacements.append((original, node))
+
+        return replacements
+
+    @staticmethod
+    def render_diagram(code: str, output_path: Optional[str] = None) -> Optional[str]:
+        """
+        Render a Mermaid diagram to an image file.
+
+        Args:
+            code: Mermaid diagram code
+            output_path: Path to save the rendered image (generated if None)
+
+        Returns:
+            Path to the rendered image or None if rendering failed
+
+        Note:
+            This is a placeholder. Implementation would typically use a library like
+            node-mermaid or puppeteer to render the diagram.
+        """
+        # TODO: Implement actual rendering logic
+        # For now, just return a dummy path
+        if not output_path:
+            output_path = f"diagram_{uuid.uuid4()}.png"
+
+        return output_path

docspan/backends/confluence/markdown/extensions/wikilinks.py

@@ -0,0 +1,179 @@
+"""
+Wikilinks parser extension.
+"""
+
+import re
+from typing import Any, Dict, List, Optional, Tuple
+
+from docspan.backends.confluence.markdown.ast import LinkNode, MarkdownNode, TextNode, WikiLinkNode
+
+
+class WikilinksParser:
+    """
+    Parser for wiki-style links ([[page]] or [[page|title]]).
+    """
+
+    PATTERN = r"\[\[([^\]|]+)(?:\|([^\]]+))?\]\]"
+
+    @classmethod
+    def parse(cls, content: str) -> List[Tuple[str, MarkdownNode]]:
+        """
+        Parse wiki links in content and return list of replacements.
+
+        Args:
+            content: Text content to parse
+
+        Returns:
+            List of tuples (original text, WikiLinkNode)
+        """
+        pattern = cls.PATTERN
+        matches = re.finditer(pattern, content)
+
+        replacements = []
+        for match in matches:
+            original = match.group(0)
+            target = match.group(1).strip()
+            display = match.group(2).strip() if match.group(2) else None
+
+            node = WikiLinkNode(target=target, display=display)
+            replacements.append((original, node))
+
+        return replacements
+
+    @classmethod
+    def replace_wikilinks(
+        cls, text_node: TextNode, page_map: Dict[str, Any] = None
+    ) -> List[MarkdownNode]:
+        """
+        Replace wiki links in a text node with link nodes.
+
+        Args:
+            text_node: Text node to process
+            page_map: Optional mapping of page names to page IDs
+
+        Returns:
+            List of nodes with wiki links replaced
+        """
+        if not text_node.content:
+            return [text_node]
+
+        content = text_node.content
+        pattern = cls.PATTERN
+
+        # Find all wikilink matches
+        matches = list(re.finditer(pattern, content))
+        if not matches:
+            return [text_node]
+
+        # Create result nodes
+        result = []
+        last_end = 0
+
+        for match in matches:
+            start, end = match.span()
+
+            # Add text before the link
+            if start > last_end:
+                result.append(TextNode(content=content[last_end:start]))
+
+            # Process the link
+            target = match.group(1).strip()
+            display = match.group(2).strip() if match.group(2) else target
+
+            # Resolve link target if page map provided
+            page_id = None
+            if page_map:
+                page_id = cls.resolve_link(target, page_map)
+
+            # Create a wiki link node or standard link node
+            if page_id:
+                # Create regular link to Confluence page
+                result.append(LinkNode(url=f"#page-{page_id}", title=target))
+                link_node = result[-1]
+                link_node.children.append(TextNode(content=display))
+            else:
+                # Create wiki link node
+                result.append(WikiLinkNode(target=target, display=display))
+
+            last_end = end
+
+        # Add remaining text
+        if last_end < len(content):
+            result.append(TextNode(content=content[last_end:]))
+
+        return result
+
+    @classmethod
+    def resolve_link(cls, target: str, page_map: Dict[str, Any]) -> Optional[str]:
+        """
+        Resolve wiki link target to a Confluence page ID.
+
+        Args:
+            target: Link target (page name)
+            page_map: Dictionary mapping page names to page IDs
+
+        Returns:
+            Page ID or None if not found
+        """
+        # Check direct match
+        if target in page_map:
+            return page_map[target]
+
+        # Try case-insensitive match
+        target_lower = target.lower()
+        for name, page_id in page_map.items():
+            if name.lower() == target_lower:
+                return page_id
+
+        # Try with different separators
+        normalized_target = cls._normalize_page_name(target)
+        for name, page_id in page_map.items():
+            normalized_name = cls._normalize_page_name(name)
+            if normalized_name == normalized_target:
+                return page_id
+
+        return None
+
+    @staticmethod
+    def _normalize_page_name(name: str) -> str:
+        """
+        Normalize a page name for comparison.
+
+        Args:
+            name: Page name to normalize
+
+        Returns:
+            Normalized page name
+        """
+        # Replace spaces, hyphens, and underscores with a common separator
+        result = re.sub(r"[ \-_]+", "-", name.lower())
+        # Remove any non-alphanumeric chars (except dashes)
+        result = re.sub(r"[^\w\-]", "", result, flags=re.ASCII)
+        return result
+
+    @classmethod
+    def build_page_map(cls, pages: List[Dict[str, Any]]) -> Dict[str, str]:
+        """
+        Build a mapping of page titles to page IDs.
+
+        Args:
+            pages: List of page data dictionaries
+
+        Returns:
+            Dictionary mapping page titles to page IDs
+        """
+        result = {}
+
+        for page in pages:
+            title = page.get("title")
+            page_id = page.get("id")
+
+            if title and page_id:
+                result[title] = page_id
+
+                # Also add normalized version
+                normalized = cls._normalize_page_name(title)
+                if normalized != title.lower():
+                    result[normalized] = page_id
+
+        return result