rolfedh-doc-utils 0.1.41__tar.gz → 0.1.42__tar.gz

{rolfedh_doc_utils-0.1.41 → rolfedh_doc_utils-0.1.42}/PKG-INFO

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

{rolfedh_doc_utils-0.1.41 → rolfedh_doc_utils-0.1.42}/callout_lib/converter_deflist.py

@@ -41,41 +41,20 @@ class DefListConverter:
         if table_title:
             # Remove leading dot and trailing period if present
             title_text = table_title.lstrip('.').rstrip('.')
-            lines = [f'\n{title_text}, where:']
+            lines = [f'{title_text}, where:']
         else:
-            lines = ['\nwhere:']
+            lines = ['where:']
 
         # Process each group (which may contain one or more callouts)
         for group in callout_groups:
             code_line = group.code_line
             callout_nums = group.callout_numbers
 
-            # COMMENTED OUT: User-replaceable value detection causes false positives
-            # with Java generics (e.g., <MyEntity, Integer>) and other valid syntax
-            # that uses angle brackets. Always use the full code line as the term.
-            #
-            # # Check if this is a user-replaceable value (contains angle brackets but not heredoc)
-            # # User values are single words/phrases in angle brackets like <my-value>
-            # user_values = DefListConverter.USER_VALUE_PATTERN.findall(code_line)
-            #
-            # if user_values and len(user_values) == 1 and len(code_line) < 100:
-            #     # This looks like a user-replaceable value placeholder
-            #     # Format the value (ensure it has angle brackets)
-            #     user_value = user_values[0]
-            #     if not user_value.startswith('<'):
-            #         user_value = f'<{user_value}>'
-            #     if not user_value.endswith('>'):
-            #         user_value = f'{user_value}>'
-            #     term = f'`{user_value}`'
-            # else:
-            #     # This is a code line - strip whitespace before wrapping in backticks
-            #     term = f'`{code_line.strip()}`'
-
             # Always use the full code line - strip whitespace before wrapping in backticks
             term = f'`{code_line.strip()}`'
 
-            # Add blank line before each term
-            lines.append('')
+            # Add continuation marker before each definition term
+            lines.append('+')
             lines.append(f'{term}::')
 
             # Add explanations for all callouts in this group

{rolfedh_doc_utils-0.1.41 → rolfedh_doc_utils-0.1.42}/callout_lib/detector.py

@@ -281,8 +281,8 @@ class CalloutDetector:
         explanations = {}
         i = start_line + 1  # Start after the closing delimiter
 
-        # Skip blank lines and continuation markers (+)
-        while i < len(lines) and (not lines[i].strip() or lines[i].strip() == '+'):
+        # Skip blank lines, continuation markers (+), and {nbsp} spacers
+        while i < len(lines) and (not lines[i].strip() or lines[i].strip() in ('+', '{nbsp}')):
             i += 1
 
         # Collect consecutive callout explanation lines
@@ -298,8 +298,18 @@ class CalloutDetector:
                 # Continue until we hit a blank line, a new callout, or certain patterns
                 while i < len(lines):
                     line = lines[i]
-                    # Stop if we hit a blank line, new callout, or list start marker
-                    if not line.strip() or self.CALLOUT_EXPLANATION.match(line) or line.startswith('[start='):
+                    stripped = line.strip()
+                    # Stop if we hit:
+                    # - blank line
+                    # - new callout explanation
+                    # - list start marker [start=N]
+                    # - standalone + (list continuation that attaches to parent)
+                    # - admonition block start [NOTE], [IMPORTANT], [WARNING], [TIP], [CAUTION]
+                    if (not stripped or
+                        self.CALLOUT_EXPLANATION.match(line) or
+                        line.startswith('[start=') or
+                        stripped == '+' or
+                        stripped in ('[NOTE]', '[IMPORTANT]', '[WARNING]', '[TIP]', '[CAUTION]')):
                         break
                     # Add continuation line preserving original formatting
                     explanation_lines.append(line)

{rolfedh_doc_utils-0.1.41 → rolfedh_doc_utils-0.1.42}/convert_callouts_interactive.py

@@ -381,10 +381,19 @@ class InteractiveCalloutConverter:
                 )
             else:
                 # Remove old explanations, add new list
