rolfedh-doc-utils 0.1.25__tar.gz → 0.1.27__tar.gz

{rolfedh_doc_utils-0.1.25/rolfedh_doc_utils.egg-info → rolfedh_doc_utils-0.1.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rolfedh-doc-utils
-Version: 0.1.25
+Version: 0.1.27
 Summary: CLI tools for AsciiDoc documentation projects
 Author: Rolfe Dlugy-Hegwer
 License: MIT License

{rolfedh_doc_utils-0.1.25 → rolfedh_doc_utils-0.1.27}/callout_lib/detector.py

@@ -2,11 +2,13 @@
 Callout Detection Module
 
 Detects code blocks with callouts and extracts callout information from AsciiDoc files.
+Supports both list-format and table-format callout explanations.
 """
 
 import re
 from typing import List, Dict, Tuple, Optional
 from dataclasses import dataclass
+from .table_parser import TableParser
 
 
 @dataclass
@@ -50,6 +52,10 @@ class CalloutDetector:
     # Excludes heredoc syntax (<<) and comparison operators
     USER_VALUE_PATTERN = re.compile(r'(?<!<)<([a-zA-Z][^>]*)>')
 
+    def __init__(self):
+        """Initialize detector with table parser."""
+        self.table_parser = TableParser()
+
     def find_code_blocks(self, lines: List[str]) -> List[CodeBlock]:
         """Find all code blocks in the document."""
         blocks = []
@@ -151,8 +157,95 @@ class CalloutDetector:
     def extract_callout_explanations(self, lines: List[str], start_line: int) -> Tuple[Dict[int, Callout], int]:
         """
         Extract callout explanations following a code block.
+        Supports list-format (<1> text), 2-column table, and 3-column table formats.
         Returns dict of callouts and the line number where explanations end.
         """
+        # First, try to find a table-format callout explanation
+        table = self.table_parser.find_callout_table_after_code_block(lines, start_line)
+        if table:
+            # Check if it's a 3-column table (Item | Value | Description)
+            if self.table_parser.is_3column_callout_table(table):
+                return self._extract_from_3column_table(table)
+            # Check if it's a 2-column table (<callout> | explanation)
+            elif self.table_parser.is_callout_table(table):
+                return self._extract_from_table(table)
+
+        # Fall back to list-format extraction
+        return self._extract_from_list(lines, start_line)
+
+    def _extract_from_table(self, table) -> Tuple[Dict[int, Callout], int]:
+        """Extract callout explanations from a table format."""
+        explanations = {}
+        table_data = self.table_parser.extract_callout_explanations_from_table(table)
+
+        for callout_num, (explanation_lines, conditionals) in table_data.items():
+            # Combine explanation lines with conditionals preserved
+            all_lines = []
+            for line in explanation_lines:
+                all_lines.append(line)
+
+            # Add conditionals as separate lines (they'll be preserved in output)
+            all_lines.extend(conditionals)
+
+            # Check if marked as optional
+            is_optional = False
+            if all_lines and (all_lines[0].lower().startswith('optional.') or
+                             all_lines[0].lower().startswith('optional:')):
+                is_optional = True
+                all_lines[0] = all_lines[0][9:].strip()
+            elif all_lines and ('(Optional)' in all_lines[0] or '(optional)' in all_lines[0]):
+                is_optional = True
+                all_lines[0] = re.sub(r'\s*\(optional\)\s*', ' ', all_lines[0], flags=re.IGNORECASE).strip()
+
+            explanations[callout_num] = Callout(callout_num, all_lines, is_optional)
+
+        return explanations, table.end_line
+
+    def _extract_from_3column_table(self, table) -> Tuple[Dict[int, Callout], int]:
+        """
+        Extract callout explanations from a 3-column table format.
+        Format: Item (number) | Value | Description
+        """
+        explanations = {}
+        table_data = self.table_parser.extract_3column_callout_explanations(table)
+
+        for callout_num, (value_lines, description_lines, conditionals) in table_data.items():
+            # Combine value and description into explanation lines
+            # Strategy: Include value as context, then description
+            all_lines = []
+
+            # Add value lines with context
+            if value_lines:
+                # Format: "Refers to `value`. Description..."
+                value_text = value_lines[0] if value_lines else ""
+                # If value is code-like (contains backticks or special chars), keep it formatted
+                if value_text:
+                    all_lines.append(f"Refers to {value_text}.")
+
+                # Add additional value lines if multi-line
+                for line in value_lines[1:]:
+                    all_lines.append(line)
+
+            # Add description lines
+            all_lines.extend(description_lines)
+
+            # Add conditionals as separate lines (they'll be preserved in output)
+            all_lines.extend(conditionals)
+
+            # Check if marked as optional
+            is_optional = False
+            if all_lines and (all_lines[0].lower().startswith('optional.') or
+                             all_lines[0].lower().startswith('optional:') or
+                             'optional' in all_lines[0].lower()[:50]):  # Check first 50 chars
+                is_optional = True
+                # Don't remove "optional" text - it's part of the description
+
+            explanations[callout_num] = Callout(callout_num, all_lines, is_optional)
+
+        return explanations, table.end_line
+
+    def _extract_from_list(self, lines: List[str], start_line: int) -> Tuple[Dict[int, Callout], int]:
+        """Extract callout explanations from list format (<1> text)."""
         explanations = {}
         i = start_line + 1  # Start after the closing delimiter