render-engine 2025.10.1a2__tar.gz → 2025.11.1__tar.gz

{render_engine-2025.10.1a2 → render_engine-2025.11.1}/.gitignore

@@ -166,3 +166,5 @@ untitled-site/
 
 .DS_Store
 .python-version
+
+__version__.py

{render_engine-2025.10.1a2 → render_engine-2025.11.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: render_engine
-Version: 2025.10.1a2
+Version: 2025.11.1
 Summary: A Flexible Static Site Generator for Python
 Project-URL: homepage, https://github.com/render-engine/render-engine/
 Project-URL: repository, https://github.com/render-engine/render-engine/

{render_engine-2025.10.1a2 → render_engine-2025.11.1}/docs/docs/cli.md

@@ -7,6 +7,12 @@ tags: ["render-engine", "cli", "site-setup", "build", "serve"]
 
 Render Engine comes with a CLI that can be used to create, build, and serve your site.
 
+> !!! Note
+    The CLI is no longer a part of the Render Engine package and must be installed
+    separately. To install run `pip install render-engine-cli`. Render Engine can be
+    installed together with the CLI as well using
+    `pip install render-engine[cli]`.
+
 ## pyproject.toml Configuration
 
 The Render Engine CLI can be configured through your `pyproject.toml` file to set default values and avoid repetitive command-line arguments.

{render_engine-2025.10.1a2 → render_engine-2025.11.1}/docs/docs/collection.md

@@ -46,7 +46,8 @@ sort_reverse: bool = False
 title: str
 template: str | None
 archive_template str | None: The template to use for the archive pages.
-skip_site_map: bool = False: Flag to indicate whether this Collection should not be included in the SiteMap.
+ContentManager: type[ContentManager] | None = FileContentManager: The `ContentManager` to use.
+content_manager_extras: dict[str, Any]: Configuration options to send to the `ContentManager` during instantiation.
 ```
 
 ## Attributes

render_engine-2025.11.1/docs/docs/content_manager.md

@@ -0,0 +1,67 @@
+---
+title: "Enhancing Functionality with Content Managers"
+description: "Guide to using creating Content Managers to use alternate content storage systems."
+date: August 22, 2024
+tags: ["content_manager", "render-engine", "customization"]
+---
+
+Content Managers are a way to control how and where your content is stored.
+
+## Introduction
+
+Render Engine `Collection` uses a `ContentManager` to manage the storage of content for site generation. By default
+content is stored in the file system with each piece of content existing in a discrete file. With an alternate
+`ContentManager` the content can be stored in a database, JSON file, or other alternate data store.
+
+## Selecting a `ContentManager`
+
+The `ContentManager` for a given [`Collection`](collection.md) is controlled by the `ContentManager` attribute. When
+the class is instantiated the `ContentManager` is also instantiated with any `content_manager_extras` being passed
+as arguments. To access the `ContentManager` of a given `Collection` use the `content_manager` attribute.
+
+## Creating a `ContentManager`
+
+To create a `ContentManager` create a sub-class of `ContentManager` that implements the following methods:
+
+```python
+@property
+@abstractmethod
+def pages(self) -> Iterable:
+    """The Page objects managed by the content manager"""
+    ...
+
+@abstractmethod
+def create_entry(self, filepath: Path = None, editor: str = None, metadata: dict = None, content: str = None):
+    """Create a new entry"""
+    ...
+```
+
+### `pages`
+
+The `pages` property is how the `Collection` accesses its content. It is a method that _must_ be implemented by
+every `ContentManager`. An example `pages` implementation (from the
+[`FileContentManger`](https://github.com/render-engine/render-engine/blob/main/src/render_engine/content_managers/file_content_manager.py)) is:
+
+```python
+@property
+def pages(self) -> Iterable:
+    if self._pages is None:
+        self._pages = [self.collection.get_page(page) for page in self.iter_content_path()]
+    yield from self._pages
+```
+
+### `create_entry`
+
+The `create_entry` method is used by the Render Engine CLI tool to add new entries. It is responsible for adding
+the new entry to the datastore and, if an `editor` is specified, giving the user the ability to edit the new entry
+prior to committing the entry to the datastore.
+
+#### Arguments
+
+- `filepath: Path`: The path on the filesystem to store the new entry.
+- `editor: str`: The text editor to open for editing the new entry.
+- `content: str`: The initial content for the new entry.
+- `metadata: dict`: The metadata for the new entry.
+
+!!! Note
+    Not every `ContentManager` actually needs all the arguments that are passed.

{render_engine-2025.10.1a2 → render_engine-2025.11.1}/docs/docs/parsers.md

@@ -51,7 +51,7 @@ my_page._render_content()
 In many cases, you will want to create rich content. The `MarkdownPageParser`. You can also pass in attributes to the page via frontmatter at the top of the markdown file.
 
 ```python
-from render_engine.parsers.base_parsers import BasePageParser
+from render_engine_markdown import MarkdownPageParser
 from render_engine.page import Page
 
 base_markdown = """
@@ -63,8 +63,8 @@ This is **dynamic** content
 """
 
 class MyPage(Page):
-    parser = BasePageParser
-    content = base_text
+    parser = MarkdownPageParser
+    content = base_markdown
 
 my_page = MyPage()
 my_page.title
@@ -78,6 +78,10 @@ my_page._render_content()
 
 ```
 
+> !!! Note
+    `MarkdownPageParser` is found in the `render_engine_markdown` package.
+    To install run `pip install render_engine_markdown`.
+
 ## Creating Custom Parsers
 
 You can create custom parsers.

{render_engine-2025.10.1a2 → render_engine-2025.11.1}/docs/docs/templates.md

@@ -95,3 +95,10 @@ By default this will format to the site's `DATETIME_FORMAT` (default: `"%d %b %Y
 {{ page.date | format_datetime("%B %d, %Y") }} --> January 01, 2000
 
 ```
+
+## Site Map
+
+Render builds a site map prior to rendering the content. The contents of this
+site map are available to be used in both Page objects (see
+[Page object documentation](/page/#accessing-urls-for-other-pages-in-the-site-from-within-the-page-content).)
+Please see the [site map documentation](/site_map.html) for more information.

{render_engine-2025.10.1a2 → render_engine-2025.11.1}/docs/mkdocs.yml

@@ -18,20 +18,21 @@ nav:
     - contributing/CONTRIBUTING.md
   - Components:
     - Page Objects: page.md
-    - Collection:
+    - Collection Objects:
       - Collection: collection.md
       - Custom Collection: custom_collections.md
       - Archive: archive.md
       - RSS Feed: feeds.md
-    - Site:
-      - Site: site.md
+    - Site Objects: site.md
   - Extending Render Engine:
     - Plugins: plugins.md
+    - Content Managers: content_manager.md
   - Parsers: parsers.md
   - CLI: cli.md
   - Templates and Themes:
     - Templates: templates.md
     - ThemeManager: theme_management.md
+  - Site Map: site_map.md
 
 markdown_extensions:
   - toc

{render_engine-2025.10.1a2 → render_engine-2025.11.1}/pyproject.toml

@@ -42,9 +42,9 @@ dev = [
   "watchfiles",
 ]
 
-
 [tool.setuptools_scm]
 local_scheme = "no-local-version"
+version_file = "src/render_engine/__version__.py"
 # version_scheme = "python-simplified-semver"
 
 [project.urls]

render_engine-2025.11.1/src/render_engine/__version__.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '2025.11.1'
+__version_tuple__ = version_tuple = (2025, 11, 1)
+
+__commit_id__ = commit_id = 'g3ef9c0acb'

{render_engine-2025.10.1a2 → render_engine-2025.11.1}/src/render_engine/collection.py

@@ -6,10 +6,12 @@ from pathlib import Path
 from typing import Any
 
 import dateutil.parser as dateparse
-from more_itertools import batched, flatten
+from more_itertools import batched
 from render_engine_parser import BasePageParser
 from slugify import slugify
 
+from render_engine.content_managers import ContentManager, FileContentManager
+
 from ._base_object import BaseObject
 from .archive import Archive
 from .feeds import RSSFeed
@@ -56,6 +58,9 @@ class Collection(BaseObject):
         title: str
         template: str | None
         archive_template str | None: The template to use for the archive pages.
+        ContentManager: type[ContentManager] | None = FileContentManager
+        content_manager: ContentManager
+        content_manager_extras: dict[str, Any]: kwargs to pass to the ContentManager when instantiating
 
     Methods:
 
@@ -84,6 +89,8 @@ class Collection(BaseObject):
     template_vars: dict[str, Any]
     template: str | None
     plugin_manager: PluginManager | None
+    ContentManager: type[ContentManager] | None = FileContentManager
+    content_manager_extras: dict[str, Any]
 
     def __init__(
         self,
@@ -102,9 +109,16 @@ class Collection(BaseObject):
         self.title = self._title
         self.template_vars = getattr(self, "template_vars", {})
 
-    def iter_content_path(self):
-        """Iterate through in the collection's content path."""
-        return flatten([Path(self.content_path).glob(suffix) for suffix in self.include_suffixes])
+        cm_extras = {
+            "content_path": getattr(self, "content_path", None),
+            "include_suffixes": getattr(self, "include_suffixes", None),
+            "collection": self,
+        }
+        if hasattr(self, "content_manager_extras"):
+            cm_extras.update(self.content_manager_extras)
+        self.content_manager = self.ContentManager(**cm_extras)
+        if hasattr(self, "pages"):
+            self.content_manager.pages = self.pages
 
     def get_page(
         self,
@@ -116,8 +130,6 @@ class Collection(BaseObject):
             Parser=self.Parser,
         )
 
-        if getattr(self, "_pm", None):
-            _page.register_plugins(self.plugins, **self.plugin_settings)
         _page.parser_extras = getattr(self, "parser_extras", {})
         _page.routes = self.routes
         _page.template = getattr(self, "template", None)
@@ -162,7 +174,7 @@ class Collection(BaseObject):
         """
         try:
             return sorted(
-                (page for page in self.__iter__()),
+                (page for page in self),
                 key=self._sort_key(self.sort_by),
                 reverse=self.sort_reverse,
             )
@@ -231,10 +243,7 @@ class Collection(BaseObject):
         return f"{__name__}"
 
     def __iter__(self):
-        if not hasattr(self, "pages"):
-            self.pages = [self.get_page(page) for page in self.iter_content_path()]
-        for page in self.pages:  # noqa: UP028
-            yield page
+        yield from self.content_manager
 
     def _run_collection_plugins(self, site, hook_type: str):
         """
@@ -279,6 +288,24 @@ class Collection(BaseObject):
             feed.site = self.site
             feed.render(route="./", theme_manager=self.site.theme_manager)
 
+    def create_entry(
+        self, filepath: Path = None, editor: str = None, content: str = None, metadata: dict = None
+    ) -> str:
+        """
+        Create a new entry for the Collection
+
+        :param filepath: Path object for the new entry
+        :param editor: Editor to open to edit the entry.
+        :param content: Content for the new entry
+        :param metadata: Metadata for the new entry
+        """
+        context = copy.deepcopy(self._metadata_attrs())
+        if metadata:
+            context.update(metadata)
+        return self.content_manager.create_entry(
+            filepath=filepath, editor=editor, metadata=context, content=content or "Hello, world!"
+        )
+
 
 def render_archives(archive, **kwargs) -> list[Archive]:
     return [archive.render(pages=archive.pages, **kwargs) for archive in archive]

render_engine-2025.11.1/src/render_engine/content_managers/__init__.py

@@ -0,0 +1,7 @@
+from .base_content_manager import ContentManager
+from .file_content_manager import FileContentManager
+
+__all__ = [
+    ContentManager,
+    FileContentManager,
+]

render_engine-2025.11.1/src/render_engine/content_managers/base_content_manager.py

@@ -0,0 +1,22 @@
+from abc import ABC, abstractmethod
+from collections.abc import Generator, Iterable
+from pathlib import Path
+
+
+class ContentManager(ABC):
+    """Base ContentManager abstract class"""
+
+    @property
+    @abstractmethod
+    def pages(self) -> Iterable:
+        """The Page objects managed by the content manager"""
+        ...
+
+    def __iter__(self) -> Generator:
+        """Iterator for the ContentManager"""
+        yield from self.pages
+
+    @abstractmethod
+    def create_entry(self, filepath: Path = None, editor: str = None, metadata: dict = None, content: str = None):
+        """Create a new entry"""
+        ...

render_engine-2025.11.1/src/render_engine/content_managers/file_content_manager.py

@@ -0,0 +1,57 @@
+import subprocess
+from collections.abc import Iterable
+from pathlib import Path
+
+from more_itertools import flatten
+
+from render_engine.content_managers import ContentManager
+
+
+class FileContentManager(ContentManager):
+    """Content manager for content stored on the file system as individual files"""
+
+    def __init__(
+        self,
+        content_path: Path | str,
+        collection,
+        include_suffixes: Iterable[str] = ("*.md", "*.html"),
+        **kwargs,
+    ):
+        self.content_path = content_path
+        self.include_suffixes = include_suffixes
+        self.collection = collection
+        self._pages = None
+
+    def iter_content_path(self):
+        """Iterate through in the collection's content path."""
+        return flatten([Path(self.content_path).glob(suffix) for suffix in self.include_suffixes])
+
+    @property
+    def pages(self) -> Iterable:
+        if self._pages is None:
+            self._pages = [self.collection.get_page(page) for page in self.iter_content_path()]
+        yield from self._pages
+
+    @pages.setter
+    def pages(self, value: Iterable):
+        self._pages = value
+
+    def create_entry(
+        self, filepath: Path = None, editor: str = None, metadata: dict = None, content: str = None
+    ) -> str:
+        """
+        Create a new entry for the Collection
+
+        :param filepath: Path object for the new entry
+        :param editor: Editor to open to edit the entry.
+        :param content: The content for the entry
+        :param metadata: Metadata for the new entry
+        """
+        if not filepath:
+            raise ValueError("filepath needs to be specified.")
+
+        parsed_content = self.collection.Parser.create_entry(content=content, **metadata)
+        filepath.write_text(parsed_content)
+        if editor:
+            subprocess.run([editor, filepath])
+        return f"New entry created at {filepath} ."

{render_engine-2025.10.1a2 → render_engine-2025.11.1}/src/render_engine/site.py

@@ -3,6 +3,7 @@ import logging
 from collections import defaultdict
 from pathlib import Path
 
+import rich
 from jinja2 import FileSystemLoader, PrefixLoader
 from rich.progress import Progress
 
@@ -13,6 +14,12 @@ from .plugins import PluginManager, handle_plugin_registration
 from .site_map import SiteMap
 from .themes import Theme, ThemeManager
 
+try:
+    # Get the RE version for display. If it's not set it means we're working locally.
+    from render_engine.__version__ import __version__ as re_version
+except ImportError:
+    re_version = "development"
+
 
 class Site:
     """
@@ -251,7 +258,10 @@ class Site:
         You can choose to call it manually in your file or
         use the CLI command [`render-engine build`][src.render_engine.cli.build]
         """
-
+        rich.print(
+            f"[green]Building {repr(self.site_vars.get('SITE_TITLE', 'your site'))} "
+            f"with Render Engine version {re_version}"
+        )
         with Progress() as progress:
             task_site_map = progress.add_task("Generating site map", total=1)
             self._site_map = SiteMap(self.route_list, self.site_vars.get("SITE_URL", ""))

{render_engine-2025.10.1a2 → render_engine-2025.11.1}/src/render_engine/site_map.py

@@ -22,7 +22,7 @@ class SiteMapEntry:
                 self._route = f"/{route.lstrip('/')}/{self.path_name}" if from_collection else f"/{self.path_name}"
                 self.entries = list()
             case Collection():
-                self._route = f"/{route.lstrip('/')}"
+                self._route = f"/{entry.routes[0].lstrip('/')}"
                 self.entries = [
                     SiteMapEntry(collection_entry, self._route, from_collection=True) for collection_entry in entry
                 ]

{render_engine-2025.10.1a2 → render_engine-2025.11.1}/src/render_engine.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: render_engine
-Version: 2025.10.1a2
+Version: 2025.11.1
 Summary: A Flexible Static Site Generator for Python
 Project-URL: homepage, https://github.com/render-engine/render-engine/
 Project-URL: repository, https://github.com/render-engine/render-engine/

{render_engine-2025.10.1a2 → render_engine-2025.11.1}/src/render_engine.egg-info/SOURCES.txt

@@ -34,6 +34,7 @@ docs/requirements.txt
 docs/docs/archive.md
 docs/docs/cli.md
 docs/docs/collection.md
+docs/docs/content_manager.md
 docs/docs/custom_collections.md
 docs/docs/feeds.md
 docs/docs/index.md
@@ -63,6 +64,7 @@ docs/docs/getting-started/layout.md
 src/render_engine/.gitignore
 src/render_engine/__init__.py
 src/render_engine/__main__.py
+src/render_engine/__version__.py
 src/render_engine/_base_object.py
 src/render_engine/archive.py
 src/render_engine/blog.py
@@ -82,6 +84,9 @@ src/render_engine.egg-info/SOURCES.txt
 src/render_engine.egg-info/dependency_links.txt
 src/render_engine.egg-info/requires.txt
 src/render_engine.egg-info/top_level.txt
+src/render_engine/content_managers/__init__.py
+src/render_engine/content_managers/base_content_manager.py
+src/render_engine/content_managers/file_content_manager.py
 src/render_engine/extras/__init__.py
 src/render_engine/parsers/markdown.py
 src/render_engine/render_engine_templates/__init__.py

{render_engine-2025.10.1a2 → render_engine-2025.11.1}/tests/test_collections.py

@@ -1,4 +1,5 @@
 import pathlib
+import textwrap
 
 import pluggy
 import pytest
@@ -360,3 +361,58 @@ def test_collection_custom_sort_by_list_with_date():
 
     # Verify the sorted order by checking custom_sort_content values
     assert [page.custom_sort_content for page in sorted_pages] == [page.custom_sort_content for page in expected_pages]
+
+
+@pytest.mark.parametrize(
+    "content, context, expected",
+    [
+        (
+            "",
+            {"title": "title"},
+            textwrap.dedent("""---
+title: title
+---
+
+Hello, world!"""),
+        ),
+        (
+            "test",
+            {},
+            textwrap.dedent("""---
+title: Untitled Entry
+---
+
+test"""),
+        ),
+        (
+            "",
+            {},
+            textwrap.dedent("""---
+title: Untitled Entry
+---
+
+Hello, world!"""),
+        ),
+    ],
+)
+def test_create_entry(tmp_path: pathlib.Path, content, context, expected):
+    """Test the create_entry method"""
+    tmp_dir = tmp_path / "content"
+    tmp_dir.mkdir()
+
+    class BasicCollection(Collection):
+        content_path = tmp_dir.absolute()
+
+    filename = "test.md"
+    filepath = tmp_dir / filename
+    assert str(filepath) in BasicCollection().create_entry(
+        filepath=filepath, editor=None, content=content, metadata=context
+    )
+    assert filepath.read_text().strip() == expected
+
+
+def test_create_entry_no_filename():
+    """Test create_entry with no filename raises an exception"""
+    # Since the base Collection object uses a FileContentManager
+    with pytest.raises(ValueError):
+        Collection().create_entry()

{render_engine-2025.10.1a2 → render_engine-2025.11.1}/tests/test_site_map.py

@@ -60,7 +60,7 @@ def site(tmp_path_factory):
     for collection in ["coll1", "coll2"]:
 
         class MyColl(Collection):
-            routes = [collection]
+            routes = [f"{collection}-route"]
             pages = coll_pages[collection]
 
         collection_class = MyColl
@@ -82,19 +82,19 @@ def test_site_map_to_html(site):
     sm = SiteMap(site.route_list, "")
     assert sm.html == (
         "<ul>\n"
-        '\t<li><a href="/coll1">coll1</a></li>\n'
+        '\t<li><a href="/coll1-route">coll1</a></li>\n'
         "\t<ul>\n"
-        '\t\t<li><a href="/coll1/page0.html">coll1 -- Page 0</a></li>\n'
-        '\t\t<li><a href="/coll1/page1.html">coll1 -- Page 1</a></li>\n'
-        '\t\t<li><a href="/coll1/page2.html">coll1 -- Page 2</a></li>\n'
-        '\t\t<li><a href="/coll1/page3.html">coll1 -- Page 3</a></li>\n'
+        '\t\t<li><a href="/coll1-route/page0.html">coll1 -- Page 0</a></li>\n'
+        '\t\t<li><a href="/coll1-route/page1.html">coll1 -- Page 1</a></li>\n'
+        '\t\t<li><a href="/coll1-route/page2.html">coll1 -- Page 2</a></li>\n'
+        '\t\t<li><a href="/coll1-route/page3.html">coll1 -- Page 3</a></li>\n'
         "\t</ul>\n"
-        '\t<li><a href="/coll2">coll2</a></li>\n'
+        '\t<li><a href="/coll2-route">coll2</a></li>\n'
         "\t<ul>\n"
-        '\t\t<li><a href="/coll2/page0.html">coll2 -- Page 0</a></li>\n'
-        '\t\t<li><a href="/coll2/page1.html">coll2 -- Page 1</a></li>\n'
-        '\t\t<li><a href="/coll2/page2.html">coll2 -- Page 2</a></li>\n'
-        '\t\t<li><a href="/coll2/page3.html">coll2 -- Page 3</a></li>\n'
+        '\t\t<li><a href="/coll2-route/page0.html">coll2 -- Page 0</a></li>\n'
+        '\t\t<li><a href="/coll2-route/page1.html">coll2 -- Page 1</a></li>\n'
+        '\t\t<li><a href="/coll2-route/page2.html">coll2 -- Page 2</a></li>\n'
+        '\t\t<li><a href="/coll2-route/page3.html">coll2 -- Page 3</a></li>\n'
         "\t</ul>\n"
         '\t<li><a href="/page0.html">Page 0</a></li>\n'
         '\t<li><a href="/page1.html">Page 1</a></li>\n'
@@ -109,21 +109,21 @@ def test_site_map_to_html(site):
         ("page1", {}, "/page1.html"),
         ("page1", {"attr": "slug"}, "/page1.html"),
         ("page3", {"attr": "slug"}, None),
-        ("page3", {"attr": "slug", "full_search": True}, "/coll1/page3.html"),
-        ("page3", {"attr": "slug", "collection": "coll2"}, "/coll2/page3.html"),
+        ("page3", {"attr": "slug", "full_search": True}, "/coll1-route/page3.html"),
+        ("page3", {"attr": "slug", "collection": "coll2"}, "/coll2-route/page3.html"),
         ("page1.html", {"attr": "path_name"}, "/page1.html"),
         ("page3.html", {"attr": "path_name"}, None),
-        ("page3.html", {"attr": "path_name", "full_search": True}, "/coll1/page3.html"),
-        ("page3.html", {"attr": "path_name", "collection": "coll2"}, "/coll2/page3.html"),
+        ("page3.html", {"attr": "path_name", "full_search": True}, "/coll1-route/page3.html"),
+        ("page3.html", {"attr": "path_name", "collection": "coll2"}, "/coll2-route/page3.html"),
         ("page1", {"attr": "slug"}, "/page1.html"),
         ("page3", {"attr": "slug"}, None),
-        ("page3", {"attr": "slug", "full_search": True}, "/coll1/page3.html"),
-        ("page3", {"attr": "slug", "collection": "coll2"}, "/coll2/page3.html"),
+        ("page3", {"attr": "slug", "full_search": True}, "/coll1-route/page3.html"),
+        ("page3", {"attr": "slug", "collection": "coll2"}, "/coll2-route/page3.html"),
         ("Page 1", {"attr": "title"}, "/page1.html"),
         ("coll1 -- Page 3", {"attr": "title"}, None),
-        ("coll1 -- Page 3", {"attr": "title", "full_search": True}, "/coll1/page3.html"),
+        ("coll1 -- Page 3", {"attr": "title", "full_search": True}, "/coll1-route/page3.html"),
         ("coll1 -- Page 3", {"attr": "title", "collection": "coll2"}, None),
-        ("coll2 -- Page 3", {"attr": "title", "collection": "coll2"}, "/coll2/page3.html"),
+        ("coll2 -- Page 3", {"attr": "title", "collection": "coll2"}, "/coll2-route/page3.html"),
     ],
 )
 def test_site_map_search(site, value, params, expected):
@@ -137,7 +137,7 @@ def test_site_map_search(site, value, params, expected):
 
 def test_find_in_template(site):
     site.render()
-    assert (site.output_path / "page1.html").read_text() == "Page 1\n/coll1/page0.html"
+    assert (site.output_path / "page1.html").read_text() == "Page 1\n/coll1-route/page0.html"
 
 
 def test_site_map_to_xml(site):
@@ -148,34 +148,34 @@ def test_site_map_to_xml(site):
         == """<?xml version="1.0" encoding="UTF-8"?>
 <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
 <url>
-	<loc>http://localhost:8000/coll1</loc>
+	<loc>http://localhost:8000/coll1-route</loc>
 </url>
 <url>
-	<loc>http://localhost:8000/coll1/page0.html</loc>
+	<loc>http://localhost:8000/coll1-route/page0.html</loc>
 </url>
 <url>
-	<loc>http://localhost:8000/coll1/page1.html</loc>
+	<loc>http://localhost:8000/coll1-route/page1.html</loc>
 </url>
 <url>
-	<loc>http://localhost:8000/coll1/page2.html</loc>
+	<loc>http://localhost:8000/coll1-route/page2.html</loc>
 </url>
 <url>
-	<loc>http://localhost:8000/coll1/page3.html</loc>
+	<loc>http://localhost:8000/coll1-route/page3.html</loc>
 </url>
 <url>
-	<loc>http://localhost:8000/coll2</loc>
+	<loc>http://localhost:8000/coll2-route</loc>
 </url>
 <url>
-	<loc>http://localhost:8000/coll2/page0.html</loc>
+	<loc>http://localhost:8000/coll2-route/page0.html</loc>
 </url>
 <url>
-	<loc>http://localhost:8000/coll2/page1.html</loc>
+	<loc>http://localhost:8000/coll2-route/page1.html</loc>
 </url>
 <url>
-	<loc>http://localhost:8000/coll2/page2.html</loc>
+	<loc>http://localhost:8000/coll2-route/page2.html</loc>
 </url>
 <url>
-	<loc>http://localhost:8000/coll2/page3.html</loc>
+	<loc>http://localhost:8000/coll2-route/page3.html</loc>
 </url>
 <url>
 	<loc>http://localhost:8000/page0.html</loc>