rolfedh-doc-utils 0.1.0__tar.gz

rolfedh_doc_utils-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Rolfe Dlugy-Hegwer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

rolfedh_doc_utils-0.1.0/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.4
+Name: rolfedh-doc-utils
+Version: 0.1.0
+Summary: CLI tools for AsciiDoc documentation projects
+Author: Rolfe Dlugy-Hegwer
+License: MIT License
+        
+        Copyright (c) 2025 Rolfe Dlugy-Hegwer
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# doc-utils
+
+This repository contains modular Python utilities and CLI scripts to help technical writers with documentation tasks.
+
+**Purpose:**
+Each script is now a thin CLI wrapper that delegates to reusable modules in the `doc_utils` package. For details on how to use a script, see the initial docstring, comments, or the corresponding Markdown help file.
+
+## Current Scripts
+
+- **check_scannability.py**  
+  Checks the scannability of AsciiDoc (`.adoc`) files in the current directory. Reports sentences that are too long and paragraphs that contain too many sentences, based on configurable limits. See [check_scannability.md](check_scannability.md) for usage and examples.
+
+- **archive_unused_files.py**  
+  Scans `./modules` and `./assemblies` for AsciiDoc files not referenced by any other AsciiDoc file in the project. Optionally archives and deletes them. See [archive_unused_files.md](archive_unused_files.md) for usage and examples.
+
+- **archive_unused_images.py**  
+  Scans all directories for image files (e.g., `.png`, `.jpg`, `.jpeg`, `.gif`, `.svg`) not referenced by any AsciiDoc file in the project. Optionally archives and deletes them. See [archive_unused_images.md](archive_unused_images.md) for usage and examples.
+
+- **find_unused_attributes.py**  
+  Scans a user-specified attributes file (e.g., `attributes.adoc`) for attribute definitions (e.g., `:version:`) and recursively scans all `.adoc` files in the current directory for usages (e.g., `{version}`). Reports any attribute that is defined but not used in any `.adoc` file as **NOT USED** in both the command line output and a timestamped output file. See [find_unused_attributes.md](find_unused_attributes.md) for usage and examples.
+
+## Modular Python Package
+
+The core logic for all scripts is implemented in the `doc_utils/` package. You can import and reuse these utilities in your own scripts or tests:
+
+- `doc_utils.file_utils` — file collection, manifest, and archiving utilities
+- `doc_utils.unused_images` — logic for finding and archiving unused images
+- `doc_utils.unused_adoc` — logic for finding and archiving unused AsciiDoc files
+- `doc_utils.scannability` — logic for checking AsciiDoc scannability
+- `doc_utils.unused_attributes` — logic for finding unused AsciiDoc attributes
+
+## How to Use
+
+1. Open the script you are interested in (for example, `check_scannability.py` or `find_unused_attributes.py`).
+2. Read the top of the script or the corresponding `.md` file for instructions, options, and examples.
+3. Run the script from your terminal as described in the usage section.
+
+## Running Tests
+
+To run all tests, install the development requirements and run pytest from the project root:
+
+```sh
+pip install -r requirements-dev.txt
+pytest
+```
+
+All tests and fixtures are located in the `tests/` directory. See `tests/README.md` for details.
+
+---
+
+*For licensing information, see [LICENSE](LICENSE).*

rolfedh_doc_utils-0.1.0/README.md