+                # Find where explanations actually start (skip {nbsp} and + markers to preserve them)
+                explanation_start_line = block.end_line + 1
+                while explanation_start_line < len(new_lines) and (
+                    not new_lines[explanation_start_line].strip() or
+                    new_lines[explanation_start_line].strip() in ('+', '{nbsp}')
+                ):
+                    explanation_start_line += 1
+
                 new_section = (
                     new_lines[:content_start] +
                     converted_content +
-                    [new_lines[content_end]] +
+                    [new_lines[content_end]] +  # Keep closing delimiter
+                    new_lines[content_end + 1:explanation_start_line] +  # Preserve {nbsp} and + markers
                     output_list +
                     new_lines[explanation_end + 1:]
                 )

{rolfedh_doc_utils-0.1.41 → rolfedh_doc_utils-0.1.42}/convert_callouts_to_deflist.py

@@ -245,9 +245,13 @@ class CalloutConverter:
                     # Table format: preserve content between code block and table start
                     explanation_start_line = self.detector.last_table.start_line
                 else:
-                    # List format: skip blank lines after code block
+                    # List format: skip blank lines, {nbsp} spacers, and + continuation markers
+                    # These will be preserved in the output via the slice below
                     explanation_start_line = block.end_line + 1
-                    while explanation_start_line < len(new_lines) and not new_lines[explanation_start_line].strip():
+                    while explanation_start_line < len(new_lines) and (
+                        not new_lines[explanation_start_line].strip() or
+                        new_lines[explanation_start_line].strip() in ('+', '{nbsp}')
+                    ):
                         explanation_start_line += 1
 
                 # Build the new section

rolfedh_doc_utils-0.1.42/convert_id_attributes_to_ids.py

