clear-skies-doc-builder 2.0.8__tar.gz → 2.0.10__tar.gz

{clear_skies_doc_builder-2.0.8 → clear_skies_doc_builder-2.0.10}/CHANGELOG.md

@@ -5,11 +5,22 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.0.9] - 2026-01-28
+
+### Added
+- Add ordering
+
+### Changed
+- Bump version to v2.0.9 by @github-actions[bot]
+
 ## [2.0.8] - 2026-01-28
 
 ### Added
 - Add support for just headings
 
+### Changed
+- Bump version to v2.0.8 by @github-actions[bot]
+
 ## [2.0.7] - 2026-01-28
 
 ### Added
@@ -83,6 +94,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 * @ made their first contribution
 * @tnijboer made their first contribution in [#1](https://github.com/clearskies-py/doc-builder/pull/1)
 * @cmancone made their first contribution
+[2.0.9]: https://github.com/clearskies-py/doc-builder/compare/v2.0.8..v2.0.9
 [2.0.8]: https://github.com/clearskies-py/doc-builder/compare/v2.0.7..v2.0.8
 [2.0.7]: https://github.com/clearskies-py/doc-builder/compare/v2.0.6..v2.0.7
 [2.0.6]: https://github.com/clearskies-py/doc-builder/compare/v2.0.5..v2.0.6

clear_skies_doc_builder-2.0.10/LATEST_CHANGELOG.md

@@ -0,0 +1,2 @@
+## [2.0.10] - 2026-01-28
+

{clear_skies_doc_builder-2.0.8 → clear_skies_doc_builder-2.0.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clear-skies-doc-builder
-Version: 2.0.8
+Version: 2.0.10
 Summary: The docbuilder for all 'official' clearskies plugins (as well as the main clearskies docs)
 Project-URL: repository, https://github.com/clearskies-py/docs
 Project-URL: issues, https://github.com/clearskies-py/docs/issues
@@ -195,3 +195,75 @@ You can also use `SingleClass` builder for documenting individual classes within
   ]
 }
 ```
+
+### Automatic Navigation Ordering
+
+Child entries under a parent are automatically sorted so that submodules appear first (alphabetically), followed by individual classes (alphabetically). The entry type is **automatically inferred** from the builder:
+
+- **`Module` builder** → treated as "submodule" (appears first)
+- **`SingleClass` / `SingleClassToSection` builder** → treated as "class" (appears after submodules)
+- **Other builders** → appear last
+
+#### Example
+
+```json
+{
+  "tree": [
+    {
+      "title": "Cursors",
+      "source": "clearskies.cursors.Cursor",
+      "builder": "clearskies_doc_builder.builders.Module"
+    },
+    {
+      "title": "Memory Cursor",
+      "source": "clearskies.cursors.MemoryCursor",
+      "builder": "clearskies_doc_builder.builders.SingleClass",
+      "parent": "Cursors"
+    },
+    {
+      "title": "File Cursor",
+      "source": "clearskies.cursors.FileCursor",
+      "builder": "clearskies_doc_builder.builders.SingleClass",
+      "parent": "Cursors"
+    },
+    {
+      "title": "From Environment",
+      "source": "clearskies.cursors.from_environment.FromEnvironmentBase",
+      "builder": "clearskies_doc_builder.builders.Module",
+      "parent": "Cursors",
+      "classes": ["clearskies.cursors.from_environment.EnvCursor"]
+    },
+    {
+      "title": "AWS",
+      "source": "clearskies.cursors.aws.AWSBase",
+      "builder": "clearskies_doc_builder.builders.Module",
+      "parent": "Cursors",
+      "classes": ["clearskies.cursors.aws.SecretsManager"]
+    }
+  ]
+}
+```
+
+This will generate navigation in the following order under "Cursors":
+1. **AWS** (Module builder = submodule, alphabetically first)
+2. **From Environment** (Module builder = submodule, alphabetically second)
+3. **File Cursor** (SingleClass builder = class, alphabetically first)
+4. **Memory Cursor** (SingleClass builder = class, alphabetically second)
+
+This ensures a consistent navigation structure where submodules (which typically contain multiple classes) are grouped together at the top, followed by individual class documentation.
+
+#### Manual Override with `entry_type`
+
+If needed, you can explicitly set `entry_type` to override the automatic inference:
+
+```json
+{
+  "title": "Special Entry",
+  "source": "...",
+  "builder": "clearskies_doc_builder.builders.SingleClass",
+  "parent": "Cursors",
+  "entry_type": "submodule"
+}
+```
+
+Supported values: `"submodule"`, `"class"`, or omit for default behavior.

{clear_skies_doc_builder-2.0.8 → clear_skies_doc_builder-2.0.10}/README.md

@@ -175,3 +175,75 @@ You can also use `SingleClass` builder for documenting individual classes within
   ]
 }
 ```
