rolfedh-doc-utils 0.1.15__tar.gz → 0.1.17__tar.gz

{rolfedh_doc_utils-0.1.15/rolfedh_doc_utils.egg-info → rolfedh_doc_utils-0.1.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rolfedh-doc-utils
-Version: 0.1.15
+Version: 0.1.17
 Summary: CLI tools for AsciiDoc documentation projects
 Author: Rolfe Dlugy-Hegwer
 License: MIT License
@@ -190,11 +190,27 @@ Before submitting PRs:
 
 ## 📊 Project Status
 
-- **Latest Version**: 0.1.6
+- **Latest Version**: 0.1.16 (with automatic update notifications)
 - **Python Support**: 3.8+
-- **Test Coverage**: 66+ tests (100% passing)
+- **Test Coverage**: 112+ tests (100% passing)
 - **Dependencies**: Minimal (PyYAML for OpenShift-docs support)
 
+### 🔔 Update Notifications
+
+All tools now check for updates automatically and notify you when a new version is available:
+
+```
+📦 Update available: 0.1.15 → 0.1.16
+   Run: pip install --upgrade rolfedh-doc-utils
+```
+
+To disable update checks, set the environment variable:
+```bash
+export DOC_UTILS_NO_VERSION_CHECK=1
+```
+
+Update checks are cached for 24 hours to minimize network requests.
+
 ## 🔗 Resources
 
 - [Documentation](https://rolfedh.github.io/doc-utils/)

{rolfedh_doc_utils-0.1.15 → rolfedh_doc_utils-0.1.17}/README.md

@@ -157,11 +157,27 @@ Before submitting PRs:
 
 ## 📊 Project Status
 
-- **Latest Version**: 0.1.6
+- **Latest Version**: 0.1.16 (with automatic update notifications)
 - **Python Support**: 3.8+
-- **Test Coverage**: 66+ tests (100% passing)
+- **Test Coverage**: 112+ tests (100% passing)
 - **Dependencies**: Minimal (PyYAML for OpenShift-docs support)
 
+### 🔔 Update Notifications
+
+All tools now check for updates automatically and notify you when a new version is available:
+
+```
+📦 Update available: 0.1.15 → 0.1.16
+   Run: pip install --upgrade rolfedh-doc-utils
+```
+
+To disable update checks, set the environment variable:
+```bash
+export DOC_UTILS_NO_VERSION_CHECK=1
+```
+
+Update checks are cached for 24 hours to minimize network requests.
+
 ## 🔗 Resources
 
 - [Documentation](https://rolfedh.github.io/doc-utils/)

{rolfedh_doc_utils-0.1.15 → rolfedh_doc_utils-0.1.17}/archive_unused_files.py

@@ -9,10 +9,13 @@ For full documentation and usage examples, see archive_unused_files.md in this d
 
 import argparse
 from doc_utils.unused_adoc import find_unused_adoc
+from doc_utils.version_check import check_version_on_startup
 from doc_utils.file_utils import parse_exclude_list_file
 
 from doc_utils.spinner import Spinner
 def main():
+    # Check for updates (non-blocking, won't interfere with tool operation)
+    check_version_on_startup()
     parser = argparse.ArgumentParser(
         description='Archive unused AsciiDoc files.',
         epilog='By default, automatically discovers all modules and assemblies directories in the repository.'

{rolfedh_doc_utils-0.1.15 → rolfedh_doc_utils-0.1.17}/archive_unused_images.py

@@ -8,10 +8,13 @@ For full documentation and usage examples, see archive_unused_files.md in this d
 
 import argparse
 from doc_utils.unused_images import find_unused_images
+from doc_utils.version_check import check_version_on_startup
 from doc_utils.file_utils import parse_exclude_list_file
 
 from doc_utils.spinner import Spinner
 def main():
+    # Check for updates (non-blocking, won't interfere with tool operation)
+    check_version_on_startup()
     parser = argparse.ArgumentParser(description='Archive unused image files.')
     parser.add_argument('--archive', action='store_true', help='Move the files to a dated zip in the archive directory.')
     parser.add_argument('--exclude-dir', action='append', default=[], help='Directory to exclude (can be used multiple times).')

{rolfedh_doc_utils-0.1.15 → rolfedh_doc_utils-0.1.17}/check_scannability.py

@@ -17,6 +17,7 @@ import sys
 import argparse
 from datetime import datetime
 from doc_utils.scannability import check_scannability
+from doc_utils.version_check import check_version_on_startup
 from doc_utils.file_utils import collect_files, parse_exclude_list_file
 
 from doc_utils.spinner import Spinner
@@ -27,6 +28,8 @@ def print_help():
     print(__doc__)
 
 def main():
+    # Check for updates (non-blocking, won't interfere with tool operation)
+    check_version_on_startup()
     # Manual check for -h or --help to display the full docstring
     if '-h' in sys.argv or '--help' in sys.argv:
         print_help()

{rolfedh_doc_utils-0.1.15 → rolfedh_doc_utils-0.1.17}/doc_utils/unused_attributes.py

@@ -50,13 +50,22 @@ def find_adoc_files(root_dir: str) -> List[str]:
 
 def scan_for_attribute_usage(adoc_files: List[str], attributes: Set[str]) -> Set[str]:
     used = set()
+    # Pattern for attribute references: {attribute-name}
     attr_pattern = re.compile(r'\{([\w-]+)\}')
+    # Patterns for conditional directives: ifdef::attr[], ifndef::attr[], endif::attr[]
+    conditional_pattern = re.compile(r'(?:ifdef|ifndef|endif)::([\w-]+)\[')
+
     for file in adoc_files:
         with open(file, 'r', encoding='utf-8') as f:
             for line in f:
+                # Check for {attribute} references
                 for match in attr_pattern.findall(line):
                     if match in attributes:
                         used.add(match)
+                # Check for ifdef::attribute[], ifndef::attribute[], endif::attribute[]
+                for match in conditional_pattern.findall(line):
+                    if match in attributes:
+                        used.add(match)
     return used
 
 def find_attributes_files(root_dir: str = '.') -> List[str]:
@@ -136,3 +145,44 @@ def find_unused_attributes(attr_file: str, adoc_root: str = '.') -> List[str]:
     used = scan_for_attribute_usage(adoc_files, attributes)
     unused = sorted(attributes - used)
     return unused
+
+
+def comment_out_unused_attributes(attr_file: str, unused_attrs: List[str]) -> int:
+    """
+    Comment out unused attributes in the attributes file.
+
+    Args:
+        attr_file: Path to the attributes file
+        unused_attrs: List of unused attribute names
+
+    Returns:
+        Number of attributes commented out
+    """
+    if not unused_attrs:
+        return 0
+
+    # Read the file
+    with open(attr_file, 'r', encoding='utf-8') as f:
+        lines = f.readlines()
+
+    # Create a set for faster lookup
+    unused_set = set(unused_attrs)
+    commented_count = 0
+
+    # Process each line
+    new_lines = []
+    for line in lines:
+        # Check if this line defines an attribute
+        match = re.match(r'^:([\w-]+):', line)
+        if match and match.group(1) in unused_set:
+            # Comment out this line
+            new_lines.append(f'// Unused {line}')
+            commented_count += 1
+        else:
+            new_lines.append(line)
+
+    # Write back to the file
+    with open(attr_file, 'w', encoding='utf-8') as f:
+        f.writelines(new_lines)
+
+    return commented_count

rolfedh_doc_utils-0.1.17/doc_utils/version_check.py

@@ -0,0 +1,204 @@
+#!/usr/bin/env python3
+"""
+Version checking utility for doc-utils.
+
+Checks PyPI for the latest version and notifies users if an update is available.
+Includes caching to avoid excessive PyPI requests.
+"""
+
+import json
+import os
+import sys
+import time
+import urllib.request
+import urllib.error
+from datetime import datetime, timedelta
+from importlib.metadata import version as get_installed_version
+from pathlib import Path
+from typing import Optional, Tuple
+
+
+def get_cache_dir() -> Path:
+    """Get the cache directory for version check data."""
+    # Use XDG_CACHE_HOME if set, otherwise ~/.cache
+    cache_home = os.environ.get('XDG_CACHE_HOME')
+    if cache_home:
+        cache_dir = Path(cache_home) / 'doc-utils'
+    else:
+        cache_dir = Path.home() / '.cache' / 'doc-utils'
+
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    return cache_dir
+
+
+def get_cache_file() -> Path:
+    """Get the cache file path."""
+    return get_cache_dir() / 'version_check.json'
+
+
+def read_cache() -> Optional[dict]:
+    """Read version check cache."""
+    cache_file = get_cache_file()
+    if not cache_file.exists():
+        return None
+
+    try:
+        with open(cache_file, 'r') as f:
+            data = json.load(f)
+            # Check if cache is still valid (24 hours)
+            last_check = datetime.fromisoformat(data['last_check'])
+            if datetime.now() - last_check < timedelta(hours=24):
+                return data
+    except (json.JSONDecodeError, KeyError, ValueError):
+        pass
+
+    return None
+
+
+def write_cache(latest_version: str, current_version: str):
+    """Write version check cache."""
+    cache_file = get_cache_file()
+    data = {
+        'last_check': datetime.now().isoformat(),
+        'latest_version': latest_version,
+        'current_version': current_version,
+    }
+
+    try:
+        with open(cache_file, 'w') as f:
+            json.dump(data, f)
+    except Exception:
+        # Silently fail if we can't write cache
+        pass
+
+
+def fetch_latest_version() -> Optional[str]:
+    """Fetch the latest version from PyPI."""
+    try:
+        # Use PyPI JSON API
+        url = 'https://pypi.org/pypi/rolfedh-doc-utils/json'
+        with urllib.request.urlopen(url, timeout=2) as response:
+            data = json.loads(response.read())
+            return data['info']['version']
+    except (urllib.error.URLError, json.JSONDecodeError, KeyError, TimeoutError):
+        # Silently fail if we can't reach PyPI
+        return None
+
+
+def parse_version(version_str: str) -> Tuple[int, ...]:
+    """Parse version string into tuple of integers for comparison."""
+    try:
+        # Remove any pre-release or dev suffixes
+        version_str = version_str.split('+')[0].split('-')[0]
+        return tuple(int(x) for x in version_str.split('.'))
+    except (ValueError, AttributeError):
+        return (0,)
+
+
+def check_for_update(force_check: bool = False) -> Optional[str]:
+    """
+    Check if a newer version is available.
+
+    Args:
+        force_check: If True, bypass cache and always check PyPI
+
+    Returns:
+        The latest version string if an update is available, None otherwise
+    """
+    try:
+        current_version = get_installed_version('rolfedh-doc-utils')
+    except Exception:
+        # Can't determine installed version
+        return None
+
+    # Check cache first (unless forced)
+    if not force_check:
+        cache_data = read_cache()
+        if cache_data:
+            latest_version = cache_data['latest_version']
+            # Only notify if there's a newer version
+            if parse_version(latest_version) > parse_version(current_version):
+                return latest_version
+            return None
+
+    # Fetch from PyPI
+    latest_version = fetch_latest_version()
+    if not latest_version:
+        return None
+
+    # Cache the result
+    write_cache(latest_version, current_version)
+
+    # Check if update is available
+    if parse_version(latest_version) > parse_version(current_version):
+        return latest_version
+
+    return None
+
+
+def show_update_notification(latest_version: str, current_version: str = None):
+    """Show update notification to user."""
+    if not current_version:
+        try:
+            current_version = get_installed_version('rolfedh-doc-utils')
+        except Exception:
+            current_version = 'unknown'
+
+    # Use stderr to avoid interfering with tool output
+    print(f"\n📦 Update available: {current_version} → {latest_version}", file=sys.stderr)
+    print(f"   Run: pip install --upgrade rolfedh-doc-utils", file=sys.stderr)
+    print("", file=sys.stderr)
+
+
+def check_version_on_startup():
+    """
+    Check for updates on tool startup.
+
+    This should be called early in the main() function of each CLI tool.
+    It runs asynchronously and won't block the tool execution.
+    """
+    # Skip version check in certain conditions
+    if any([
+        os.environ.get('DOC_UTILS_NO_VERSION_CHECK'),  # User opt-out
+        os.environ.get('CI'),  # Running in CI
+        not sys.stderr.isatty(),  # Not running in terminal
+    ]):
+        return
+
+    try:
+        latest_version = check_for_update()
+        if latest_version:
+            show_update_notification(latest_version)
+    except Exception:
+        # Never let version checking break the tool
+        pass
+
+
+def disable_version_check():
+    """
+    Instructions for disabling version check.
+
+    Users can disable by setting DOC_UTILS_NO_VERSION_CHECK environment variable.
+    """
+    print("To disable version checking, set the environment variable:")
+    print("  export DOC_UTILS_NO_VERSION_CHECK=1")
+    print("\nOr add it to your shell configuration file.")
+
+
+if __name__ == "__main__":
+    # For testing/debugging
+    import argparse
+    parser = argparse.ArgumentParser(description="Check for doc-utils updates")
+    parser.add_argument('--force', action='store_true', help='Force check (bypass cache)')
+    parser.add_argument('--disable-instructions', action='store_true',
+                       help='Show instructions for disabling version check')
+    args = parser.parse_args()
+
+    if args.disable_instructions:
+        disable_version_check()
+    else:
+        latest = check_for_update(force_check=args.force)
+        if latest:
+            show_update_notification(latest)
+        else:
+            print("You are running the latest version!")

{rolfedh_doc_utils-0.1.15 → rolfedh_doc_utils-0.1.17}/extract_link_attributes.py

@@ -10,9 +10,12 @@ attribute references.
 import argparse
 import sys
 from doc_utils.extract_link_attributes import extract_link_attributes
+from doc_utils.version_check import check_version_on_startup
 
 
 def main():
+    # Check for updates (non-blocking, won't interfere with tool operation)
+    check_version_on_startup()
     """Main entry point for the extract-link-attributes CLI tool."""
     parser = argparse.ArgumentParser(
         description='Extract link and xref macros containing attributes into attribute definitions',

{rolfedh_doc_utils-0.1.15 → rolfedh_doc_utils-0.1.17}/find_unused_attributes.py

@@ -12,10 +12,13 @@ import argparse
 import os
 import sys
 from datetime import datetime
-from doc_utils.unused_attributes import find_unused_attributes, find_attributes_files, select_attributes_file
+from doc_utils.unused_attributes import find_unused_attributes, find_attributes_files, select_attributes_file, comment_out_unused_attributes
 from doc_utils.spinner import Spinner
+from doc_utils.version_check import check_version_on_startup
 
 def main():
+    # Check for updates (non-blocking, won't interfere with tool operation)
+    check_version_on_startup()
     parser = argparse.ArgumentParser(description='Find unused AsciiDoc attributes.')
     parser.add_argument(
         'attributes_file',
@@ -23,6 +26,7 @@ def main():
         help='Path to the attributes file. If not specified, auto-discovers attributes files.'
     )
     parser.add_argument('-o', '--output', action='store_true', help='Write results to a timestamped txt file in your home directory.')
+    parser.add_argument('-c', '--comment-out', action='store_true', help='Comment out unused attributes in the attributes file with "// Unused".')
     args = parser.parse_args()
 
     # Determine which attributes file to use
@@ -81,6 +85,16 @@ def main():
             f.write(output + '\n')
         print(f'Results written to: {filename}')
 
+    if args.comment_out and output:
+        # Ask for confirmation before modifying the file
+        print(f'\nThis will comment out {len(unused)} unused attributes in: {attr_file}')
+        response = input('Continue? (y/n): ').strip().lower()
+        if response == 'y':
+            commented_count = comment_out_unused_attributes(attr_file, unused)
+            print(f'Commented out {commented_count} unused attributes in: {attr_file}')
+        else:
+            print('Operation cancelled.')
+
     return 0
 
 if __name__ == '__main__':

{rolfedh_doc_utils-0.1.15 → rolfedh_doc_utils-0.1.17}/format_asciidoc_spacing.py

@@ -10,6 +10,7 @@ import sys
 from pathlib import Path
 
 from doc_utils.format_asciidoc_spacing import process_file, find_adoc_files
+from doc_utils.version_check import check_version_on_startup
 
 
 from doc_utils.spinner import Spinner
@@ -27,6 +28,8 @@ def print_colored(message: str, color: str = Colors.NC) -> None:
 
 
 def main():
+    # Check for updates (non-blocking, won't interfere with tool operation)
+    check_version_on_startup()
     """Main entry point"""
     parser = argparse.ArgumentParser(
         description="Format AsciiDoc files to ensure proper spacing",

{rolfedh_doc_utils-0.1.15 → rolfedh_doc_utils-0.1.17}/pyproject.toml

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

{rolfedh_doc_utils-0.1.15 → rolfedh_doc_utils-0.1.17}/replace_link_attributes.py

@@ -19,6 +19,7 @@ from doc_utils.replace_link_attributes import (
     replace_link_attributes_in_file,
     find_adoc_files
 )
+from doc_utils.version_check import check_version_on_startup
 from doc_utils.spinner import Spinner
 
 
@@ -83,6 +84,8 @@ def prompt_for_attributes_file(attributes_files: list[Path]) -> Optional[Path]:
 
 
 def main():
+    # Check for updates (non-blocking, won't interfere with tool operation)
+    check_version_on_startup()
     parser = argparse.ArgumentParser(
         description='Replace AsciiDoc attributes within link macros with their actual values.'
     )

{rolfedh_doc_utils-0.1.15 → rolfedh_doc_utils-0.1.17/rolfedh_doc_utils.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rolfedh-doc-utils
-Version: 0.1.15
+Version: 0.1.17
 Summary: CLI tools for AsciiDoc documentation projects
 Author: Rolfe Dlugy-Hegwer
 License: MIT License
@@ -190,11 +190,27 @@ Before submitting PRs:
 
 ## 📊 Project Status
 
-- **Latest Version**: 0.1.6
+- **Latest Version**: 0.1.16 (with automatic update notifications)
 - **Python Support**: 3.8+
-- **Test Coverage**: 66+ tests (100% passing)
+- **Test Coverage**: 112+ tests (100% passing)
 - **Dependencies**: Minimal (PyYAML for OpenShift-docs support)
 
+### 🔔 Update Notifications
+
+All tools now check for updates automatically and notify you when a new version is available:
+
+```
+📦 Update available: 0.1.15 → 0.1.16
+   Run: pip install --upgrade rolfedh-doc-utils
+```
+
+To disable update checks, set the environment variable:
+```bash
+export DOC_UTILS_NO_VERSION_CHECK=1
+```
+
+Update checks are cached for 24 hours to minimize network requests.
+
 ## 🔗 Resources
 
 - [Documentation](https://rolfedh.github.io/doc-utils/)

{rolfedh_doc_utils-0.1.15 → rolfedh_doc_utils-0.1.17}/rolfedh_doc_utils.egg-info/SOURCES.txt

@@ -22,6 +22,7 @@ doc_utils/unused_adoc.py
 doc_utils/unused_attributes.py
 doc_utils/unused_images.py
 doc_utils/validate_links.py
+doc_utils/version_check.py
 rolfedh_doc_utils.egg-info/PKG-INFO
 rolfedh_doc_utils.egg-info/SOURCES.txt
 rolfedh_doc_utils.egg-info/dependency_links.txt

rolfedh_doc_utils-0.1.17/tests/test_unused_attributes.py

@@ -0,0 +1,199 @@
+import os
+import tempfile
+from doc_utils.unused_attributes import parse_attributes_file, find_adoc_files, scan_for_attribute_usage, find_unused_attributes, comment_out_unused_attributes
+
+def make_file(path, content):
+    with open(path, 'w', encoding='utf-8') as f:
+        f.write(content)
+
+def test_parse_attributes_file():
+    with tempfile.TemporaryDirectory() as tmpdir:
+        attr_path = os.path.join(tmpdir, 'attributes.adoc')
+        make_file(attr_path, ":foo: bar\n:bar: baz\n:unused: 123\n")
+        attrs = parse_attributes_file(attr_path)
+        assert 'foo' in attrs
+        assert 'bar' in attrs
+        assert 'unused' in attrs
+
+def test_find_adoc_files_and_usage():
+    with tempfile.TemporaryDirectory() as tmpdir:
+        attr_path = os.path.join(tmpdir, 'attributes.adoc')
+        make_file(attr_path, ":foo: bar\n:bar: baz\n:unused: 123\n")
+        adoc1 = os.path.join(tmpdir, 'a.adoc')
+        adoc2 = os.path.join(tmpdir, 'b.adoc')
+        make_file(adoc1, "This uses {foo} and {bar}.")
+        make_file(adoc2, "No attributes here.")
+        adoc_files = find_adoc_files(tmpdir)
+        attrs = parse_attributes_file(attr_path)
+        used = scan_for_attribute_usage(adoc_files, attrs)
+        assert 'foo' in used
+        assert 'bar' in used
+        assert 'unused' not in used
+
+def test_find_unused_attributes():
+    with tempfile.TemporaryDirectory() as tmpdir:
+        attr_path = os.path.join(tmpdir, 'attributes.adoc')
+        make_file(attr_path, ":foo: bar\n:bar: baz\n:unused: 123\n")
+        adoc1 = os.path.join(tmpdir, 'a.adoc')
+        adoc2 = os.path.join(tmpdir, 'b.adoc')
+        make_file(adoc1, "This uses {foo} and {bar}.")
+        make_file(adoc2, "No attributes here.")
+        unused = find_unused_attributes(attr_path, tmpdir)
+        assert 'unused' in unused
+        assert 'foo' not in unused
+        assert 'bar' not in unused
+
+def test_conditional_directives_ifdef():
+    """Test that ifdef::attribute:: is recognized as usage."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        attr_path = os.path.join(tmpdir, 'attributes.adoc')
+        make_file(attr_path, ":rh-only:\n:downstream:\n:unused:\n")
+        adoc1 = os.path.join(tmpdir, 'test.adoc')
+        make_file(adoc1, "ifdef::rh-only[]\nSome content\nendif::rh-only[]\n")
+        attrs = parse_attributes_file(attr_path)
+        adoc_files = find_adoc_files(tmpdir)
+        used = scan_for_attribute_usage(adoc_files, attrs)
+        assert 'rh-only' in used
+        assert 'downstream' not in used
+        assert 'unused' not in used
+
+def test_conditional_directives_ifndef():
+    """Test that ifndef::attribute:: is recognized as usage."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        attr_path = os.path.join(tmpdir, 'attributes.adoc')
+        make_file(attr_path, ":no-feature:\n:unused:\n")
+        adoc1 = os.path.join(tmpdir, 'test.adoc')
+        make_file(adoc1, "ifndef::no-feature[]\nContent when feature exists\nendif::no-feature[]\n")
+        attrs = parse_attributes_file(attr_path)
+        adoc_files = find_adoc_files(tmpdir)
+        used = scan_for_attribute_usage(adoc_files, attrs)
+        assert 'no-feature' in used
+        assert 'unused' not in used
+
+def test_conditional_directives_endif():
+    """Test that endif::attribute:: is recognized as usage."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        attr_path = os.path.join(tmpdir, 'attributes.adoc')
+        make_file(attr_path, ":my-attr:\n:unused:\n")
+        adoc1 = os.path.join(tmpdir, 'test.adoc')
+        make_file(adoc1, "ifdef::my-attr[]\nSome content\nendif::my-attr[]\n")
+        attrs = parse_attributes_file(attr_path)
+        adoc_files = find_adoc_files(tmpdir)
+        used = scan_for_attribute_usage(adoc_files, attrs)
+        assert 'my-attr' in used
+        assert 'unused' not in used
+
+def test_mixed_usage_patterns():
+    """Test attributes used in both {attr} and ifdef::attr:: forms."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        attr_path = os.path.join(tmpdir, 'attributes.adoc')
+        make_file(attr_path, ":version: 1.0\n:rh-only:\n:unused:\n")
+        adoc1 = os.path.join(tmpdir, 'test.adoc')
+        make_file(adoc1, "Version {version}\nifdef::rh-only[]\nRH content\nendif::rh-only[]\n")
+        unused = find_unused_attributes(attr_path, tmpdir)
+        assert 'unused' in unused
+        assert 'version' not in unused
+        assert 'rh-only' not in unused
+
+def test_no_prefix_attributes():
+    """Test attributes with 'no-' prefix used in ifndef directives."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        attr_path = os.path.join(tmpdir, 'attributes.adoc')
+        make_file(attr_path, ":no-quarkus-security-jpa-reactive:\n:no-webauthn-authentication:\n:unused:\n")
+        adoc1 = os.path.join(tmpdir, 'test.adoc')
+        make_file(adoc1, """
+ifndef::no-quarkus-security-jpa-reactive[]
+Content about JPA reactive security
+endif::no-quarkus-security-jpa-reactive[]
+
+ifndef::no-webauthn-authentication[]
+Content about WebAuthn
+endif::no-webauthn-authentication[]
+""")
+        unused = find_unused_attributes(attr_path, tmpdir)
+        assert 'unused' in unused
+        assert 'no-quarkus-security-jpa-reactive' not in unused
+        assert 'no-webauthn-authentication' not in unused
+
+def test_comment_out_unused_attributes():
+    """Test commenting out unused attributes in the attributes file."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        attr_path = os.path.join(tmpdir, 'attributes.adoc')
+        original_content = """:version: 1.0
+:product: MyApp
+:unused1: value1
+:unused2: value2
+:rh-only:
+"""
+        make_file(attr_path, original_content)
+
+        adoc1 = os.path.join(tmpdir, 'test.adoc')
+        make_file(adoc1, "Version {version} Product {product}\nifdef::rh-only[]\nContent\nendif::rh-only[]\n")
+
+        # Find unused attributes
+        unused = find_unused_attributes(attr_path, tmpdir)
+        assert 'unused1' in unused
+        assert 'unused2' in unused
+        assert 'version' not in unused
+        assert 'product' not in unused
+        assert 'rh-only' not in unused
+
+        # Comment out unused attributes
+        count = comment_out_unused_attributes(attr_path, unused)
+        assert count == 2
+
+        # Verify the file was modified correctly
+        with open(attr_path, 'r') as f:
+            content = f.read()
+
+        assert '// Unused :unused1: value1\n' in content
+        assert '// Unused :unused2: value2\n' in content
+        assert ':version: 1.0\n' in content
+        assert ':product: MyApp\n' in content
+        assert ':rh-only:\n' in content
+
+def test_comment_out_empty_list():
+    """Test that comment_out_unused_attributes handles empty list correctly."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        attr_path = os.path.join(tmpdir, 'attributes.adoc')
+        original_content = ":version: 1.0\n:product: MyApp\n"
+        make_file(attr_path, original_content)
+
+        # Comment out with empty list
+        count = comment_out_unused_attributes(attr_path, [])
+        assert count == 0
+
+        # Verify file was not modified
+        with open(attr_path, 'r') as f:
+            content = f.read()
+
+        assert content == original_content
+
+def test_comment_out_preserves_formatting():
+    """Test that commenting out preserves line formatting and comments."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        attr_path = os.path.join(tmpdir, 'attributes.adoc')
+        original_content = """// This is a comment
+:version: 1.0
+
+:unused: value with spaces
+// Another comment
+:product: MyApp
+"""
+        make_file(attr_path, original_content)
+
+        adoc1 = os.path.join(tmpdir, 'test.adoc')
+        make_file(adoc1, "Version {version} Product {product}\n")
+
+        unused = find_unused_attributes(attr_path, tmpdir)
+        count = comment_out_unused_attributes(attr_path, unused)
+        assert count == 1
+
+        with open(attr_path, 'r') as f:
+            content = f.read()
+
+        assert '// This is a comment\n' in content
+        assert '// Unused :unused: value with spaces\n' in content
+        assert '// Another comment\n' in content
+        assert ':version: 1.0\n' in content
+        assert ':product: MyApp\n' in content

{rolfedh_doc_utils-0.1.15 → rolfedh_doc_utils-0.1.17}/validate_links.py

@@ -12,10 +12,13 @@ import argparse
 import sys
 import json
 from doc_utils.validate_links import LinkValidator, parse_transpositions, format_results
+from doc_utils.version_check import check_version_on_startup
 from doc_utils.spinner import Spinner
 
 
 def main():
+    # Check for updates (non-blocking, won't interfere with tool operation)
+    check_version_on_startup()
     """Main entry point for the validate-links CLI tool."""
     parser = argparse.ArgumentParser(
         description='Validate links in AsciiDoc documentation',

rolfedh_doc_utils-0.1.15/tests/test_unused_attributes.py

@@ -1,44 +0,0 @@
-import os
-import tempfile
-from doc_utils.unused_attributes import parse_attributes_file, find_adoc_files, scan_for_attribute_usage, find_unused_attributes
-
-def make_file(path, content):
-    with open(path, 'w', encoding='utf-8') as f:
-        f.write(content)
-
-def test_parse_attributes_file():
-    with tempfile.TemporaryDirectory() as tmpdir:
-        attr_path = os.path.join(tmpdir, 'attributes.adoc')
-        make_file(attr_path, ":foo: bar\n:bar: baz\n:unused: 123\n")
-        attrs = parse_attributes_file(attr_path)
-        assert 'foo' in attrs
-        assert 'bar' in attrs
-        assert 'unused' in attrs
-
-def test_find_adoc_files_and_usage():
-    with tempfile.TemporaryDirectory() as tmpdir:
-        attr_path = os.path.join(tmpdir, 'attributes.adoc')
-        make_file(attr_path, ":foo: bar\n:bar: baz\n:unused: 123\n")
-        adoc1 = os.path.join(tmpdir, 'a.adoc')
-        adoc2 = os.path.join(tmpdir, 'b.adoc')
-        make_file(adoc1, "This uses {foo} and {bar}.")
-        make_file(adoc2, "No attributes here.")
-        adoc_files = find_adoc_files(tmpdir)
-        attrs = parse_attributes_file(attr_path)
-        used = scan_for_attribute_usage(adoc_files, attrs)
-        assert 'foo' in used
-        assert 'bar' in used
-        assert 'unused' not in used
-
-def test_find_unused_attributes():
-    with tempfile.TemporaryDirectory() as tmpdir:
-        attr_path = os.path.join(tmpdir, 'attributes.adoc')
-        make_file(attr_path, ":foo: bar\n:bar: baz\n:unused: 123\n")
-        adoc1 = os.path.join(tmpdir, 'a.adoc')
-        adoc2 = os.path.join(tmpdir, 'b.adoc')
-        make_file(adoc1, "This uses {foo} and {bar}.")
-        make_file(adoc2, "No attributes here.")
-        unused = find_unused_attributes(attr_path, tmpdir)
-        assert 'unused' in unused
-        assert 'foo' not in unused
-        assert 'bar' not in unused