rolfedh-doc-utils 0.1.28__tar.gz → 0.1.30__tar.gz

{rolfedh_doc_utils-0.1.28/rolfedh_doc_utils.egg-info → rolfedh_doc_utils-0.1.30}/PKG-INFO

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

{rolfedh_doc_utils-0.1.28 → rolfedh_doc_utils-0.1.30}/callout_lib/converter_deflist.py

@@ -70,10 +70,37 @@ class DefListConverter:
                     lines.append('+')
 
                 # Add explanation lines, prepending "Optional. " to first line if needed
+                # Handle blank lines and conditionals by inserting continuation markers
+                need_continuation = False
+                had_content = False  # Track if we've output any non-conditional content
+
                 for line_idx, line in enumerate(explanation.lines):
+                    stripped = line.strip()
+
+                    # Check if this is a blank line
+                    if stripped == '':
+                        # Next non-blank line will need a continuation marker
+                        need_continuation = True
+                        continue  # Skip blank lines
+
+                    # Check if this is a conditional directive
+                    is_conditional = stripped.startswith(('ifdef::', 'ifndef::', 'endif::'))
+
+                    # Add continuation marker if:
+                    # 1. Previous line was blank (need_continuation=True), OR
+                    # 2. This is a conditional and we've had content before (need separator)
+                    if need_continuation or (is_conditional and had_content and line_idx > 0):
+                        lines.append('+')
+                        need_continuation = False
+
+                    # Add the line
                     if line_idx == 0 and explanation.is_optional:
                         lines.append(f'Optional. {line}')
                     else:
                         lines.append(line)
 
+                    # Track that we've output content (not just conditionals)
+                    if not is_conditional:
+                        had_content = True
+
         return lines

{rolfedh_doc_utils-0.1.28 → rolfedh_doc_utils-0.1.30}/callout_lib/detector.py

@@ -184,14 +184,17 @@ class CalloutDetector:
         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
+        for callout_num, (explanation_lines, row_conditionals) in table_data.items():
+            # explanation_lines now includes blank lines and conditionals inline
+            # row_conditionals are before/after the entire row (rarely used)
             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)
+            # Add any row-level conditionals before
+            if row_conditionals:
+                all_lines.extend(row_conditionals)
+
+            # Add explanation lines (already includes inline conditionals and blank lines)
+            all_lines.extend(explanation_lines)
 
             # Check if marked as optional
             is_optional = False
@@ -215,11 +218,15 @@ class CalloutDetector:
         explanations = {}
         table_data = self.table_parser.extract_3column_callout_explanations(table)
 
-        for callout_num, (value_lines, description_lines, conditionals) in table_data.items():
+        for callout_num, (value_lines, description_lines, row_conditionals) in table_data.items():
             # Combine value and description into explanation lines
-            # Strategy: Include value as context, then description
+            # Both value_lines and description_lines now include conditionals and blank lines inline
             all_lines = []
 
+            # Add any row-level conditionals before
+            if row_conditionals:
+                all_lines.extend(row_conditionals)
+
             # Add value lines with context
             if value_lines:
                 # Format: "`value`:"
@@ -228,16 +235,13 @@ class CalloutDetector:
                 if value_text:
                     all_lines.append(f"{value_text}:")
 
-                # Add additional value lines if multi-line
+                # Add additional value lines if multi-line (includes conditionals and blank lines)
                 for line in value_lines[1:]:
                     all_lines.append(line)
 
-            # Add description lines
+            # Add description lines (already includes conditionals and blank 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

{rolfedh_doc_utils-0.1.28 → rolfedh_doc_utils-0.1.30}/callout_lib/table_parser.py

@@ -57,6 +57,44 @@ class TableParser:
     # Pattern for callout number (used for callout table detection)
     CALLOUT_NUMBER = re.compile(r'^<(\d+)>\s*$')
 