@@ -0,0 +1,51 @@
+# doc-utils
+
+This repository contains modular Python utilities and CLI scripts to help technical writers with documentation tasks.
+
+**Purpose:**
+Each script is now a thin CLI wrapper that delegates to reusable modules in the `doc_utils` package. For details on how to use a script, see the initial docstring, comments, or the corresponding Markdown help file.
+
+## Current Scripts
+
+- **check_scannability.py**  
+  Checks the scannability of AsciiDoc (`.adoc`) files in the current directory. Reports sentences that are too long and paragraphs that contain too many sentences, based on configurable limits. See [check_scannability.md](check_scannability.md) for usage and examples.
+
+- **archive_unused_files.py**  
+  Scans `./modules` and `./assemblies` for AsciiDoc files not referenced by any other AsciiDoc file in the project. Optionally archives and deletes them. See [archive_unused_files.md](archive_unused_files.md) for usage and examples.
+
+- **archive_unused_images.py**  
+  Scans all directories for image files (e.g., `.png`, `.jpg`, `.jpeg`, `.gif`, `.svg`) not referenced by any AsciiDoc file in the project. Optionally archives and deletes them. See [archive_unused_images.md](archive_unused_images.md) for usage and examples.
+
+- **find_unused_attributes.py**  
+  Scans a user-specified attributes file (e.g., `attributes.adoc`) for attribute definitions (e.g., `:version:`) and recursively scans all `.adoc` files in the current directory for usages (e.g., `{version}`). Reports any attribute that is defined but not used in any `.adoc` file as **NOT USED** in both the command line output and a timestamped output file. See [find_unused_attributes.md](find_unused_attributes.md) for usage and examples.
+
+## Modular Python Package
+
+The core logic for all scripts is implemented in the `doc_utils/` package. You can import and reuse these utilities in your own scripts or tests:
+
+- `doc_utils.file_utils` — file collection, manifest, and archiving utilities
+- `doc_utils.unused_images` — logic for finding and archiving unused images
+- `doc_utils.unused_adoc` — logic for finding and archiving unused AsciiDoc files
+- `doc_utils.scannability` — logic for checking AsciiDoc scannability
+- `doc_utils.unused_attributes` — logic for finding unused AsciiDoc attributes
+
+## How to Use
+
+1. Open the script you are interested in (for example, `check_scannability.py` or `find_unused_attributes.py`).
+2. Read the top of the script or the corresponding `.md` file for instructions, options, and examples.
+3. Run the script from your terminal as described in the usage section.
+
+## Running Tests
+
+To run all tests, install the development requirements and run pytest from the project root:
+
+```sh
+pip install -r requirements-dev.txt
+pytest
+```
+
+All tests and fixtures are located in the `tests/` directory. See `tests/README.md` for details.
+
+---
+
+*For licensing information, see [LICENSE](LICENSE).*

rolfedh_doc_utils-0.1.0/doc_utils/__init__.py

@@ -0,0 +1,3 @@
+# doc_utils/__init__.py
+
+# This file marks doc_utils as a Python package.

rolfedh_doc_utils-0.1.0/doc_utils/file_utils.py