+
+### Automatic Navigation Ordering
+
+Child entries under a parent are automatically sorted so that submodules appear first (alphabetically), followed by individual classes (alphabetically). The entry type is **automatically inferred** from the builder:
+
+- **`Module` builder** → treated as "submodule" (appears first)
+- **`SingleClass` / `SingleClassToSection` builder** → treated as "class" (appears after submodules)
+- **Other builders** → appear last
+
+#### Example
+
+```json
+{
+  "tree": [
+    {
+      "title": "Cursors",
+      "source": "clearskies.cursors.Cursor",
+      "builder": "clearskies_doc_builder.builders.Module"
+    },
+    {
+      "title": "Memory Cursor",
+      "source": "clearskies.cursors.MemoryCursor",
+      "builder": "clearskies_doc_builder.builders.SingleClass",
+      "parent": "Cursors"
+    },
+    {
+      "title": "File Cursor",
+      "source": "clearskies.cursors.FileCursor",
+      "builder": "clearskies_doc_builder.builders.SingleClass",
+      "parent": "Cursors"
+    },
+    {
+      "title": "From Environment",
+      "source": "clearskies.cursors.from_environment.FromEnvironmentBase",
+      "builder": "clearskies_doc_builder.builders.Module",
+      "parent": "Cursors",
+      "classes": ["clearskies.cursors.from_environment.EnvCursor"]
+    },
+    {
+      "title": "AWS",
+      "source": "clearskies.cursors.aws.AWSBase",
+      "builder": "clearskies_doc_builder.builders.Module",
+      "parent": "Cursors",
+      "classes": ["clearskies.cursors.aws.SecretsManager"]
+    }
+  ]
+}
+```
+
+This will generate navigation in the following order under "Cursors":
+1. **AWS** (Module builder = submodule, alphabetically first)
+2. **From Environment** (Module builder = submodule, alphabetically second)
+3. **File Cursor** (SingleClass builder = class, alphabetically first)
+4. **Memory Cursor** (SingleClass builder = class, alphabetically second)
+
+This ensures a consistent navigation structure where submodules (which typically contain multiple classes) are grouped together at the top, followed by individual class documentation.
+
+#### Manual Override with `entry_type`
+
+If needed, you can explicitly set `entry_type` to override the automatic inference:
+
+```json
+{
+  "title": "Special Entry",
+  "source": "...",
+  "builder": "clearskies_doc_builder.builders.SingleClass",
+  "parent": "Cursors",
+  "entry_type": "submodule"
+}
+```
+
+Supported values: `"submodule"`, `"class"`, or omit for default behavior.

{clear_skies_doc_builder-2.0.8 → clear_skies_doc_builder-2.0.10}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "clear-skies-doc-builder"
 description = "The docbuilder for all 'official' clearskies plugins (as well as the main clearskies docs)"
-version = "2.0.8"
+version = "2.0.10"
 license = "MIT"
 readme = "./README.md"
 authors = [{name = "Conor Mancone", email = "cmancone@gmail.com"}]

clear_skies_doc_builder-2.0.10/src/clearskies_doc_builder/build_callable.py