+    def _finalize_row_if_complete(self, current_row_cells, conditionals_before_row,
+                                   conditionals_after_row, expected_columns, rows):
+        """
+        Check if we have enough cells for a complete row, and if so, save it.
+
+        Returns: (new_current_row_cells, new_conditionals_before, new_conditionals_after)
+        """
+        if expected_columns > 0 and len(current_row_cells) >= expected_columns:
+            # Row is complete - save it
+            rows.append(TableRow(
+                cells=current_row_cells.copy(),
+                conditionals_before=conditionals_before_row.copy(),
+                conditionals_after=conditionals_after_row.copy()
+            ))
+            return [], [], []  # Reset for next row
+
+        # Row not complete yet
+        return current_row_cells, conditionals_before_row, conditionals_after_row
+
+    def _parse_column_count(self, attributes: str) -> int:
+        """
+        Parse the cols attribute to determine number of columns.
+
+        Example: '[cols="1,7a"]' returns 2
+                 '[cols="1,2,3"]' returns 3
+        """
+        import re
+        # Match cols="..." or cols='...'
+        match = re.search(r'cols=["\']([^"\']+)["\']', attributes)
+        if not match:
+            return 0  # Unknown column count
+
+        cols_spec = match.group(1)
+        # Count comma-separated values
+        # Handle formats like: "1,2", "1a,2a", "1,2,3", etc.
+        columns = cols_spec.split(',')
+        return len(columns)
+
     def find_tables(self, lines: List[str]) -> List[AsciiDocTable]:
         """Find all tables in the document."""
         tables = []