@@ -0,0 +1,60 @@
+# doc_utils/file_utils.py
+
+import os
+import re
+import zipfile
+from datetime import datetime
+
+
+def collect_files(scan_dirs, extensions, exclude_dirs=None, exclude_files=None):
+    """
+    Recursively collect files with given extensions from scan_dirs, excluding symlinks, exclude_dirs, and exclude_files.
+    Returns a list of normalized file paths.
+    """
+    exclude_dirs = set(os.path.abspath(os.path.normpath(d)) for d in (exclude_dirs or []))
+    exclude_files = set(os.path.abspath(os.path.normpath(f)) for f in (exclude_files or []))
+    found_files = []
+    for base_dir in scan_dirs:
+        for root, dirs, files in os.walk(base_dir):
+            abs_root = os.path.abspath(root)
+            # Exclude directories by absolute path
+            dirs[:] = [d for d in dirs if not os.path.islink(os.path.join(root, d)) and os.path.abspath(os.path.join(root, d)) not in exclude_dirs]
+            for f in files:
+                file_path = os.path.normpath(os.path.join(root, f))
+                abs_file_path = os.path.abspath(file_path)
+                if os.path.islink(file_path):
+                    continue
+                if abs_file_path in exclude_files:
+                    continue
+                if os.path.splitext(f)[1].lower() in extensions:
+                    found_files.append(file_path)
+    return list(dict.fromkeys(found_files))
+
+
+def write_manifest_and_archive(unused_files, archive_dir, manifest_prefix, archive_prefix, archive=False):
+    """
+    Write a manifest of unused files and optionally archive and delete them.
+    Returns the manifest path and (if archive=True) the archive path.
+    """
+    if not unused_files:
+        print("No unused files found. No manifest or ZIP archive created.")
+        return None, None
+    now = datetime.now()
+    datetime_str = now.strftime('%Y-%m-%d_%H%M%S')
+    output_file = f'{manifest_prefix}-{datetime_str}.txt'
+    os.makedirs(archive_dir, exist_ok=True)
+    manifest_path = os.path.join(archive_dir, output_file)
+    with open(manifest_path, 'w') as f:
+        for file in unused_files:
+            print(file)
+            f.write(file + '\n')
+    archive_path = None
+    if archive:
+        archive_path = os.path.join(archive_dir, f"{archive_prefix}-{datetime_str}.zip")
+        with zipfile.ZipFile(archive_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+            for file in unused_files:
+                arcname = os.path.relpath(file)
+                print(f"Archiving: {file} -> {archive_path} ({arcname})")
+                zipf.write(file, arcname)
+                os.remove(file)
+    return manifest_path, archive_path

rolfedh_doc_utils-0.1.0/doc_utils/scannability.py

@@ -0,0 +1,23 @@
+# doc_utils/scannability.py
+
+import os
+import re
+
+def check_scannability(adoc_files, max_sentence_length=22, max_paragraph_sentences=3):
+    long_sentences = []
+    long_paragraphs = []
+    for file_path in adoc_files:
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+                paragraphs = content.split('\n\n')
+                for i, para in enumerate(paragraphs):
+                    sentences = re.split(r'(?<=[.!?]) +', para.strip())
+                    for sent in sentences:
+                        if len(sent.split()) > max_sentence_length:
+                            long_sentences.append((file_path, i+1, sent.strip()))
+                    if len(sentences) > max_paragraph_sentences:
+                        long_paragraphs.append((file_path, i+1, len(sentences)))
+        except Exception as e:
+            print(f"Warning: could not read {file_path}: {e}")
+    return long_sentences, long_paragraphs

rolfedh_doc_utils-0.1.0/doc_utils/unused_adoc.py

@@ -0,0 +1,24 @@
+# doc_utils/unused_adoc.py
+
+import os
+import re
+from .file_utils import collect_files, write_manifest_and_archive
+
+def find_unused_adoc(scan_dirs, archive_dir, archive=False, exclude_dirs=None, exclude_files=None):
+    asciidoc_files = collect_files(scan_dirs, {'.adoc'}, exclude_dirs, exclude_files)
+    include_pattern = re.compile(r'include::(.+?)\[')
+    included_files = set()
+    adoc_files = collect_files(['.'], {'.adoc'}, exclude_dirs, exclude_files)
+    for file_path in adoc_files:
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+                includes = include_pattern.findall(content)
+                included_files.update(os.path.basename(include) for include in includes)
+        except Exception as e:
+            print(f"Warning: could not read {file_path}: {e}")
+    unused_files = [f for f in asciidoc_files if os.path.basename(f) not in included_files]
+    unused_files = list(dict.fromkeys(unused_files))
+    return write_manifest_and_archive(
+        unused_files, archive_dir, 'to-archive', 'to-archive', archive=archive
+    )

rolfedh_doc_utils-0.1.0/doc_utils/unused_attributes.py

@@ -0,0 +1,50 @@
+"""
+Module for finding unused AsciiDoc attributes.
+
+Functions:
+- parse_attributes_file: Parse attribute names from an attributes.adoc file.
+- find_adoc_files: Recursively find all .adoc files in a directory (ignoring symlinks).
+- scan_for_attribute_usage: Find which attributes are used in a set of .adoc files.
+- find_unused_attributes: Main function to return unused attributes.
+"""
+
+import os
+import re
+from typing import Set, List
+
+def parse_attributes_file(attr_file: str) -> Set[str]:
+    attributes = set()
+    with open(attr_file, 'r', encoding='utf-8') as f:
+        for line in f:
+            match = re.match(r'^:([\w-]+):', line.strip())
+            if match:
+                attributes.add(match.group(1))
+    return attributes
+
+def find_adoc_files(root_dir: str) -> List[str]:
+    adoc_files = []
+    for dirpath, dirnames, filenames in os.walk(root_dir, followlinks=False):
+        for fname in filenames:
+            if fname.endswith('.adoc'):
+                full_path = os.path.join(dirpath, fname)
+                if not os.path.islink(full_path):
+                    adoc_files.append(full_path)
+    return adoc_files
+
+def scan_for_attribute_usage(adoc_files: List[str], attributes: Set[str]) -> Set[str]:
+    used = set()
+    attr_pattern = re.compile(r'\{([\w-]+)\}')
+    for file in adoc_files:
+        with open(file, 'r', encoding='utf-8') as f:
+            for line in f:
+                for match in attr_pattern.findall(line):
+                    if match in attributes:
+                        used.add(match)
+    return used
+
+def find_unused_attributes(attr_file: str, adoc_root: str = '.') -> List[str]:
+    attributes = parse_attributes_file(attr_file)
+    adoc_files = find_adoc_files(adoc_root)
+    used = scan_for_attribute_usage(adoc_files, attributes)
+    unused = sorted(attributes - used)
+    return unused

rolfedh_doc_utils-0.1.0/doc_utils/unused_images.py

@@ -0,0 +1,28 @@
+# doc_utils/unused_images.py
+
+import os
+import re
+from .file_utils import collect_files, write_manifest_and_archive
+
+IMAGE_EXTENSIONS = {'.png', '.jpg', '.jpeg', '.gif', '.svg'}
+
+def find_unused_images(scan_dirs, archive_dir, archive=False, exclude_dirs=None, exclude_files=None):
+    image_files = collect_files(scan_dirs, IMAGE_EXTENSIONS, exclude_dirs, exclude_files)
+    adoc_files = collect_files(['.'], {'.adoc'}, exclude_dirs, exclude_files)
+    referenced_images = set()
+    image_ref_pattern = re.compile(r'(?i)image::([^\[]+)[\[]|image:([^\[]+)[\[]|"([^"\s]+\.(?:png|jpg|jpeg|gif|svg))"')
+    for adoc_file in adoc_files:
+        try:
+            with open(adoc_file, 'r', encoding='utf-8') as f:
+                content = f.read()
+                for match in image_ref_pattern.findall(content):
+                    for group in match:
+                        if group:
+                            referenced_images.add(os.path.basename(group))
+        except Exception as e:
+            print(f"Warning: could not read {adoc_file}: {e}")
+    unused_images = [f for f in image_files if os.path.basename(f) not in referenced_images]
+    unused_images = list(dict.fromkeys(unused_images))
+    return write_manifest_and_archive(
+        unused_images, archive_dir, 'unused-images', 'unused-images', archive=archive
+    )

rolfedh_doc_utils-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "rolfedh-doc-utils"
+version = "0.1.0"
+description = "CLI tools for AsciiDoc documentation projects"
+readme = "README.md"
+requires-python = ">=3.8"
+license = { file = "LICENSE" }
+authors = [
+  { name="Rolfe Dlugy-Hegwer" }
+]
+dependencies = []
+
+[project.scripts]
+check-scannability = "check_scannability:main"
+archive-unused-files = "archive_unused_files:main"
+archive-unused-images = "archive_unused_images:main"
+find-unused-attributes = "find_unused_attributes:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["doc_utils*"]

rolfedh_doc_utils-0.1.0/rolfedh_doc_utils.egg-info/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.4
+Name: rolfedh-doc-utils
+Version: 0.1.0
+Summary: CLI tools for AsciiDoc documentation projects
+Author: Rolfe Dlugy-Hegwer
+License: MIT License
+        
+        Copyright (c) 2025 Rolfe Dlugy-Hegwer
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# doc-utils
+
+This repository contains modular Python utilities and CLI scripts to help technical writers with documentation tasks.
+
+**Purpose:**
+Each script is now a thin CLI wrapper that delegates to reusable modules in the `doc_utils` package. For details on how to use a script, see the initial docstring, comments, or the corresponding Markdown help file.
+
+## Current Scripts
+
+- **check_scannability.py**  
+  Checks the scannability of AsciiDoc (`.adoc`) files in the current directory. Reports sentences that are too long and paragraphs that contain too many sentences, based on configurable limits. See [check_scannability.md](check_scannability.md) for usage and examples.
+
+- **archive_unused_files.py**  
+  Scans `./modules` and `./assemblies` for AsciiDoc files not referenced by any other AsciiDoc file in the project. Optionally archives and deletes them. See [archive_unused_files.md](archive_unused_files.md) for usage and examples.
+
+- **archive_unused_images.py**  
+  Scans all directories for image files (e.g., `.png`, `.jpg`, `.jpeg`, `.gif`, `.svg`) not referenced by any AsciiDoc file in the project. Optionally archives and deletes them. See [archive_unused_images.md](archive_unused_images.md) for usage and examples.
+
+- **find_unused_attributes.py**  
+  Scans a user-specified attributes file (e.g., `attributes.adoc`) for attribute definitions (e.g., `:version:`) and recursively scans all `.adoc` files in the current directory for usages (e.g., `{version}`). Reports any attribute that is defined but not used in any `.adoc` file as **NOT USED** in both the command line output and a timestamped output file. See [find_unused_attributes.md](find_unused_attributes.md) for usage and examples.
+
+## Modular Python Package
+
+The core logic for all scripts is implemented in the `doc_utils/` package. You can import and reuse these utilities in your own scripts or tests:
+
+- `doc_utils.file_utils` — file collection, manifest, and archiving utilities
+- `doc_utils.unused_images` — logic for finding and archiving unused images
+- `doc_utils.unused_adoc` — logic for finding and archiving unused AsciiDoc files
+- `doc_utils.scannability` — logic for checking AsciiDoc scannability
+- `doc_utils.unused_attributes` — logic for finding unused AsciiDoc attributes
+
+## How to Use
+
+1. Open the script you are interested in (for example, `check_scannability.py` or `find_unused_attributes.py`).
+2. Read the top of the script or the corresponding `.md` file for instructions, options, and examples.
+3. Run the script from your terminal as described in the usage section.
+
+## Running Tests
+
+To run all tests, install the development requirements and run pytest from the project root:
+
+```sh
+pip install -r requirements-dev.txt
+pytest
+```
+
+All tests and fixtures are located in the `tests/` directory. See `tests/README.md` for details.
+
+---
+
+*For licensing information, see [LICENSE](LICENSE).*

rolfedh_doc_utils-0.1.0/rolfedh_doc_utils.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+README.md
+pyproject.toml
+doc_utils/__init__.py
+doc_utils/file_utils.py
+doc_utils/scannability.py
+doc_utils/unused_adoc.py
+doc_utils/unused_attributes.py
+doc_utils/unused_images.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.egg-info/entry_points.txt
+rolfedh_doc_utils.egg-info/top_level.txt
+tests/test_archive_unused_files.py
+tests/test_archive_unused_images.py
+tests/test_check_scannability.py
+tests/test_unused_attributes.py

rolfedh_doc_utils-0.1.0/rolfedh_doc_utils.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

rolfedh_doc_utils-0.1.0/rolfedh_doc_utils.egg-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+archive-unused-files = archive_unused_files:main
+archive-unused-images = archive_unused_images:main
+check-scannability = check_scannability:main
+find-unused-attributes = find_unused_attributes:main

rolfedh_doc_utils-0.1.0/rolfedh_doc_utils.egg-info/top_level.txt

@@ -0,0 +1 @@
+doc_utils

rolfedh_doc_utils-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

rolfedh_doc_utils-0.1.0/tests/test_archive_unused_files.py

@@ -0,0 +1,46 @@
+import os
+import sys
+import tempfile
+import shutil
+import pytest
+from test_fixture_archive_unused_files import setup_test_fixture_archive_unused_files
+import subprocess
+
+SCRIPT = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'archive_unused_files.py'))
+
+def run_script(args, cwd):
+    result = subprocess.run([sys.executable, SCRIPT] + args, cwd=cwd, capture_output=True, text=True)
+    return result
+
+def test_archive_unused_files_basic():
+    with tempfile.TemporaryDirectory() as tmpdir:
+        setup_test_fixture_archive_unused_files(tmpdir)
+        result = run_script([], cwd=tmpdir)
+        assert 'unused1.adoc' in result.stdout
+        assert 'unused2.adoc' in result.stdout
+        assert 'used.adoc' not in result.stdout
+        # Manifest file should be created in archive
+        archive_dir = os.path.join(tmpdir, 'archive')
+        manifest_files = [f for f in os.listdir(archive_dir) if f.startswith('to-archive-') and f.endswith('.txt')]
+        assert manifest_files
+
+@pytest.mark.parametrize('exclude_args,should_find', [
+    (['--exclude-file', './modules/unused1.adoc'], 'unused2.adoc'),
+    (['--exclude-dir', './modules'], None),
+])
+def test_archive_unused_files_exclusions(exclude_args, should_find):
+    with tempfile.TemporaryDirectory() as tmpdir:
+        setup_test_fixture_archive_unused_files(tmpdir)
+        result = run_script(exclude_args, cwd=tmpdir)
+        archive_dir = os.path.join(tmpdir, 'archive')
+        manifest_files = [f for f in os.listdir(archive_dir) if f.startswith('to-archive-') and f.endswith('.txt')]
+        assert manifest_files
+        manifest_path = os.path.join(archive_dir, manifest_files[0])
+        with open(manifest_path, 'r', encoding='utf-8') as f:
+            manifest_content = f.read()
+        if should_find:
+            assert should_find in manifest_content
+        else:
+            # If all modules are excluded, no unused files from './modules' should be present
+            assert 'modules/unused1.adoc' not in manifest_content
+            assert 'modules/unused2.adoc' not in manifest_content