@@ -0,0 +1,229 @@
+#!/usr/bin/env python3
+"""
+convert-id-attributes-to-ids - Convert :id: attribute definitions to AsciiDoc [id="..."] anchors.
+
+This script recursively scans a directory for AsciiDoc files and replaces instances of
+`:id: <id_value>` with `[id="<id_value>_{context}"]`.
+
+Optionally, with --clean-up, it also removes related boilerplate lines:
+- // define ID as an attribute
+- // assign ID conditionally, followed by header
+- include::{modules}/common/id.adoc[]
+"""
+
+import argparse
+import os
+import re
+import sys
+from pathlib import Path
+
+from doc_utils.version_check import check_version_on_startup
+from doc_utils.version import __version__
+from doc_utils.spinner import Spinner
+
+
+def find_adoc_files(directory: Path) -> list[Path]:
+    """Recursively find all .adoc files in a directory."""
+    adoc_files = []
+    for root, dirs, files in os.walk(directory, followlinks=False):
+        # Skip hidden directories and common non-content directories
+        dirs[:] = [d for d in dirs if not d.startswith('.') and d not in ('node_modules', '__pycache__')]
+        for file in files:
+            if file.endswith('.adoc'):
+                adoc_files.append(Path(root) / file)
+    return adoc_files
+
+
+def convert_id_attributes(content: str, clean_up: bool = False) -> tuple[str, int, int]:
+    """
+    Convert :id: attributes to [id="..._{context}"] format.
+
+    Args:
+        content: The file content to process
+        clean_up: If True, also remove boilerplate lines
+
+    Returns:
+        Tuple of (modified_content, id_replacements_count, cleanup_removals_count)
+    """
+    lines = content.split('\n')
+    new_lines = []
+    id_replacements = 0
+    cleanup_removals = 0
+
+    # Patterns for clean-up (flexible matching for variations)
+    cleanup_patterns = [
+        re.compile(r'^\s*//\s*define ID as an attribute', re.IGNORECASE),
+        re.compile(r'^\s*//\s*assign.*ID conditionally', re.IGNORECASE),
+        re.compile(r'^\s*include::\{modules\}/common/id\.adoc\[\]'),
+    ]
+
+    # Pattern to match :id: <value>
+    id_pattern = re.compile(r'^:id:\s*(.+?)\s*$')
+
+    for line in lines:
+        # Check if this is an :id: line
+        id_match = id_pattern.match(line)
+        if id_match:
+            id_value = id_match.group(1)
+            new_line = f'[id="{id_value}_{{context}}"]'
+            new_lines.append(new_line)
+            id_replacements += 1
+            continue
+
+        # Check if clean-up is enabled and line matches cleanup patterns
+        if clean_up:
+            should_remove = False
+            for pattern in cleanup_patterns:
+                if pattern.search(line):
+                    should_remove = True
+                    cleanup_removals += 1
+                    break
+            if should_remove:
+                continue
+
+        new_lines.append(line)
+
+    return '\n'.join(new_lines), id_replacements, cleanup_removals
+
+
+def process_file(file_path: Path, dry_run: bool = False, clean_up: bool = False) -> tuple[int, int]:
+    """
+    Process a single AsciiDoc file.
+
+    Returns:
+        Tuple of (id_replacements, cleanup_removals)
+    """
+    try:
+        content = file_path.read_text(encoding='utf-8')
+    except Exception as e:
+        print(f"  Error reading {file_path}: {e}")
+        return 0, 0
+
+    new_content, id_replacements, cleanup_removals = convert_id_attributes(content, clean_up)
+
+    if id_replacements > 0 or cleanup_removals > 0:
+        if not dry_run:
+            try:
+                file_path.write_text(new_content, encoding='utf-8')
+            except Exception as e:
+                print(f"  Error writing {file_path}: {e}")
+                return 0, 0
+
+    return id_replacements, cleanup_removals
+
+
+def main():
+    # Check for updates (non-blocking)
+    check_version_on_startup()
+
+    parser = argparse.ArgumentParser(
+        description='Convert :id: attribute definitions to AsciiDoc [id="..._{context}"] anchors.'
+    )
+    parser.add_argument(
+        'directory',
+        nargs='?',
+        default='.',
+        help='Directory to scan for .adoc files (default: current directory)'
+    )
+    parser.add_argument(
+        '--dry-run', '-n',
+        action='store_true',
+        help='Show what would be changed without making actual modifications'
+    )
+    parser.add_argument(
+        '--clean-up',
+        action='store_true',
+        help='Also remove ID-related boilerplate lines (comments and include directives)'
+    )
+    parser.add_argument(
+        '--verbose', '-v',
+        action='store_true',
+        help='Show detailed output for each file processed'
+    )
+    parser.add_argument(
+        '--version',
+        action='version',
+        version=f'%(prog)s {__version__}'
+    )
+
+    args = parser.parse_args()
+
+    # Resolve directory path
+    directory = Path(args.directory).resolve()
+
+    if not directory.exists():
+        print(f"Error: Directory not found: {directory}")
+        sys.exit(1)
+
+    if not directory.is_dir():
+        print(f"Error: Not a directory: {directory}")
+        sys.exit(1)
+
+    mode_str = "DRY RUN MODE - " if args.dry_run else ""
+    print(f"{mode_str}Scanning directory: {directory}")
+
+    if args.clean_up:
+        print("Clean-up mode enabled: will remove ID-related boilerplate lines")
+
+    # Find all AsciiDoc files
+    spinner = Spinner("Searching for .adoc files")
+    spinner.start()
+    adoc_files = find_adoc_files(directory)
+    spinner.stop(f"Found {len(adoc_files)} .adoc files")
+
+    if not adoc_files:
+        print("No AsciiDoc files found.")
+        sys.exit(0)
+
+    if args.dry_run:
+        print("\n*** DRY RUN MODE - No files will be modified ***\n")
+
+    # Process each file
+    total_id_replacements = 0
+    total_cleanup_removals = 0
+    files_modified = 0
+
+    spinner = Spinner(f"Processing {len(adoc_files)} files")
+    spinner.start()
+
+    for file_path in adoc_files:
+        id_replacements, cleanup_removals = process_file(file_path, args.dry_run, args.clean_up)
+
+        if id_replacements > 0 or cleanup_removals > 0:
+            files_modified += 1
+            total_id_replacements += id_replacements
+            total_cleanup_removals += cleanup_removals
+
+            if args.verbose:
+                rel_path = file_path.relative_to(directory)
+                changes = []
+                if id_replacements > 0:
+                    changes.append(f"{id_replacements} ID conversion(s)")
+                if cleanup_removals > 0:
+                    changes.append(f"{cleanup_removals} line(s) removed")
+                print(f"  {rel_path}: {', '.join(changes)}")
+
+    spinner.stop(f"Processed {len(adoc_files)} files")
+
+    # Summary
+    print(f"\nSummary:")
+    if args.dry_run:
+        print(f"  Files that would be modified: {files_modified}")
+        print(f"  :id: attributes that would be converted: {total_id_replacements}")
+        if args.clean_up:
+            print(f"  Boilerplate lines that would be removed: {total_cleanup_removals}")
+        print("\nRun without --dry-run to apply changes.")
+    else:
+        print(f"  Files modified: {files_modified}")
+        print(f"  :id: attributes converted: {total_id_replacements}")
+        if args.clean_up:
+            print(f"  Boilerplate lines removed: {total_cleanup_removals}")
+
+        if total_id_replacements == 0:
+            print("\nNo :id: attributes found to convert.")
+        else:
+            print("\nConversion complete!")
+
+
+if __name__ == '__main__':
+    main()