@@ -96,12 +134,20 @@ class TableParser:
         |Cell4
         |===
         """
+        # Get attributes and parse column count
+        attributes = ""
+        if start_line < delimiter_line:
+            attributes = lines[start_line]
+
+        expected_columns = self._parse_column_count(attributes)
+
         i = delimiter_line + 1
         rows = []
         current_row_cells = []
         current_cell_lines = []
         conditionals_before_row = []
         conditionals_after_row = []
+        in_asciidoc_cell = False  # Track if we're in an a| (AsciiDoc) cell
 
         while i < len(lines):
             line = lines[i]
@@ -138,22 +184,29 @@ class TableParser:
 
             # Check for conditional directives
             if self.IFDEF_PATTERN.match(line) or self.ENDIF_PATTERN.match(line):
-                if not current_row_cells:
+                # If we're building a cell (current_cell_lines is not empty) OR
+                # we're in an AsciiDoc cell, add conditional to cell content
+                if current_cell_lines or in_asciidoc_cell:
+                    # Inside a cell - conditional is part of cell content
+                    current_cell_lines.append(line)
+                elif current_row_cells:
+                    # Between cells in the same row
+                    conditionals_after_row.append(line)
+                else:
                     # Conditional before any cells in this row
                     conditionals_before_row.append(line)
-                else:
-                    # Conditional after cells started - treat as part of current context
-                    if current_cell_lines:
-                        # Inside a cell
-                        current_cell_lines.append(line)
-                    else:
-                        # Between cells in the same row
-                        conditionals_after_row.append(line)
                 i += 1
                 continue
 
-            # Blank line separates rows
+            # Blank line handling
             if not line.strip():
+                # In AsciiDoc cells (a|), blank lines are part of cell content
+                if in_asciidoc_cell:
+                    current_cell_lines.append(line)
+                    i += 1
+                    continue
+
+                # Otherwise, blank line separates rows
                 # Save pending cell if exists
                 if current_cell_lines:
                     current_row_cells.append(TableCell(
@@ -161,6 +214,7 @@ class TableParser:
                         conditionals=[]
                     ))
                     current_cell_lines = []
+                    in_asciidoc_cell = False
 
                 # Save row if we have cells
                 if current_row_cells:
@@ -178,6 +232,18 @@ class TableParser:
 
             # Check for cell separator (|)
             if self.CELL_SEPARATOR.match(line):
+                # Check if this is a cell type specifier on its own line (e.g., "a|" or "s|")
+                cell_content = line[1:].strip()  # Remove leading | and whitespace
+
+                # If line is just "a|", "s|", "h|", etc. (cell type specifier alone)
+                if len(cell_content) == 2 and cell_content[0] in 'ashdmev' and cell_content[1] == '|':
+                    # This is a cell type specifier on its own line
+                    if cell_content[0] == 'a':
+                        in_asciidoc_cell = True
+                    # Don't create a cell yet - content comes on following lines
+                    i += 1
+                    continue
+
                 # Save previous cell if exists
                 if current_cell_lines:
                     current_row_cells.append(TableCell(
@@ -185,9 +251,27 @@ class TableParser:
                         conditionals=[]
                     ))
                     current_cell_lines = []
+                    in_asciidoc_cell = False  # Reset for next cell
+
+                    # Check if row is complete (have enough cells based on cols attribute)
+                    current_row_cells, conditionals_before_row, conditionals_after_row = \
+                        self._finalize_row_if_complete(
+                            current_row_cells, conditionals_before_row,
+                            conditionals_after_row, expected_columns, rows
+                        )
 
                 # Extract cell content from this line (text after |)
-                cell_content = line[1:].strip()  # Remove leading |
+                cell_content = line[1:]  # Remove leading |
+
+                # Check for inline cell type specifier (a|text, s|text, etc.)
+                # Cell type specifiers are single characters followed by |
+                if len(cell_content) > 0 and cell_content[0] in 'ashdmev' and len(cell_content) > 1 and cell_content[1] == '|':
+                    # Track if this is an AsciiDoc cell (a|)
+                    if cell_content[0] == 'a':
+                        in_asciidoc_cell = True
+                    cell_content = cell_content[2:]  # Remove type specifier and second |
+
+                cell_content = cell_content.strip()
 
                 # Check if there are multiple cells on the same line (e.g., |Cell1 |Cell2 |Cell3)
                 if '|' in cell_content:
@@ -220,6 +304,39 @@ class TableParser:
                 i += 1
                 continue
 
+            # Check for cell type specifier on its own line (e.g., "a|", "s|", "h|")
+            # This is actually a cell SEPARATOR with type specifier
+            # Example:
+            #   |<1>          ← Cell 1
+            #   a|            ← Start cell 2 with type 'a' (AsciiDoc)
+            #   content...    ← Cell 2 content
+            stripped_line = line.strip()
+            if (len(stripped_line) == 2 and
+                stripped_line[0] in 'ashdmev' and
+                stripped_line[1] == '|' and
+                (current_cell_lines or current_row_cells)):
+                # Save previous cell if we have one
+                if current_cell_lines:
+                    current_row_cells.append(TableCell(
+                        content=current_cell_lines.copy(),
+                        conditionals=[]
+                    ))
+                    current_cell_lines = []
+
+                    # Check if row is complete
+                    current_row_cells, conditionals_before_row, conditionals_after_row = \
+                        self._finalize_row_if_complete(
+                            current_row_cells, conditionals_before_row,
+                            conditionals_after_row, expected_columns, rows
+                        )
+
+                # Set cell type for the NEW cell we're starting
+                if stripped_line[0] == 'a':
+                    in_asciidoc_cell = True
+                # Start collecting content for the new cell (no content on this line)
+                i += 1
+                continue
+
             # Regular content line (continuation of current cell)
             if current_cell_lines or current_row_cells:
                 current_cell_lines.append(line)
@@ -338,25 +455,20 @@ class TableParser:
 
             callout_num = int(match.group(1))
 
-            # Collect explanation lines
+            # Collect explanation lines, preserving blank lines and conditionals inline
+            # Blank lines will need to become continuation markers (+) in definition lists
             explanation_lines = []
             for line in explanation_cell.content:
-                # Skip conditional directives in explanation (preserve them separately)
-                if not (self.IFDEF_PATTERN.match(line) or self.ENDIF_PATTERN.match(line)):
-                    explanation_lines.append(line)
+                # Preserve ALL lines including conditionals and blank lines
+                # Empty lines will be marked as '' which signals need for continuation marker
+                explanation_lines.append(line)
 
-            # Collect all conditionals for this row
-            all_conditionals = []
-            all_conditionals.extend(row.conditionals_before)
+            # Collect conditionals that appear before/after the row
+            row_conditionals = []
+            row_conditionals.extend(row.conditionals_before)
+            row_conditionals.extend(row.conditionals_after)
 
-            # Extract conditionals from explanation cell
-            for line in explanation_cell.content:
-                if self.IFDEF_PATTERN.match(line) or self.ENDIF_PATTERN.match(line):
-                    all_conditionals.append(line)
-
-            all_conditionals.extend(row.conditionals_after)
-
-            explanations[callout_num] = (explanation_lines, all_conditionals)
+            explanations[callout_num] = (explanation_lines, row_conditionals)
 
         return explanations
 
@@ -397,37 +509,22 @@ class TableParser:
 
             callout_num = int(item_num_str)
 
-            # Collect value lines (column 2)
+            # Collect value lines (column 2), preserving all content including conditionals
             value_lines = []
             for line in value_cell.content:
-                # Skip conditional directives in value (preserve them separately)
-                if not (self.IFDEF_PATTERN.match(line) or self.ENDIF_PATTERN.match(line)):
-                    value_lines.append(line)
+                value_lines.append(line)
 
-            # Collect description lines (column 3)
+            # Collect description lines (column 3), preserving all content including conditionals
             description_lines = []
             for line in desc_cell.content:
-                # Skip conditional directives in description (preserve them separately)
-                if not (self.IFDEF_PATTERN.match(line) or self.ENDIF_PATTERN.match(line)):
-                    description_lines.append(line)
-
-            # Collect all conditionals for this row
-            all_conditionals = []
-            all_conditionals.extend(row.conditionals_before)
-
-            # Extract conditionals from value cell
-            for line in value_cell.content:
-                if self.IFDEF_PATTERN.match(line) or self.ENDIF_PATTERN.match(line):
-                    all_conditionals.append(line)
-
-            # Extract conditionals from description cell
-            for line in desc_cell.content:
-                if self.IFDEF_PATTERN.match(line) or self.ENDIF_PATTERN.match(line):
-                    all_conditionals.append(line)
+                description_lines.append(line)
 
-            all_conditionals.extend(row.conditionals_after)
+            # Collect conditionals that appear before/after the row
+            row_conditionals = []
+            row_conditionals.extend(row.conditionals_before)
+            row_conditionals.extend(row.conditionals_after)
 
-            explanations[callout_num] = (value_lines, description_lines, all_conditionals)
+            explanations[callout_num] = (value_lines, description_lines, row_conditionals)
 
         return explanations
 

{rolfedh_doc_utils-0.1.28 → rolfedh_doc_utils-0.1.30}/doc_utils/format_asciidoc_spacing.py

@@ -65,9 +65,16 @@ def process_file(file_path: Path, dry_run: bool = False, verbose: bool = False)
             new_lines.append(current_line)
             in_conditional = False
             # Add blank line after conditional if needed
+            # Don't add if next line is:
+            # - a list item (starts with *, -, ., .., or numbered)
+            # - list continuation (+)
+            # - another conditional
+            # - blank
             if (next_line and
                 not re.match(r'^\s*$', next_line) and
-                not re.match(r'^(ifdef::|ifndef::|endif::)', next_line)):
+                not re.match(r'^(ifdef::|ifndef::|endif::)', next_line) and
+                not re.match(r'^(\*|\-|\.|\.\.|\d+\.)\s', next_line) and  # List items
+                not re.match(r'^\+\s*$', next_line)):  # List continuation
                 new_lines.append("")
                 changes_made = True
                 if verbose:
@@ -102,10 +109,13 @@ def process_file(file_path: Path, dry_run: bool = False, verbose: bool = False)
         # Check for block titles (.Title)
         elif not in_block and not in_comment_block and re.match(r'^\.[A-Z]', current_line):
             # Add blank line before block title if needed
-            if (prev_line and
+            # Don't add if inside a conditional block or if previous line is a conditional directive
+            if (not in_conditional and
+                prev_line and
                 not re.match(r'^\s*$', prev_line) and
                 not re.match(r'^=+\s+', prev_line) and
-                not re.match(r'^\[role=', prev_line)):  # Don't add if previous is heading, empty, or role block
+                not re.match(r'^\[role=', prev_line) and
+                not re.match(r'^(ifdef::|ifndef::|endif::)', prev_line)):  # Don't add if previous is conditional
                 new_lines.append("")
                 changes_made = True
                 if verbose:
@@ -117,11 +127,12 @@ def process_file(file_path: Path, dry_run: bool = False, verbose: bool = False)
         elif not in_block and re.match(r'^=+\s+', current_line):
             new_lines.append(current_line)
 
-            # Check if next line is not empty, not another heading, and not a comment block
+            # Check if next line is not empty, not another heading, not a comment block, and not a conditional
             if (next_line and
                 not re.match(r'^=+\s+', next_line) and
                 not re.match(r'^\s*$', next_line) and
-                not re.match(r'^////+$', next_line)):  # Don't add if next is comment block
+                not re.match(r'^////+$', next_line) and  # Don't add if next is comment block
+                not re.match(r'^(ifdef::|ifndef::|endif::)', next_line)):  # Don't add if next is conditional
                 new_lines.append("")
                 changes_made = True
                 if verbose:

{rolfedh_doc_utils-0.1.28 → rolfedh_doc_utils-0.1.30}/doc_utils/version.py

@@ -1,7 +1,7 @@
 """Version information for doc-utils."""
 
 # This should match the version in pyproject.toml
-__version__ = "0.1.21"
+__version__ = "0.1.30"
 
 def get_version():
     """Return the current version string."""

{rolfedh_doc_utils-0.1.28 → rolfedh_doc_utils-0.1.30}/doc_utils/version_check.py

@@ -141,10 +141,12 @@ def detect_install_method() -> str:
     Detect how the package was installed.
 
     Returns:
-        'pipx', 'pip', or 'unknown'
+        'pipx' or 'pip'
+
+    Note: Defaults to 'pipx' as the recommended installation method.
     """