rolfedh_doc_utils-0.1.0/tests/test_archive_unused_images.py

@@ -0,0 +1,41 @@
+import os
+import sys
+import tempfile
+import shutil
+import pytest
+from test_fixture_archive_unused_images import setup_test_fixture
+import subprocess
+
+SCRIPT = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'archive_unused_images.py'))
+
+def run_script(args, cwd):
+    result = subprocess.run([sys.executable, SCRIPT] + args, cwd=cwd, capture_output=True, text=True)
+    return result
+
+def test_archive_unused_images_basic():
+    with tempfile.TemporaryDirectory() as tmpdir:
+        setup_test_fixture(tmpdir)
+        result = run_script([], cwd=tmpdir)
+        assert 'unused1.png' in result.stdout
+        assert 'unused2.jpg' in result.stdout
+        assert 'used1.png' not in result.stdout
+        assert 'used2.jpg' not in result.stdout
+        # Manifest file should be created in archive
+        archive_dir = os.path.join(tmpdir, 'archive')
+        manifest_files = [f for f in os.listdir(archive_dir) if f.startswith('unused-images-') and f.endswith('.txt')]
+        assert manifest_files
+
+@pytest.mark.parametrize('exclude_args,should_find', [
+    (['--exclude-file', './images/unused1.png'], 'unused2.jpg'),
+    (['--exclude-dir', './images'], None),
+])
+def test_archive_unused_images_exclusions(exclude_args, should_find):
+    with tempfile.TemporaryDirectory() as tmpdir:
+        setup_test_fixture(tmpdir)
+        result = run_script(exclude_args, cwd=tmpdir)
+        if should_find:
+            assert should_find in result.stdout
+        else:
+            # If all images are excluded, no unused images from './images' should be present
+            assert 'images/unused1.png' not in result.stdout
+            assert 'images/unused2.jpg' not in result.stdout