{rolfedh_doc_utils-0.1.41 → rolfedh_doc_utils-0.1.42}/doc_utils/version.py

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

rolfedh_doc_utils-0.1.42/insert_procedure_title.py

@@ -0,0 +1,257 @@
+#!/usr/bin/env python3
+"""
+Insert .Procedure block title above numbered steps in AsciiDoc procedure files.
+
+This script finds AsciiDoc procedure files (those with :_mod-docs-content-type: PROCEDURE)
+and inserts a .Procedure block title before the first numbered step if one is missing.
+
+Usage:
+    insert-procedure-title <file_or_directory> [options]
+
+Examples:
+    insert-procedure-title modules/proc_example.adoc
+    insert-procedure-title modules/ --dry-run
+    insert-procedure-title . --verbose
+"""
+
+import argparse
+import os
+import re
+import sys
+from pathlib import Path
+
+
+def is_procedure_file(content: str) -> bool:
+    """Check if file is a PROCEDURE content type."""
+    return ':_mod-docs-content-type: PROCEDURE' in content
+
+
+def find_first_numbered_step(lines: list[str]) -> int | None:
+    """
+    Find the line index of the first numbered step.
+
+    Numbered steps can be:
+    - `. Step text` (AsciiDoc implicit ordered list)
+    - `1. Step text` (explicit numbered list)
+
+    Returns None if no numbered steps found.
+    """
+    # Pattern for ordered list items:
+    # - Starts with `. ` (implicit) or `<digit>. ` (explicit)
+    # - Must not be a block title (block titles are `.Title` without space after dot)
+    ordered_list_pattern = re.compile(r'^(\d+\.\s|\.(?!\w)\s)')
+
+    for i, line in enumerate(lines):
+        stripped = line.strip()
+        if ordered_list_pattern.match(stripped):
+            return i
+    return None
+
+
+def has_procedure_title_before(lines: list[str], step_index: int) -> bool:
+    """
+    Check if there's a .Procedure block title before the numbered steps.
+
+    Looks backward from the step index to find `.Procedure` on its own line.
+    Continues past other block titles (like sub-section titles) until hitting
+    a section heading (= or ==) or the start of the file.
+    """
+    for i in range(step_index - 1, -1, -1):
+        stripped = lines[i].strip()
+        if stripped == '.Procedure':
+            return True
+        # Stop searching if we hit a section heading
+        if stripped.startswith('= ') or stripped.startswith('== '):
+            return False
+    return False
+
+
+def find_insertion_point(lines: list[str], step_index: int) -> int:
+    """
+    Find the correct line index to insert .Procedure block title.
+
+    The insertion point should be before the numbered steps, but after:
+    - Prerequisites block
+    - Introductory paragraphs
+    - Blank lines
+
+    Returns the line index where .Procedure should be inserted.
+    """
+    # Look backward from the step to find a good insertion point
+    # We want to insert just before the numbered list starts
+    insertion_point = step_index
+
+    # Skip backward over any preceding blank lines to insert before them
+    while insertion_point > 0 and lines[insertion_point - 1].strip() == '':
+        insertion_point -= 1
+
+    return insertion_point
+
+
+def insert_procedure_title(content: str) -> tuple[str, bool]:
+    """
+    Insert .Procedure block title if missing.
+
+    Returns:
+        tuple: (modified_content, was_modified)
+    """
+    lines = content.split('\n')
+
+    # Find the first numbered step
+    step_index = find_first_numbered_step(lines)
+    if step_index is None:
+        return content, False
+
+    # Check if .Procedure already exists before the steps
+    if has_procedure_title_before(lines, step_index):
+        return content, False
+
+    # Find where to insert
+    insertion_point = find_insertion_point(lines, step_index)
+
+    # Insert .Procedure followed by blank line
+    # If there's already a blank line before steps, just insert .Procedure
+    if insertion_point < len(lines) and lines[insertion_point].strip() == '':
+        lines.insert(insertion_point, '.Procedure')
+        lines.insert(insertion_point + 1, '')
+    else:
+        lines.insert(insertion_point, '')
+        lines.insert(insertion_point, '.Procedure')
+
+    return '\n'.join(lines), True
+
+
+def has_numbered_steps(content: str) -> bool:
+    """Check if file has numbered steps."""
+    lines = content.split('\n')
+    return find_first_numbered_step(lines) is not None
+
+
+def has_procedure_title(content: str) -> bool:
+    """Check if file has a .Procedure block title."""
+    for line in content.split('\n'):
+        if line.strip() == '.Procedure':
+            return True
+    return False
+
+
+def process_file(filepath: Path, dry_run: bool = False, verbose: bool = False) -> tuple[bool, bool]:
+    """
+    Process a single AsciiDoc file.
+
+    Returns tuple: (was_modified, has_warning)
+    """
+    try:
+        content = filepath.read_text(encoding='utf-8')
+    except Exception as e:
+        print(f"Error reading {filepath}: {e}", file=sys.stderr)
+        return False, False
+
+    # Only process PROCEDURE files
+    if not is_procedure_file(content):
+        if verbose:
+            print(f"Skipping (not a procedure file): {filepath}")
+        return False, False
+
+    # If file already has .Procedure, no action needed
+    # (handles cases where procedures use unordered lists instead of numbered steps)
+    if has_procedure_title(content):
+        if verbose:
+            print(f"No changes needed (has .Procedure): {filepath}")
+        return False, False
+
+    # Check if file has numbered steps
+    if not has_numbered_steps(content):
+        print(f"Warning: Procedure file has no numbered steps and no .Procedure title: {filepath}")
+        return False, True
+
+    new_content, was_modified = insert_procedure_title(content)
+
+    if was_modified:
+        if dry_run:
+            print(f"Would modify: {filepath}")
+        else:
+            filepath.write_text(new_content, encoding='utf-8')
+            print(f"Modified: {filepath}")
+        return True, False
+    else:
+        if verbose:
+            print(f"No changes needed: {filepath}")
+        return False, False
+
+
+def collect_adoc_files(path: Path) -> list[Path]:
+    """Collect all .adoc files from path (file or directory)."""
+    if path.is_file():
+        if path.suffix == '.adoc':
+            return [path]
+        return []
+
+    files = []
+    for root, _, filenames in os.walk(path):
+        for filename in filenames:
+            if filename.endswith('.adoc'):
+                files.append(Path(root) / filename)
+    return sorted(files)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Insert .Procedure block title above numbered steps in AsciiDoc procedure files.',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog='''
+Examples:
+  %(prog)s modules/proc_example.adoc
+  %(prog)s modules/ --dry-run
+  %(prog)s . --verbose
+        '''
+    )
+    parser.add_argument(
+        'path',
+        type=Path,
+        help='File or directory to process'
+    )
+    parser.add_argument(
+        '-n', '--dry-run',
+        action='store_true',
+        help='Show what would be changed without modifying files'
+    )
+    parser.add_argument(
+        '-v', '--verbose',
+        action='store_true',
+        help='Show all files processed, including those not modified'
+    )
+
+    args = parser.parse_args()
+
+    if not args.path.exists():
+        print(f"Error: Path does not exist: {args.path}", file=sys.stderr)
+        sys.exit(1)
+
+    files = collect_adoc_files(args.path)
+
+    if not files:
+        print(f"No .adoc files found in: {args.path}")
+        sys.exit(0)
+
+    modified_count = 0
+    warning_count = 0
+    for filepath in files:
+        was_modified, has_warning = process_file(filepath, dry_run=args.dry_run, verbose=args.verbose)
+        if was_modified:
+            modified_count += 1
+        if has_warning:
+            warning_count += 1
+
+    print()
+    if args.dry_run:
+        print(f"Dry run complete. {modified_count} file(s) would be modified.")
+    else:
+        print(f"Complete. {modified_count} file(s) modified.")
+
+    if warning_count > 0:
+        print(f"Warnings: {warning_count} procedure file(s) have no numbered steps.")
+
+
+if __name__ == '__main__':
+    main()

{rolfedh_doc_utils-0.1.41 → rolfedh_doc_utils-0.1.42}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "rolfedh-doc-utils"
-version = "0.1.41"
+version = "0.1.42"
 description = "CLI tools for AsciiDoc documentation projects"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -34,10 +34,12 @@ inventory-conditionals = "inventory_conditionals:main"
 find-duplicate-content = "find_duplicate_content:main"
 find-duplicate-includes = "find_duplicate_includes:main"
 insert-abstract-role = "insert_abstract_role:main"
+insert-procedure-title = "insert_procedure_title:main"
+convert-id-attributes-to-ids = "convert_id_attributes_to_ids:main"
 
 [tool.setuptools.packages.find]
 where = ["."]
 include = ["doc_utils*", "callout_lib*"]
 
 [tool.setuptools]
-py-modules = ["doc_utils_cli", "find_unused_attributes", "check_scannability", "archive_unused_files", "archive_unused_images", "format_asciidoc_spacing", "replace_link_attributes", "extract_link_attributes", "validate_links", "convert_callouts_to_deflist", "convert_callouts_interactive", "check_source_directives", "convert_tables_to_deflists", "check_published_links", "convert_freemarker_to_asciidoc", "inventory_conditionals", "find_duplicate_content", "find_duplicate_includes", "insert_abstract_role"]
+py-modules = ["doc_utils_cli", "find_unused_attributes", "check_scannability", "archive_unused_files", "archive_unused_images", "format_asciidoc_spacing", "replace_link_attributes", "extract_link_attributes", "validate_links", "convert_callouts_to_deflist", "convert_callouts_interactive", "check_source_directives", "convert_tables_to_deflists", "check_published_links", "convert_freemarker_to_asciidoc", "inventory_conditionals", "find_duplicate_content", "find_duplicate_includes", "insert_abstract_role", "insert_procedure_title", "convert_id_attributes_to_ids"]

{rolfedh_doc_utils-0.1.41 → rolfedh_doc_utils-0.1.42}/rolfedh_doc_utils.egg-info/PKG-INFO

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

{rolfedh_doc_utils-0.1.41 → rolfedh_doc_utils-0.1.42}/rolfedh_doc_utils.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ check_source_directives.py
 convert_callouts_interactive.py
 convert_callouts_to_deflist.py
 convert_freemarker_to_asciidoc.py
+convert_id_attributes_to_ids.py
 convert_tables_to_deflists.py
 doc_utils_cli.py
 extract_link_attributes.py
@@ -16,6 +17,7 @@ find_duplicate_includes.py
 find_unused_attributes.py
 format_asciidoc_spacing.py
 insert_abstract_role.py
+insert_procedure_title.py
 inventory_conditionals.py
 pyproject.toml
 replace_link_attributes.py

{rolfedh_doc_utils-0.1.41 → rolfedh_doc_utils-0.1.42}/rolfedh_doc_utils.egg-info/entry_points.txt

@@ -7,6 +7,7 @@ check-source-directives = check_source_directives:main
 convert-callouts-interactive = convert_callouts_interactive:main
 convert-callouts-to-deflist = convert_callouts_to_deflist:main
 convert-freemarker-to-asciidoc = convert_freemarker_to_asciidoc:main
+convert-id-attributes-to-ids = convert_id_attributes_to_ids:main
 convert-tables-to-deflists = convert_tables_to_deflists:main
 doc-utils = doc_utils_cli:main
 extract-link-attributes = extract_link_attributes:main
@@ -15,6 +16,7 @@ find-duplicate-includes = find_duplicate_includes:main
 find-unused-attributes = find_unused_attributes:main
 format-asciidoc-spacing = format_asciidoc_spacing:main
 insert-abstract-role = insert_abstract_role:main
+insert-procedure-title = insert_procedure_title:main
 inventory-conditionals = inventory_conditionals:main
 replace-link-attributes = replace_link_attributes:main
 validate-links = validate_links:main

{rolfedh_doc_utils-0.1.41 → rolfedh_doc_utils-0.1.42}/rolfedh_doc_utils.egg-info/top_level.txt

@@ -7,6 +7,7 @@ check_source_directives
 convert_callouts_interactive
 convert_callouts_to_deflist
 convert_freemarker_to_asciidoc
+convert_id_attributes_to_ids
 convert_tables_to_deflists
 doc_utils
 doc_utils_cli
@@ -16,6 +17,7 @@ find_duplicate_includes
 find_unused_attributes
 format_asciidoc_spacing
 insert_abstract_role
+insert_procedure_title
 inventory_conditionals
 replace_link_attributes
 validate_links