-    # Check if running from pipx venv
-    if 'pipx' in sys.prefix:
+    # Check if running from pipx venv (standard pipx install)
+    if 'pipx' in sys.prefix.lower():
         return 'pipx'
 
     # Check PIPX_HOME environment variable
@@ -152,8 +154,17 @@ def detect_install_method() -> str:
     if pipx_home and str(Path(sys.prefix)).startswith(str(Path(pipx_home))):
         return 'pipx'
 
-    # Default to pip
-    return 'pip'
+    # Check if executable is in typical pipx bin location
+    try:
+        exe_path = Path(sys.executable)
+        if '.local/pipx' in str(exe_path):
+            return 'pipx'
+    except Exception:
+        pass
+
+    # Default to pipx as the recommended method (per CLAUDE.md guidelines)
+    # This ensures users see the recommended upgrade command even for editable installs
+    return 'pipx'
 
 
 def show_update_notification(latest_version: str, current_version: str = None):

{rolfedh_doc_utils-0.1.28 → rolfedh_doc_utils-0.1.30}/doc_utils_cli.py

@@ -55,9 +55,14 @@ TOOLS = [
     },
     {
         'name': 'convert-callouts-to-deflist',
-        'description': 'Converts callout-style annotations to definition list format',
+        'description': 'Converts callouts to definition lists (batch mode)',
         'example': 'convert-callouts-to-deflist --dry-run modules/'
     },