@@ -0,0 +1,107 @@
+from typing import Any
+
+from clearskies_doc_builder import models
+from clearskies_doc_builder.prepare_doc_space import prepare_doc_space
+
+
+def _infer_entry_type(entry: dict[str, Any]) -> str:
+    """
+    Infer the entry type from the builder class name.
+
+    - Module builder -> "submodule" (contains multiple classes, acts as a section)
+    - SingleClass builder -> "class" (documents a single class)
+    - SingleClassToSection builder -> "class"
+    - Other/unknown -> "" (will be sorted last)
+
+    This can be overridden by explicitly setting "entry_type" in the config.
+    """
+    # Allow explicit override
+    if "entry_type" in entry:
+        return entry["entry_type"]
+
+    builder = entry.get("builder", "")
+    if builder.endswith(".Module"):
+        return "submodule"
+    elif builder.endswith(".SingleClass") or builder.endswith(".SingleClassToSection"):
+        return "class"
+    return ""
+
+
+def _sort_key_for_entry(entry: dict[str, Any]) -> tuple[int, str]:
+    """
+    Generate a sort key for navigation ordering.
+
+    Entries are sorted by:
+    1. entry_type priority: "submodule" (0) comes before "class" (1) and others (2)
+    2. title alphabetically (case-insensitive)
+
+    This ensures submodules appear first in navigation, followed by classes,
+    all sorted alphabetically within their group.
+
+    Entry type is automatically inferred from the builder:
+    - Module builder -> "submodule"
+    - SingleClass/SingleClassToSection builder -> "class"
+    """
+    entry_type = _infer_entry_type(entry)
+    type_priority = {"submodule": 0, "class": 1}.get(entry_type, 2)
+    title = entry.get("title", "").lower()
+    return (type_priority, title)
+
+
+def _compute_nav_orders(tree: list[dict[str, Any]]) -> dict[int, int]:
+    """
+    Compute nav_order for each entry in the tree based on sorting rules.
+
+    Returns a dict mapping original tree index to computed nav_order.
+
+    For entries with the same parent:
+    - Groups by entry_type (submodules first, then classes)
+    - Sorts alphabetically within each group
+    - Assigns sequential nav_order values
+
+    Top-level entries maintain their original order (index + 2).
+    """
+    # Group entries by their parent
+    parent_groups: dict[str | None, list[tuple[int, dict[str, Any]]]] = {}
+
+    for index, entry in enumerate(tree):
+        parent = entry.get("parent")
+        if parent not in parent_groups:
+            parent_groups[parent] = []
+        parent_groups[parent].append((index, entry))
+
+    # Compute nav_order for each entry
+    nav_orders: dict[int, int] = {}
+
+    for parent, entries in parent_groups.items():
+        if parent is None:
+            # Top-level entries: use original index-based ordering
+            for original_index, entry in entries:
+                nav_orders[original_index] = original_index + 2
+        else:
+            # Child entries: sort by type then alphabetically
+            sorted_entries = sorted(entries, key=lambda x: _sort_key_for_entry(x[1]))
+            for nav_order, (original_index, entry) in enumerate(sorted_entries, start=1):
+                nav_orders[original_index] = nav_order
+
+    return nav_orders
+
+
+def build_callable(modules: models.Module, classes: models.Class, config: dict[str, Any], project_root: str):
+    doc_root = prepare_doc_space(project_root)
+
+    # Pre-compute nav_orders based on sorting rules
+    nav_orders = _compute_nav_orders(config["tree"])
+
+    for index, branch in enumerate(config["tree"]):
+        nav_order = nav_orders[index]
+
+        builder_class = classes.find("import_path=" + branch["builder"]).type
+        builder = builder_class(
+            branch,
+            modules,
+            classes,
+            doc_root,
+            nav_order=nav_order,
+        )
+        builder.build()

{clear_skies_doc_builder-2.0.8 → clear_skies_doc_builder-2.0.10}/uv.lock

@@ -146,7 +146,7 @@ wheels = [
 
 [[package]]
 name = "clear-skies-doc-builder"
-version = "2.0.8"
+version = "2.0.10"
 source = { editable = "." }
 dependencies = [
     { name = "clear-skies" },

clear_skies_doc_builder-2.0.8/LATEST_CHANGELOG.md

@@ -1,5 +0,0 @@
-## [2.0.8] - 2026-01-28
-
-### Added
-- Add support for just headings
-

clear_skies_doc_builder-2.0.8/src/clearskies_doc_builder/build_callable.py

@@ -1,39 +0,0 @@
-from typing import Any
-
-from clearskies_doc_builder import models
-from clearskies_doc_builder.prepare_doc_space import prepare_doc_space
-
-
-def build_callable(modules: models.Module, classes: models.Class, config: dict[str, Any], project_root: str):
-    doc_root = prepare_doc_space(project_root)
-    nav_order_parent_count: dict[str, int] = {}
-
-    for index, branch in enumerate(config["tree"]):
-        # For nav_order tracking, we need to track by the immediate parent
-        # If there's a grand_parent, the parent is the immediate container
-        # If there's only a parent, that's the immediate container
-        # If neither, it's a top-level item (doesn't need tracking)
-        parent = branch.get("parent")
-        grand_parent = branch.get("grand_parent")
-
-        # Determine nav_order based on hierarchy level
-        if parent or grand_parent:
-            # Child items: track by their immediate parent
-            nav_order_title_tracker = parent
-            if nav_order_title_tracker not in nav_order_parent_count:
-                nav_order_parent_count[nav_order_title_tracker] = 0
-            nav_order_parent_count[nav_order_title_tracker] += 1
-            nav_order = nav_order_parent_count[nav_order_title_tracker]
-        else:
-            # Top-level items: use index-based nav_order
-            nav_order = index + 2
-
-        builder_class = classes.find("import_path=" + branch["builder"]).type
-        builder = builder_class(
-            branch,
-            modules,
-            classes,
-            doc_root,
-            nav_order=nav_order,
-        )
-        builder.build()