rolfedh_doc_utils-0.1.0/tests/test_check_scannability.py

@@ -0,0 +1,53 @@
+import sys
+import os
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+import tempfile
+import pytest
+from test_fixture_check_scannability import setup_test_fixture_check_scannability
+import subprocess
+
+SCRIPT = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'check_scannability.py'))
+
+def run_script(args, cwd):
+    result = subprocess.run([sys.executable, SCRIPT] + args, cwd=cwd, capture_output=True, text=True)
+    return result
+
+def test_check_scannability_basic():
+    with tempfile.TemporaryDirectory() as tmpdir:
+        setup_test_fixture_check_scannability(tmpdir)
+        result = run_script([], cwd=tmpdir)
+        # Should flag the long sentence and long paragraph in test1.adoc
+        assert 'Sentence exceeds' in result.stdout or 'Paragraph exceeds' in result.stdout
+        # Should not flag test2.adoc
+        assert 'test2.adoc' not in result.stderr
+
+@pytest.mark.parametrize('args,should_flag', [
+    (['--max-sentence-length', '10'], True),
+    (['--max-paragraph-sentences', '3'], True),
+])
+def test_check_scannability_custom_limits(args, should_flag):
+    with tempfile.TemporaryDirectory() as tmpdir:
+        setup_test_fixture_check_scannability(tmpdir)
+        result = run_script(args, cwd=tmpdir)
+        if should_flag:
+            assert 'Sentence exceeds' in result.stdout or 'Paragraph exceeds' in result.stdout
+
+def test_check_scannability_short_options():
+    with tempfile.TemporaryDirectory() as tmpdir:
+        setup_test_fixture_check_scannability(tmpdir)
+        # Use short options -s and -p
+        result = run_script(['-s', '10', '-p', '2'], cwd=tmpdir)
+        assert 'Sentence exceeds' in result.stdout or 'Paragraph exceeds' in result.stdout
+
+def test_check_scannability_defaults():
+    with tempfile.TemporaryDirectory() as tmpdir:
+        setup_test_fixture_check_scannability(tmpdir)
+        # No options: should use 22 and 3 as limits
+        result = run_script([], cwd=tmpdir)
+        # Should flag the long sentence and long paragraph in test1.adoc
+        assert 'Sentence exceeds' in result.stdout or 'Paragraph exceeds' in result.stdout
+
+def test_check_scannability_help():
+    result = run_script(['-h'], cwd=os.getcwd())
+    assert 'Scannability Checker' in result.stdout or 'usage' in result.stdout

rolfedh_doc_utils-0.1.0/tests/test_unused_attributes.py

@@ -0,0 +1,44 @@
+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