+    {
+        'name': 'convert-callouts-interactive',
+        'description': 'Interactively converts callouts with per-block format selection',
+        'example': 'convert-callouts-interactive modules/'
+    },
 ]
 
 

{rolfedh_doc_utils-0.1.28 → rolfedh_doc_utils-0.1.30}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "rolfedh-doc-utils"
-version = "0.1.28"
+version = "0.1.30"
 description = "CLI tools for AsciiDoc documentation projects"
 readme = "README.md"
 requires-python = ">=3.8"

{rolfedh_doc_utils-0.1.28 → rolfedh_doc_utils-0.1.30/rolfedh_doc_utils.egg-info}/PKG-INFO

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

{rolfedh_doc_utils-0.1.28 → rolfedh_doc_utils-0.1.30}/tests/test_version_check.py

@@ -26,20 +26,22 @@ class TestDetectInstallMethod:
                 assert detect_install_method() == 'pipx'
 
     def test_detect_pip(self):
-        """Test detection defaults to pip."""
+        """Test detection defaults to pipx (per project guidelines)."""
         with patch('sys.prefix', '/usr'):
             # Clear PIPX_HOME if set
             env = {k: v for k, v in os.environ.items() if k != 'PIPX_HOME'}
             with patch.dict(os.environ, env, clear=True):
-                assert detect_install_method() == 'pip'
+                # Default is now pipx to align with installation recommendations
+                assert detect_install_method() == 'pipx'
 
     def test_detect_pip_user(self):
-        """Test detection for pip --user installations."""
+        """Test detection for pip --user installations defaults to pipx."""
         with patch('sys.prefix', '/home/user/.local'):
             # Clear PIPX_HOME if set
             env = {k: v for k, v in os.environ.items() if k != 'PIPX_HOME'}
             with patch.dict(os.environ, env, clear=True):
-                assert detect_install_method() == 'pip'
+                # Default is now pipx to align with installation recommendations
+                assert detect_install_method() == 'pipx'
 
 
 class TestParseVersion: