pax_global_header 0000666 0000000 0000000 00000000064 15040033232 0014502 g ustar 00root root 0000000 0000000 52 comment=38e9154be3c5e187f694d821a466b967485b3bdc
django-navtag-3.3.1/ 0000775 0000000 0000000 00000000000 15040033232 0014226 5 ustar 00root root 0000000 0000000 django-navtag-3.3.1/.gitignore 0000664 0000000 0000000 00000000107 15040033232 0016214 0 ustar 00root root 0000000 0000000 .tox/
*.pyc
*.egg-info/
.eggs/
dist/
.coverage
.python-version
uv.lock
django-navtag-3.3.1/.travis.yml 0000664 0000000 0000000 00000000171 15040033232 0016336 0 ustar 00root root 0000000 0000000 sudo: false
language: python
python:
- "3.6"
- "3.7"
- "3.8"
- "3.9"
install: pip install tox-travis
script: tox
django-navtag-3.3.1/CLAUDE.md 0000664 0000000 0000000 00000004400 15040033232 0015503 0 ustar 00root root 0000000 0000000 # CLAUDE.md
This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
## Repository Overview
This is `django-navtag`, a Django template tag library for handling navigation item selection in templates. It provides a simple way to manage active states in navigation menus across template inheritance hierarchies.
## Project Structure
- `django_navtag/templatetags/navtag.py` - Core implementation (Nav class and template tags)
- `django_navtag/tests/test_navtag.py` - Test suite
- `django_navtag/tests/settings.py` - Django test settings
## Common Commands
### Development Setup
```bash
# Install with development dependencies (requires pip >= 23.1)
pip install -e ".[dev]"
# Or using the dependency-groups syntax (pip >= 24.1)
pip install -e . --dependency-groups=dev
```
### Running Tests
```bash
# Run tests with pytest
pytest
# Run with coverage
pytest --cov
# Run full test matrix across Python/Django versions
tox
# Run specific environment
tox -e py39-django32
```
### Code Quality
```bash
# Check README formatting
tox -e readme
# Run coverage checks (100% for tests, 90% for main code)
tox -e coverage
```
### Release Process
- Uses zest.releaser for version management
- Current version: 3.3.dev0
- Tag signing is enabled
## Key Implementation Details
### Nav Class (`django_navtag/templatetags/navtag.py`)
The Nav class is the core of the library, providing:
- Hierarchical navigation state management via dictionary structure
- Special comparison operators (`__eq__`, `__contains__`)
- Pattern matching with `!` syntax for children-only matching
- Active path tracking via `get_active_path()`
### Template Tags
1. **`{% nav %}`** - Sets active navigation items
- Supports hierarchical paths (e.g., `about_menu.info`)
- Custom context variable names with `for`
- Text output customization
2. **`{% navlink %}`** - Renders links/spans based on navigation state
- Automatically switches between `` and `` elements
- Supports special patterns and alternate nav variables
### Testing
- Uses pytest with pytest-django
- Test templates in `django_navtag/templates/navtag_tests/`
- Django settings module: `django_navtag.tests.settings`
## Python/Django Support
- Python: 3.8-3.12
- Django: 3.2, 4.2, 5.0, 5.1 django-navtag-3.3.1/LICENSE 0000664 0000000 0000000 00000002041 15040033232 0015230 0 ustar 00root root 0000000 0000000 Copyright (c) 2013, Chris Beaven
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.
django-navtag-3.3.1/README.rst 0000664 0000000 0000000 00000016630 15040033232 0015723 0 ustar 00root root 0000000 0000000 ``{% nav %}`` tag
=================
.. image:: https://badge.fury.io/py/django-navtag.svg
:target: https://badge.fury.io/py/django-navtag
.. image:: https://codecov.io/gh/SmileyChris/django-navtag/branch/master/graph/badge.svg
:target: https://codecov.io/gh/SmileyChris/django-navtag
A simple Django template tag to handle navigation item selection.
.. contents::
:local:
:backlinks: none
Installation
------------
Install the package using pip:
.. code:: bash
pip install django-navtag
Usage
-----
Add the app to your ``INSTALLED_APPS`` setting:
.. code:: python
INSTALLED_APPS = (
# ...
'django_navtag',
)
Give your base template a navigation block something like this:
.. code:: jinja
{% load navtag %}
{% block nav %}
{% nav text ' class="selected"' %}
{% endblock %}
In your templates, extend the base and set the navigation location:
.. code:: jinja
{% extends "base.html" %}
{% block nav %}
{% nav "home" %}
{{ block.super }}
{% endblock %}
.. note::
This works for multiple levels of template inheritance, due to the fact
that only the first ``{% nav %}`` call found will change the ``nav``
context variable.
Hierarchical navigation
-----------------------
To create a sub-menu you can check against, simply dot-separate the item:
.. code:: jinja
{% nav "about_menu.info" %}
This will be pass for both ``{% if nav.about_menu %}`` and
``{% if nav.about_menu.info %}``.
Using a different context variable
----------------------------------
By default, this tag creates a ``nav`` context variable. To use an alternate
context variable name, call ``{% nav [item] for [var_name] %}``:
.. code:: jinja
{% block nav %}
{% nav "home" for sidenav %}
{{ block.super }}
{% endblock %}
Setting the text output by the nav variable
-------------------------------------------
As shown in the initial example, you can set the text return value of the
``nav`` context variable. Use the format ``{% nav text [content] %}``. For
example:
.. code:: jinja
{% nav text "active" %}
Alternately, you can use boolean comparison of the context variable rather than
text value:
.. code:: jinja
If using a different context variable name, use the format
``{% nav text [content] for [var_name] %}``.
Comparison operations
---------------------
The ``nav`` object supports comparison operations for more flexible navigation handling:
**Exact matching with** ``==``:
.. code:: jinja
{% nav "products.phones" %}
{% if nav == "products.phones" %}
{# True - exact match #}
{% endif %}
{% if nav == "products" %}
{# False - not exact #}
{% endif %}
**Special patterns with** ``!``:
.. code:: jinja
{% nav "products.electronics" %}
{% if nav == "products!" %}
{# True - matches any child of products #}
{% endif %}
{% if nav == "products!clearance" %}
{# True - matches children except 'clearance' #}
{% endif %}
**Component checking with** ``in``:
.. code:: jinja
{% nav "products.electronics.phones" %}
{% if "products" in nav %}
{# True - component exists #}
{% endif %}
{% if "electronics" in nav %}
{# True - component exists #}
{% endif %}
{% if "tablets" in nav %}
{# False - component doesn't exist #}
{% endif %}
These operations also work with sub-navigation:
.. code:: jinja
{% nav "products.electronics.phones" %}
{% if nav.products == "electronics.phones" %}
{# True #}
{% endif %}
{% if "electronics" in nav.products %}
{# True #}
{% endif %}
Iteration
---------
The ``nav`` object supports iteration over its active path components:
.. code:: jinja
{% nav "products.electronics.phones" %}
{% for component in nav %}
{{ component }}
{# Outputs: products, electronics, phones #}
{% endfor %}
This also works with sub-navigation:
.. code:: jinja
{% nav "products.electronics.phones" %}
{% for component in nav.products %}
{{ component }}
{# Outputs: electronics, phones #}
{% endfor %}
The ``{% navlink %}`` tag
-------------------------
The ``{% navlink %}`` tag provides a convenient way to create navigation links that automatically change based on the active navigation state. It works as a block tag that renders different HTML elements depending on whether the navigation item is active.
Basic usage:
.. code:: jinja
{% load navtag %}
{% nav text 'active' %}
{% nav "products" %}
{% navlink 'home' 'home_url' %}Home{% endnavlink %}
{% navlink 'products' 'product_list' %}Products{% endnavlink %}
{% navlink 'contact' 'contact_url' %}Contact{% endnavlink %}
The tag will render:
- ``... `` - when the nav item is active
- ``... `` - when the nav item is a parent of the active item
- ``... `` - when the nav item is not active
The second parameter uses Django's built-in ``{% url %}`` tag syntax, so you can pass URL names with arguments:
.. code:: jinja
{% navlink 'product' 'product_detail' product_id=product.id %}
{{ product.name }}
{% endnavlink %}
Custom attributes
~~~~~~~~~~~~~~~~~
You can customize the attribute added to active links using ``{% nav text %}`` with an attribute format:
.. code:: jinja
{% nav text ' aria-selected="true"' %}
{% nav "home" %}
{% navlink 'home' 'home_url' %}Home{% endnavlink %}
{# Renders: Home #}
Special matching patterns
~~~~~~~~~~~~~~~~~~~~~~~~~
The ``{% navlink %}`` tag supports special patterns for more precise matching:
**Children-only pattern** (``item!``):
.. code:: jinja
{% nav "courses.special" %}
{% navlink 'courses' 'course_list' %}All Courses{% endnavlink %}
{# Renders as link with class="active" #}
{% navlink 'courses!' 'course_detail' %}Course Details{% endnavlink %}
{# Renders as link with class="active" - only when nav is a child of courses #}
When ``courses`` is active (not a child), the first link is active but the second becomes a ````.
**Exclusion pattern** (``item!exclude``):
.. code:: jinja
{% nav "courses.special" %}
{% navlink 'courses!list' 'course_detail' %}Course (not list){% endnavlink %}
{# Renders as link - active for any child except 'list' #}
{% navlink 'courses!special' 'course_detail' %}Course (not special){% endnavlink %}
{# Renders as span - 'special' is excluded #}
You can also use these patterns with ``{% if %}`` statements:
.. code:: jinja
{% if nav == "courses!" %}
{# True - matches any child of courses #}
{% endif %}
Alternate nav context
~~~~~~~~~~~~~~~~~~~~~
To use a different navigation context variable, prefix the nav item with the variable name:
.. code:: jinja
{% nav "products" for mainnav %}
{% nav "settings" for sidenav %}
{% navlink 'mainnav:products' 'product_list' %}Products{% endnavlink %}
{% navlink 'sidenav:settings' 'user_settings' %}Settings{% endnavlink %}
django-navtag-3.3.1/deploy.py 0000775 0000000 0000000 00000026257 15040033232 0016113 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python3
# /// script
# requires-python = ">=3.8"
# dependencies = [
# "keyring",
# ]
# ///
"""Deploy package to PyPI."""
import argparse
import configparser
import os
import shutil
import subprocess
import sys
from pathlib import Path
def run_command(cmd, check=True, capture_output=False):
"""Run a command and return the result."""
result = subprocess.run(
cmd, shell=True, check=check, capture_output=capture_output, text=True
)
if capture_output:
return result.stdout.strip()
else:
return result
def check_uv_installed():
"""Check if uv is installed."""
if shutil.which("uv") is None:
print("Error: 'uv' is not installed. Please install it first.")
print("Visit: https://github.com/astral-sh/uv#installation")
sys.exit(1)
print("✓ uv is installed")
def ensure_uv_env_vars():
"""Ensure required UV environment variables are set."""
required_vars = {
"UV_KEYRING_PROVIDER": "subprocess",
"UV_PUBLISH_USERNAME": "__token__",
}
vars_to_set = {}
for var, value in required_vars.items():
if os.environ.get(var) != value:
vars_to_set[var] = value
os.environ[var] = value
if not vars_to_set:
print("✓ UV environment variables already configured")
return
print("Setting UV environment variables for this session...")
for var, value in vars_to_set.items():
print(f" {var}={value}")
# Detect shell and update config file
shell = os.environ.get("SHELL", "").split("/")[-1]
home = Path.home()
shell_configs = {
"bash": home / ".bashrc",
"zsh": home / ".zshrc",
"fish": home / ".config/fish/config.fish",
}
config_file = shell_configs.get(shell)
if not config_file or not config_file.exists():
# Try to find which one exists
for shell_name, path in shell_configs.items():
if path.exists():
config_file = path
shell = shell_name
break
if config_file and config_file.exists():
print(f"\nUpdating {config_file.name}...")
with open(config_file, "r") as f:
content = f.read()
# Check if variables are already in the file
lines_to_add = []
for var, value in vars_to_set.items():
if f"export {var}=" not in content:
lines_to_add.append(f"export {var}={value}")
if lines_to_add:
with open(config_file, "a") as f:
f.write("\n# UV configuration for PyPI publishing\n")
for line in lines_to_add:
f.write(f"{line}\n")
print(f"✓ Added UV environment variables to {config_file.name}")
print(
f" Note: Restart your shell or run 'source {config_file}' to apply changes"
)
else:
print(f"✓ UV environment variables already in {config_file.name}")
else:
print("\n⚠️ Could not detect shell configuration file")
print("Please manually add these to your shell configuration:")
for var, value in vars_to_set.items():
print(f" export {var}={value}")
def ensure_keyring():
"""Ensure keyring is installed and configured."""
# keyring will be automatically installed by uv due to script dependencies
import keyring
# Check if token is already in keyring
try:
existing_token = keyring.get_password(
"https://upload.pypi.org/legacy/", "__token__"
)
if existing_token:
print("✓ PyPI token already configured in keyring")
return
except Exception:
pass
# Try to get token from .pypirc
pypirc_path = Path.home() / ".pypirc"
token = None
if pypirc_path.exists():
config = configparser.ConfigParser()
config.read(pypirc_path)
# Try to find token in various sections
for section in ["pypi", "pypirc"]:
if section in config:
if "password" in config[section]:
password = config[section]["password"]
if password.startswith("pypi-"):
token = password
break
if token:
print("Found PyPI token in .pypirc, adding to keyring...")
run_command(
f"keyring set 'https://upload.pypi.org/legacy/' __token__ <<< '{token}'",
shell=True,
)
print("✓ PyPI token configured in keyring")
else:
print("\nNo PyPI token found in .pypirc")
print("Please manually set your token with:")
print(" keyring set 'https://upload.pypi.org/legacy/' __token__")
print("\nYou can find your token at: https://pypi.org/manage/account/token/")
sys.exit(1)
def check_git_status():
"""Ensure git working directory is clean."""
status = run_command("git status --porcelain", capture_output=True)
if status:
print("\nError: Git working directory is not clean!")
print("Please commit or stash your changes first.")
print("\nUncommitted changes:")
print(status)
sys.exit(1)
print("✓ Git working directory is clean")
def run_tests():
"""Run full test suite with tox in parallel."""
print("\nRunning tests with tox (parallel)...")
result = run_command("uv run tox -p auto", check=False)
if result.returncode != 0:
print("\nError: Tests failed!")
sys.exit(1)
print("✓ All tests passed")
def get_current_version():
"""Get current version from pyproject.toml."""
output = run_command("uv version --short", capture_output=True)
return output.strip()
def determine_bump_type(current_version):
"""Ask user for version bump type."""
print(f"\nCurrent version: {current_version}")
try:
if "dev" in current_version:
print("\nThis is a development version.")
choice = input("Release as stable version? [Y/n]: ").strip().lower()
if choice in ["", "y", "yes"]:
return "stable"
# For both dev versions (if user said no) and stable versions
print("\nSelect version bump type:")
print("1. Major (X.0.0)")
print("2. Minor (x.Y.0)")
print("3. Patch (x.y.Z)")
while True:
choice = input("Enter choice [1-3]: ").strip()
if choice == "1":
return "major"
elif choice == "2":
return "minor"
elif choice == "3":
return "patch"
else:
print("Invalid choice. Please enter 1, 2, or 3.")
except KeyboardInterrupt:
return None
def bump_version(bump_type):
"""Bump version using uv."""
print(f"Bumping {bump_type} version...")
run_command(f"uv version --bump {bump_type}")
new_version = get_current_version()
print(f"✓ Version bumped to: {new_version}")
return new_version
def commit_version(version):
"""Commit version bump."""
print("\nCommitting version bump...")
run_command("git add pyproject.toml")
run_command(f'git commit -m "Bump version to {version}"')
print("✓ Version bump committed")
def build_package():
"""Build the package."""
print("\nBuilding package...")
# Clean up old builds
run_command("rm -rf dist/ build/ *.egg-info", check=False)
result = run_command("uv build --no-build-logs", check=False)
if result.returncode != 0:
print("\nError: Package build failed!")
sys.exit(1)
print("✓ Package built successfully")
def publish_package():
"""Publish package to PyPI."""
print("\n" + "=" * 60)
print("READY TO PUBLISH TO PYPI")
print("=" * 60)
# Show what will be uploaded
dist_files = sorted(Path("dist").glob("*"))
print("\nFiles to be uploaded:")
for f in dist_files:
if f.is_file() and f.name not in [".gitignore", ".DS_Store"]:
print(f" - {f.name}")
print("\nThis will upload the package to PyPI (production)!")
confirm = input("Are you sure you want to continue? [y/N]: ").strip().lower()
if confirm != "y":
print("\nPublish cancelled.")
return False
print("\nPublishing to PyPI...")
run_command("uv publish")
print("\n✓ Package published successfully!")
return True
def create_git_tag(version):
"""Create and push git tag."""
tag_name = f"v{version}"
print(f"\nCreating git tag {tag_name}...")
run_command(f"git tag -s {tag_name} -m 'Release version {version}'")
print(f"✓ Git tag {tag_name} created")
# Get current branch name
current_branch = run_command("git branch --show-current", capture_output=True)
push_tag = (
input(
f"\nPush branch '{current_branch}' and tag '{tag_name}' to origin? [Y/n]: "
)
.strip()
.lower()
)
if push_tag in ["", "y", "yes"]:
print("Pushing branch and tag to origin...")
run_command(f"git push origin {current_branch} {tag_name}")
print(f"✓ Branch '{current_branch}' and tag '{tag_name}' pushed to origin")
def main():
"""Main deployment function."""
parser = argparse.ArgumentParser(description="Deploy package to PyPI")
parser.add_argument(
"command",
nargs="?",
choices=["tag", "bump"],
help="Command to run (e.g., 'tag', 'bump')",
)
parser.add_argument("--version", help="Version to tag (for 'tag' command)")
parser.add_argument(
"--type",
choices=["major", "minor", "patch", "stable"],
help="Version bump type (for 'bump' command)",
)
args = parser.parse_args()
# Change to project directory
script_dir = Path(__file__).parent
os.chdir(script_dir)
# Handle tag command
if args.command == "tag":
check_uv_installed()
check_git_status()
version = args.version or get_current_version()
create_git_tag(version)
print(f"\n✅ Tag v{version} created successfully!")
return
# Handle bump command
if args.command == "bump":
check_uv_installed()
check_git_status()
current_version = get_current_version()
if args.type:
bump_type = args.type
else:
bump_type = determine_bump_type(current_version)
if bump_type is None:
print("\nBump cancelled.")
return
new_version = bump_version(bump_type)
commit_version(new_version)
print(f"\n✅ Version bumped to {new_version} and committed!")
return
# Full deployment flow
check_uv_installed()
ensure_uv_env_vars()
ensure_keyring()
check_git_status()
run_tests()
current_version = get_current_version()
bump_type = determine_bump_type(current_version)
if bump_type is None:
print("\nDeployment cancelled.")
return
new_version = bump_version(bump_type)
commit_version(new_version)
build_package()
if publish_package():
create_git_tag(new_version)
print("\n✅ Deployment completed successfully!")
else:
print("\n⚠️ Package built but not published.")
print("You can manually publish later with: uv publish")
if __name__ == "__main__":
main()
django-navtag-3.3.1/django_navtag/ 0000775 0000000 0000000 00000000000 15040033232 0017030 5 ustar 00root root 0000000 0000000 django-navtag-3.3.1/django_navtag/__init__.py 0000664 0000000 0000000 00000000000 15040033232 0021127 0 ustar 00root root 0000000 0000000 django-navtag-3.3.1/django_navtag/models.py 0000664 0000000 0000000 00000000000 15040033232 0020653 0 ustar 00root root 0000000 0000000 django-navtag-3.3.1/django_navtag/templates/ 0000775 0000000 0000000 00000000000 15040033232 0021026 5 ustar 00root root 0000000 0000000 django-navtag-3.3.1/django_navtag/templates/navtag_tests/ 0000775 0000000 0000000 00000000000 15040033232 0023530 5 ustar 00root root 0000000 0000000 django-navtag-3.3.1/django_navtag/templates/navtag_tests/base.txt 0000664 0000000 0000000 00000000236 15040033232 0025204 0 ustar 00root root 0000000 0000000 {% block nav %}
- Home {% if nav.home %}(active){% endif %}
- Contact {% if nav.contact %}(active){% endif %}
{% endblock %}
{% block main %}
{% endblock %}
django-navtag-3.3.1/django_navtag/templates/navtag_tests/contact.txt 0000664 0000000 0000000 00000000175 15040033232 0025727 0 ustar 00root root 0000000 0000000 {% extends "navtag_tests/base.txt" %}
{% load navtag %}
{% block nav %}
{% nav "contact" %}
{{ block.super }}
{% endblock %} django-navtag-3.3.1/django_navtag/templates/navtag_tests/context/ 0000775 0000000 0000000 00000000000 15040033232 0025214 5 ustar 00root root 0000000 0000000 django-navtag-3.3.1/django_navtag/templates/navtag_tests/context/home.txt 0000664 0000000 0000000 00000000312 15040033232 0026701 0 ustar 00root root 0000000 0000000 {% extends "navtag_tests/base.txt" %}
{% load navtag %}
{% block nav %}
{% nav "home" %}
{{ block.super }}
{% endblock %}
{% block main %}
{% if nav.home %}HOME{% else %}huh?{% endif %}
{% endblock %} django-navtag-3.3.1/django_navtag/templates/navtag_tests/home-unset.txt 0000664 0000000 0000000 00000000166 15040033232 0026360 0 ustar 00root root 0000000 0000000 {% extends "navtag_tests/home.txt" %}
{% load navtag %}
{% block nav %}
{% nav "" %}
{{ block.super }}
{% endblock %} django-navtag-3.3.1/django_navtag/templates/navtag_tests/home.txt 0000664 0000000 0000000 00000000172 15040033232 0025221 0 ustar 00root root 0000000 0000000 {% extends "navtag_tests/base.txt" %}
{% load navtag %}
{% block nav %}
{% nav "home" %}
{{ block.super }}
{% endblock %} django-navtag-3.3.1/django_navtag/templates/navtag_tests/submenu/ 0000775 0000000 0000000 00000000000 15040033232 0025206 5 ustar 00root root 0000000 0000000 django-navtag-3.3.1/django_navtag/templates/navtag_tests/submenu/apple.txt 0000664 0000000 0000000 00000000217 15040033232 0027050 0 ustar 00root root 0000000 0000000 {% extends "navtag_tests/submenu/base_fruit.txt" %}
{% load navtag %}
{% block nav %}
{% nav "fruit.apple" %}
{{ block.super }}
{% endblock %} django-navtag-3.3.1/django_navtag/templates/navtag_tests/submenu/banana.txt 0000664 0000000 0000000 00000000220 15040033232 0027161 0 ustar 00root root 0000000 0000000 {% extends "navtag_tests/submenu/base_fruit.txt" %}
{% load navtag %}
{% block nav %}
{% nav "fruit.banana" %}
{{ block.super }}
{% endblock %} django-navtag-3.3.1/django_navtag/templates/navtag_tests/submenu/base.txt 0000664 0000000 0000000 00000000347 15040033232 0026665 0 ustar 00root root 0000000 0000000 {% block nav %}
- Home {% if nav.home %}(active){% endif %}
- Fruit {% if nav.fruit %}(active){% endif %}
- Apple {% if nav.fruit.apple %}(active){% endif %}
- Banana {% if nav.fruit.banana %}(active){% endif %}
{% endblock %}
django-navtag-3.3.1/django_navtag/templates/navtag_tests/submenu/base_fruit.txt 0000664 0000000 0000000 00000000203 15040033232 0030065 0 ustar 00root root 0000000 0000000 {% extends "navtag_tests/submenu/base.txt" %}
{% load navtag %}
{% block nav %}
{% nav "fruit" %}
{{ block.super }}
{% endblock %} django-navtag-3.3.1/django_navtag/templates/navtag_tests/submenu/home.txt 0000664 0000000 0000000 00000000202 15040033232 0026671 0 ustar 00root root 0000000 0000000 {% extends "navtag_tests/submenu/base.txt" %}
{% load navtag %}
{% block nav %}
{% nav "home" %}
{{ block.super }}
{% endblock %} django-navtag-3.3.1/django_navtag/templates/navtag_tests/text/ 0000775 0000000 0000000 00000000000 15040033232 0024514 5 ustar 00root root 0000000 0000000 django-navtag-3.3.1/django_navtag/templates/navtag_tests/text/base.txt 0000664 0000000 0000000 00000000241 15040033232 0026164 0 ustar 00root root 0000000 0000000 {% load navtag %}
{% block nav %}
{% nav text " [is active]" %}
- Home{{ nav.home }}
- Contact{{ nav.contact }}
{% endblock %}
{% block main %}
{% endblock %}
django-navtag-3.3.1/django_navtag/templates/navtag_tests/text/contact.txt 0000664 0000000 0000000 00000000202 15040033232 0026702 0 ustar 00root root 0000000 0000000 {% extends "navtag_tests/text/base.txt" %}
{% load navtag %}
{% block nav %}
{% nav "contact" %}
{{ block.super }}
{% endblock %} django-navtag-3.3.1/django_navtag/templates/navtag_tests/text/home.txt 0000664 0000000 0000000 00000000177 15040033232 0026212 0 ustar 00root root 0000000 0000000 {% extends "navtag_tests/text/base.txt" %}
{% load navtag %}
{% block nav %}
{% nav "home" %}
{{ block.super }}
{% endblock %} django-navtag-3.3.1/django_navtag/templatetags/ 0000775 0000000 0000000 00000000000 15040033232 0021522 5 ustar 00root root 0000000 0000000 django-navtag-3.3.1/django_navtag/templatetags/__init__.py 0000664 0000000 0000000 00000000000 15040033232 0023621 0 ustar 00root root 0000000 0000000 django-navtag-3.3.1/django_navtag/templatetags/navtag.py 0000664 0000000 0000000 00000030747 15040033232 0023367 0 ustar 00root root 0000000 0000000 from django import template
from django.utils.encoding import smart_str
from django.utils.safestring import mark_safe
register = template.Library()
class Nav(object):
def __init__(self, tree=None, root=None):
self._root = root or self
self._tree = tree or {}
def __getitem__(self, key):
return Nav(self._tree[key], root=self._root)
def __str__(self):
return mark_safe(str(self._text))
def __bool__(self):
return bool(self._tree)
def _get_text(self):
if hasattr(self._root, "_text_value"):
return self._root._text_value
return self._tree
def _set_text(self, value):
self._root._text_value = value
_text = property(_get_text, _set_text)
def clear(self):
self._tree = {}
def update(self, *args, **kwargs):
self._tree.update(*args, **kwargs)
def get_active_path(self, path=""):
"""Get the dotted path of the active navigation item"""
# Handle case where _tree is not a dict (e.g., True for leaf nodes)
if not isinstance(self._tree, dict):
return ""
for key, value in self._tree.items():
current_path = path + "." + key if path else key
if isinstance(value, dict):
# Recurse into nested nav
sub_nav = Nav(value, root=self._root)
result = sub_nav.get_active_path(current_path)
if result:
return result
elif value:
return current_path
return ""
def __eq__(self, other):
"""Check if the active navigation path matches the given pattern
Patterns:
- "item" - exact match
- "item!" - children only (not exact match)
- "item!exclude" - children except 'exclude'
"""
if isinstance(other, str):
active_path = self.get_active_path()
if "!" in other:
parts = other.split("!", 1)
parent = parts[0]
exclude = parts[1] if len(parts) > 1 and parts[1] else None
if exclude:
# Pattern like 'courses!list' - match children except specific ones
return (
active_path.startswith(parent + ".")
and active_path != parent
and not active_path.startswith(parent + "." + exclude)
)
else:
# Pattern like 'courses!' - match children only, not exact
return (
active_path.startswith(parent + ".") and active_path != parent
)
else:
# Normal pattern - exact match
return active_path == other
elif isinstance(other, Nav):
return self.get_active_path() == other.get_active_path()
return False
def __contains__(self, item):
"""Check if a component is part of the active navigation path"""
if isinstance(item, str):
active_path = self.get_active_path()
if not active_path:
return False
# Check if the component matches any part of the path
components = active_path.split(".")
return item in components
return False
def __iter__(self):
"""Iterate over the active path components"""
active_path = self.get_active_path()
if active_path:
for part in active_path.split("."):
yield part
class NavNode(template.Node):
def __init__(self, item=None, var_for=None, var_text=None):
self.item = item
self.var_name = var_for or "nav"
self.text = var_text
def render(self, context):
first_context_stack = context.dicts[0]
nav = first_context_stack.get(self.var_name)
if nav is not context.get(self.var_name):
raise template.TemplateSyntaxError(
"'{0}' variable has been altered in current context".format(
self.var_name
)
)
if not isinstance(nav, Nav):
nav = Nav()
# Copy the stack to avoid leaking into other contexts.
new_first_context_stack = first_context_stack.copy()
new_first_context_stack[self.var_name] = nav
context.dicts[0] = new_first_context_stack
if self.text:
nav._text = self.text.resolve(context)
return ""
# If self.item was blank then there's nothing else to do here.
if not self.item:
return ""
if nav:
# If the nav variable is already set, don't do anything.
return ""
item = self.item.resolve(context)
item = item and smart_str(item)
value = True
if not item:
item = ""
for part in reversed(item.split(".")):
new_item = {}
new_item[part] = value
value = new_item
nav.clear()
nav.update(new_item)
return ""
def __repr__(self):
return ""
@register.tag
def nav(parser, token):
"""
Handles navigation item selection.
Example usage::
{# Set the context so {{ nav.home }} (or {{ mynav.home }}) is True #}
{% nav "home" %} or {% nav "home" for mynav %}
The most basic (and common) use of the tag is to call ``{% nav [item] %}``,
where ``[item]`` is the item you want to check is selected.
By default, this tag creates a ``nav`` context variable. To use an
alternate context variable name, call ``{% nav [item] for [var_name] %}``.
Your HTML navigation template should look something like::
{% block nav %}
{% endblock %}
To override this in a child template, you'd do::
{% include "base.html" %}
{% load nav %}
{% block nav %}
{% nav "about" %}
{{ block.super }}
{% endblock %}
This works for multiple levels of template inheritance, due to the fact
that the tag only does anything if the ``nav`` context variable does not
exist. So only the first ``{% nav %}`` call found will ever be processed.
As a shortcut, you can use a ``text`` argument and then just reference the
variable rather than query it with an ``{% if %}`` tag::
{% nav text ' class="active"' %}
To create a sub-menu you can check against, simply dot-separate the item::
{% nav "about_menu.info" %}
This will be pass for both ``{% if nav.about_menu %}`` and
``{% if nav.about_menu.info %}``.
Comparison operations::
{# Exact path matching with == #}
{% if nav == "home" %} {# True if exactly "home" is active #}
{% if nav == "products.phones" %} {# True if exactly "products.phones" is active #}
{# Children-only matching #}
{% if nav == "products!" %} {# True if any child of products is active #}
{% if nav == "products!list" %} {# True if child of products except 'list' #}
{# Component checking with 'in' #}
{% if "products" in nav %} {# True if active path contains "products" #}
{% if "phones" in nav %} {# True if active path contains "phones" #}
{# Also works on sub-navigation #}
{% nav "products.electronics.phones" %}
{% if nav.products == "electronics.phones" %} {# True #}
{% if "electronics" in nav.products %} {# True #}
{# Iteration over active path components #}
{% nav "products.electronics.phones" %}
{% for component in nav.products %}
{{ component }} {# Outputs: electronics, phones #}
{% endfor %}
"""
bits = token.split_contents()
ok = True
keys = {"for": False, "text": True}
node_kwargs = {}
while len(bits) > 2:
value = bits.pop()
key = bits.pop()
if key not in keys:
ok = False
break
compile_filter = keys.pop(key)
if compile_filter:
value = parser.compile_filter(value)
node_kwargs["var_{0}".format(key)] = value
if len(bits) > 1:
# Text argument doesn't expect an item.
ok = "text" not in node_kwargs
item = parser.compile_filter(bits[1])
else:
item = None
if not ok:
raise template.TemplateSyntaxError("Unexpected format for %s tag" % bits[0])
return NavNode(item, **node_kwargs)
class NavLinkNode(template.Node):
def __init__(self, nav_item, url_node, nodelist):
self.nav_item = nav_item
self.url_node = url_node
self.nodelist = nodelist
def render(self, context):
nav_item = self.nav_item.resolve(context)
# Check if alternate nav variable specified with ':'
var_name = "nav"
if ":" in nav_item:
var_name, nav_item = nav_item.split(":", 1)
nav = context.get(var_name)
if not isinstance(nav, Nav):
nav = Nav()
# Check if nav item is active
try:
# For normal patterns, check both exact match and parent match
# For special patterns (with !), use the Nav's __eq__ method
if "!" in nav_item:
# Use Nav's __eq__ for special patterns
is_link = nav == nav_item
else:
# Normal pattern - exact match or parent match
active_path = nav.get_active_path() if nav else ""
is_exact_match = active_path == nav_item
is_parent_match = active_path.startswith(nav_item + ".")
is_link = is_exact_match or is_parent_match
# Get the text value
nav_text = ""
if is_link and hasattr(nav, "_text_value") and nav._text_value:
nav_text = nav._text_value
if "=" not in nav_text:
nav_text = ' class="{}"'.format(nav_text.strip())
except (KeyError, AttributeError):
is_link = False
nav_text = ""
# Get the URL from the url node
url = self.url_node.render(context)
# Get the content inside the block
content = self.nodelist.render(context)
# Determine which element to render
if is_link:
# Truthy but not exact - render as regular link
return '{} '.format(url, nav_text, content)
else:
# Falsy - render as span
return "{} ".format(content)
@register.tag
def navlink(parser, token):
"""
Renders a link that changes based on navigation state.
Usage::
{% nav text ' class="active"' %}
{% navlink 'products' 'products:list' %}Products{% endnavlink %}
Renders as:
- Products - if nav.products is the active item
- Products - if nav.products is a parent item of nav
- Products - if nav.products doesn't match
Special patterns::
{% navlink 'courses!' 'course_detail' %}Course Details{% endnavlink %}
{# Active only for children like 'courses.special', not 'courses' itself #}
{% navlink 'courses!list' 'course_detail' %}Course (not list){% endnavlink %}
{# Active for 'courses.special' but not 'courses.list' #}
Use {% navlink 'alt_nav:products' ... %} to specify a different nav context.
"""
from django.template.defaulttags import url
bits = token.split_contents()
if len(bits) < 3:
raise template.TemplateSyntaxError(
"{} tag requires at least two arguments: nav item and url name".format(
bits[0]
)
)
# First argument is the nav item
nav_item = parser.compile_filter(bits[1])
# The rest is passed to the url tag
url_bits = ["url"] + bits[2:]
url_token = token.__class__(
token.token_type, " ".join(url_bits), token.position, token.lineno
)
url_node = url(parser, url_token)
# Parse until endnavlink
nodelist = parser.parse(("endnavlink",))
parser.delete_first_token()
return NavLinkNode(nav_item, url_node, nodelist)
django-navtag-3.3.1/django_navtag/tests/ 0000775 0000000 0000000 00000000000 15040033232 0020172 5 ustar 00root root 0000000 0000000 django-navtag-3.3.1/django_navtag/tests/__init__.py 0000664 0000000 0000000 00000000000 15040033232 0022271 0 ustar 00root root 0000000 0000000 django-navtag-3.3.1/django_navtag/tests/settings.py 0000664 0000000 0000000 00000001662 15040033232 0022411 0 ustar 00root root 0000000 0000000 DATABASES = {
"default": {
"ENGINE": "django.db.backends.sqlite3",
"NAME": ":memory:",
}
}
INSTALLED_APPS = [
"django_navtag",
]
SECRET_KEY = "testing"
MIDDLEWARE_CLASSES = (
"django.middleware.common.CommonMiddleware",
"django.middleware.csrf.CsrfViewMiddleware",
)
TEMPLATES = [
{
"BACKEND": "django.template.backends.django.DjangoTemplates",
"APP_DIRS": True,
"OPTIONS": {
"context_processors": [
"django.contrib.auth.context_processors.auth",
"django.template.context_processors.debug",
"django.template.context_processors.i18n",
"django.template.context_processors.media",
"django.template.context_processors.static",
"django.template.context_processors.tz",
"django.contrib.messages.context_processors.messages",
],
},
},
]
django-navtag-3.3.1/django_navtag/tests/test_navtag.py 0000664 0000000 0000000 00000061537 15040033232 0023077 0 ustar 00root root 0000000 0000000 from django import template
from django.template.loader import render_to_string
from django.test import TestCase
from django.utils.html import escape
from django_navtag.templatetags.navtag import NavNode
BASIC_TEMPLATE = """
{% load navtag %}
{% nav "banana" %}
{% if nav.apple %}Apple{% endif %}
{% if nav.banana %}Banana{% endif %}
"""
FOR_TEMPLATE = """
{% load navtag %}
{% nav "banana" for othernav %}
{% if othernav.apple %}Apple{% endif %}
{% if othernav.banana %}Banana{% endif %}
"""
NAV_LINK_TEMPLATE = """
{% load navtag %}
{% nav text 'active' %}
{% nav "products" %}
{% navlink 'home' 'home' %}Home{% endnavlink %}
{% navlink 'products' 'products' %}Products{% endnavlink %}
{% navlink 'about' 'about' %}About{% endnavlink %}
"""
NAV_LINK_TEXT_TEMPLATE = """
{% load navtag %}
{% nav text "selected" %}
{% nav "products" %}
{% navlink 'home' 'home' %}Home{% endnavlink %}
{% navlink 'products' 'products' %}Products{% endnavlink %}
{% navlink 'about' 'about' %}About{% endnavlink %}
"""
class NavTagTest(TestCase):
def test_basic(self):
t = template.Template(BASIC_TEMPLATE)
content = t.render(template.Context()).strip()
self.assertNotIn("Apple", content)
self.assertIn("Banana", content)
def test_for(self):
t = template.Template(FOR_TEMPLATE)
content = t.render(template.Context()).strip()
self.assertNotIn("Apple", content)
self.assertIn("Banana", content)
def test_basic_extends(self):
content = render_to_string("navtag_tests/home.txt").strip()
self.assertIn("- Home (active)", content)
self.assertNotIn("- Contact (active)", content)
content = render_to_string("navtag_tests/contact.txt").strip()
self.assertNotIn("- Home (active)", content)
self.assertIn("- Contact (active)", content)
def test_unset(self):
content = render_to_string("navtag_tests/home.txt").strip()
self.assertIn("- Home (active)", content)
self.assertNotIn("- Contact (active)", content)
content = render_to_string("navtag_tests/home-unset.txt").strip()
self.assertNotIn("- Home (active)", content)
self.assertNotIn("- Contact (active)", content)
def test_heirarchical(self):
content = render_to_string("navtag_tests/submenu/home.txt").strip()
self.assertIn("- Home (active)", content)
self.assertNotIn("- Fruit (active)", content)
self.assertNotIn(" - Apple (active)", content)
self.assertNotIn(" - Banana (active)", content)
content = render_to_string("navtag_tests/submenu/base_fruit.txt").strip()
self.assertNotIn("- Home (active)", content)
self.assertIn("- Fruit (active)", content)
self.assertNotIn(" - Apple (active)", content)
self.assertNotIn(" - Banana (active)", content)
content = render_to_string("navtag_tests/submenu/apple.txt").strip()
self.assertNotIn("- Home (active)", content)
self.assertIn("- Fruit (active)", content)
self.assertIn(" - Apple (active)", content)
self.assertNotIn(" - Banana (active)", content)
content = render_to_string("navtag_tests/submenu/banana.txt").strip()
self.assertNotIn("- Home (active)", content)
self.assertIn("- Fruit (active)", content)
self.assertNotIn(" - Apple (active)", content)
self.assertIn(" - Banana (active)", content)
def test_top_context(self):
content = render_to_string("navtag_tests/context/home.txt").strip()
self.assertIn("- Home (active)", content)
self.assertIn("HOME", content)
def test_repr(self):
node = NavNode()
self.assertEqual(repr(node), "")
def test_invalid_args(self):
self.assertRaises(
template.TemplateSyntaxError,
template.Template,
"""{% load navtag %}{% nav 'test' unexpected %}""",
)
def test_backwards_compatible_empty_tag(self):
content = template.Template("{% load navtag %}{% nav %}").render(
template.Context()
)
self.assertEqual(content, "")
content = template.Template("{% load navtag %}{% nav for sidenav %}").render(
template.Context()
)
self.assertEqual(content, "")
def test_yell_if_context_variable_changed(self):
t = template.Template('{% load navtag %}{% nav "test" %}{{ nav }}')
c = template.Context({"nav": "anything"})
c.update({"nav": "test"})
self.assertRaises(template.TemplateSyntaxError, t.render, c)
def test_nav_text(self):
content = template.Template('{% load navtag %}{% nav text "THIS" %}').render(
template.Context()
)
self.assertEqual(content, "")
def test_nav_text_none(self):
content = render_to_string("navtag_tests/text/base.txt").strip()
self.assertEqual(content, "- Home\n- Contact")
def test_nav_text_set(self):
content = render_to_string("navtag_tests/text/home.txt").strip()
self.assertIn("Home [is active]", content)
self.assertNotIn("Contact [is active]", content)
content = render_to_string("navtag_tests/text/contact.txt").strip()
self.assertNotIn("Home [is active]", content)
self.assertIn("Contact [is active]", content)
def test_nav_default_text(self):
content = (
template.Template(
'{% load navtag %}{% nav "fruit" %}{{ nav.fruit }}'
).render(template.Context(autoescape=False))
).strip()
self.assertEqual(content, "True")
content = (
template.Template(
'{% load navtag %}{% nav "fruit.banana" %}{{ nav.fruit }}'
).render(template.Context(autoescape=False))
).strip()
self.assertEqual(content, "{'banana': True}")
def test_escaping(self):
content = (
template.Template(
"""{% load navtag %}{% nav text ' class="active"' %}"""
"{{ name }}"
).render(template.Context({"name": "Mc'D"}))
).strip()
escaped = escape("Mc'D")
self.assertEqual(content, """%s
""" % escaped)
def test_navlink_active(self):
"""Test navlink when the nav item is active"""
t = template.Template(NAV_LINK_TEMPLATE)
# We need to patch the url rendering since we don't have URL conf
from django_navtag.templatetags.navtag import NavLinkNode
original_render = NavLinkNode.render
def patched_render(self, context):
# Override URL node rendering
original_url_render = self.url_node.render
self.url_node.render = lambda ctx: {
"home": "/home/",
"products": "/products/",
"about": "/about/",
}.get(self.nav_item.resolve(ctx), "/")
result = original_render(self, context)
self.url_node.render = original_url_render
return result
NavLinkNode.render = patched_render
try:
content = t.render(template.Context()).strip()
# Products should be active with class="active"
self.assertIn('Products ', content)
# Home and About should be spans since they're not set in nav
self.assertIn("Home ", content)
self.assertIn("About ", content)
finally:
NavLinkNode.render = original_render
def test_navlink_inactive(self):
"""Test navlink when no nav item is active"""
t = template.Template("""
{% load navtag %}
{% navlink 'home' 'home' %}Home{% endnavlink %}
{% navlink 'products' 'products' %}Products{% endnavlink %}
""")
from django_navtag.templatetags.navtag import NavLinkNode
original_render = NavLinkNode.render
def patched_render(self, context):
# Override URL node rendering
original_url_render = self.url_node.render
self.url_node.render = lambda ctx: "/" + self.nav_item.resolve(ctx) + "/"
result = original_render(self, context)
self.url_node.render = original_url_render
return result
NavLinkNode.render = patched_render
try:
content = t.render(template.Context()).strip()
# All items should be spans since no nav is set
self.assertIn("Home ", content)
self.assertIn("Products ", content)
# No links should be present
self.assertNotIn("Products ', content)
# Others should be spans since they're not set in nav
self.assertIn("Home ", content)
self.assertIn("About ", content)
# No items should have class="active" since text is "selected"
self.assertNotIn('class="active"', content)
finally:
NavLinkNode.render = original_render
def test_navlink_hierarchical(self):
"""Test navlink with hierarchical navigation"""
t = template.Template("""
{% load navtag %}
{% nav text ' class="active"' %}
{% nav "products.electronics" %}
{% navlink 'products' 'products' %}All Products{% endnavlink %}
{% navlink 'products.electronics' 'electronics' %}Electronics{% endnavlink %}
{% navlink 'products.clothing' 'clothing' %}Clothing{% endnavlink %}
""")
from django_navtag.templatetags.navtag import NavLinkNode
original_render = NavLinkNode.render
def patched_render(self, context):
# Override URL node rendering
original_url_render = self.url_node.render
self.url_node.render = (
lambda ctx: "/" + self.nav_item.resolve(ctx).replace(".", "/") + "/"
)
result = original_render(self, context)
self.url_node.render = original_url_render
return result
NavLinkNode.render = patched_render
try:
content = t.render(template.Context()).strip()
# According to the implementation, both parent and exact match get class="active"
self.assertIn(
'All Products ', content
)
# products.electronics should be active (exact match)
self.assertIn(
'Electronics ',
content,
)
# products.clothing should be a span
self.assertIn("Clothing ", content)
finally:
NavLinkNode.render = original_render
def test_navlink_with_attribute_text(self):
"""Test navlink with nav text containing '=' (e.g., data attributes)"""
t = template.Template("""
{% load navtag %}
{% nav text ' aria-selected="true"' %}
{% nav "products" %}
{% navlink 'home' 'home' %}Home{% endnavlink %}
{% navlink 'products' 'products' %}Products{% endnavlink %}
""")
from django_navtag.templatetags.navtag import NavLinkNode
original_render = NavLinkNode.render
def patched_render(self, context):
# Override URL node rendering
original_url_render = self.url_node.render
self.url_node.render = lambda ctx: "/" + self.nav_item.resolve(ctx) + "/"
result = original_render(self, context)
self.url_node.render = original_url_render
return result
NavLinkNode.render = patched_render
try:
content = t.render(template.Context()).strip()
# Products should have the data attribute
self.assertIn(
'Products ', content
)
# Home should be a span
self.assertIn("Home ", content)
# Should not contain class= since we're using data attributes
self.assertNotIn("class=", content)
finally:
NavLinkNode.render = original_render
def test_nav_eq_exact_match(self):
"""Test Nav.__eq__ for exact path matching"""
t = template.Template("""
{% load navtag %}
{% nav "home" %}
{% if nav == "home" %}HOME_EXACT{% endif %}
{% if nav == "about" %}ABOUT_EXACT{% endif %}
""")
content = t.render(template.Context()).strip()
self.assertIn("HOME_EXACT", content)
self.assertNotIn("ABOUT_EXACT", content)
def test_nav_eq_hierarchical(self):
"""Test Nav.__eq__ with hierarchical paths"""
t = template.Template("""
{% load navtag %}
{% nav "products.electronics" %}
{% if nav == "products.electronics" %}EXACT_MATCH{% endif %}
{% if nav == "products" %}PARENT_MATCH{% endif %}
{% if nav == "electronics" %}CHILD_MATCH{% endif %}
""")
content = t.render(template.Context()).strip()
self.assertIn("EXACT_MATCH", content)
self.assertNotIn("PARENT_MATCH", content)
self.assertNotIn("CHILD_MATCH", content)
def test_nav_eq_with_subnav(self):
"""Test Nav.__eq__ on sub-navigation objects"""
t = template.Template("""
{% load navtag %}
{% nav "products.electronics.phones" %}
{% if nav.products == "electronics.phones" %}SUBNAV_MATCH{% endif %}
{% if nav.products == "electronics" %}SUBNAV_NOMATCH{% endif %}
""")
content = t.render(template.Context()).strip()
self.assertIn("SUBNAV_MATCH", content)
self.assertNotIn("SUBNAV_NOMATCH", content)
def test_nav_eq_children_only(self):
"""Test Nav.__eq__ with 'item!' pattern for children only"""
t = template.Template("""
{% load navtag %}
{% nav "courses.special" %}
{% if nav == "courses!" %}CHILD_MATCH{% endif %}
{% if nav == "courses" %}EXACT_MATCH{% endif %}
""")
content = t.render(template.Context()).strip()
self.assertIn("CHILD_MATCH", content)
self.assertNotIn("EXACT_MATCH", content)
# Test when exact match (not child)
t = template.Template("""
{% load navtag %}
{% nav "courses" %}
{% if nav == "courses!" %}CHILD_MATCH{% endif %}
{% if nav == "courses" %}EXACT_MATCH{% endif %}
""")
content = t.render(template.Context()).strip()
self.assertNotIn("CHILD_MATCH", content)
self.assertIn("EXACT_MATCH", content)
def test_nav_eq_exclude_pattern(self):
"""Test Nav.__eq__ with 'item!exclude' pattern"""
t = template.Template("""
{% load navtag %}
{% nav "courses.special" %}
{% if nav == "courses!list" %}NOT_LIST{% endif %}
{% if nav == "courses!special" %}NOT_SPECIAL{% endif %}
""")
content = t.render(template.Context()).strip()
self.assertIn("NOT_LIST", content)
self.assertNotIn("NOT_SPECIAL", content)
# Test with excluded item
t = template.Template("""
{% load navtag %}
{% nav "courses.list" %}
{% if nav == "courses!list" %}NOT_LIST{% endif %}
{% if nav == "courses!special" %}NOT_SPECIAL{% endif %}
""")
content = t.render(template.Context()).strip()
self.assertNotIn("NOT_LIST", content)
self.assertIn("NOT_SPECIAL", content)
def test_nav_contains_basic(self):
"""Test Nav.__contains__ for component checking"""
t = template.Template("""
{% load navtag %}
{% nav "home" %}
{% if "home" in nav %}HOME_IN{% endif %}
{% if "about" in nav %}ABOUT_IN{% endif %}
""")
content = t.render(template.Context()).strip()
self.assertIn("HOME_IN", content)
self.assertNotIn("ABOUT_IN", content)
def test_nav_contains_hierarchical(self):
"""Test Nav.__contains__ with hierarchical paths"""
t = template.Template("""
{% load navtag %}
{% nav "products.electronics.phones" %}
{% if "products" in nav %}PRODUCTS_IN{% endif %}
{% if "electronics" in nav %}ELECTRONICS_IN{% endif %}
{% if "phones" in nav %}PHONES_IN{% endif %}
{% if "computers" in nav %}COMPUTERS_IN{% endif %}
""")
content = t.render(template.Context()).strip()
self.assertIn("PRODUCTS_IN", content)
self.assertIn("ELECTRONICS_IN", content)
self.assertIn("PHONES_IN", content)
self.assertNotIn("COMPUTERS_IN", content)
def test_nav_contains_empty(self):
"""Test Nav.__contains__ when no navigation is set"""
t = template.Template("""
{% load navtag %}
{% if "home" in nav %}HOME_IN{% endif %}
{% if "about" in nav %}ABOUT_IN{% endif %}
NO_NAV_SET
""")
content = t.render(template.Context()).strip()
self.assertNotIn("HOME_IN", content)
self.assertNotIn("ABOUT_IN", content)
self.assertIn("NO_NAV_SET", content)
def test_navlink_children_only_pattern(self):
"""Test navlink with 'item!' pattern to match children only"""
t = template.Template("""
{% load navtag %}
{% nav text ' class="active"' %}
{% nav "courses.special" %}
{% navlink 'courses' 'courses' %}All Courses{% endnavlink %}
{% navlink 'courses!' 'courses' %}Course Details{% endnavlink %}
{% navlink 'about' 'about' %}About{% endnavlink %}
""")
from django_navtag.templatetags.navtag import NavLinkNode
original_render = NavLinkNode.render
def patched_render(self, context):
# Override URL node rendering
original_url_render = self.url_node.render
self.url_node.render = (
lambda ctx: "/" + self.nav_item.resolve(ctx).split("!")[0] + "/"
)
result = original_render(self, context)
self.url_node.render = original_url_render
return result
NavLinkNode.render = patched_render
try:
content = t.render(template.Context()).strip()
# 'courses' should be active (parent match)
self.assertIn('All Courses ', content)
# 'courses!' should be active (child match)
self.assertIn(
'Course Details ', content
)
# 'about' should be span
self.assertIn("About ", content)
finally:
NavLinkNode.render = original_render
def test_navlink_children_only_pattern_exact_match(self):
"""Test navlink with 'item!' pattern doesn't match exact item"""
t = template.Template("""
{% load navtag %}
{% nav text ' class="active"' %}
{% nav "courses" %}
{% navlink 'courses' 'courses' %}All Courses{% endnavlink %}
{% navlink 'courses!' 'courses' %}Course Details{% endnavlink %}
""")
from django_navtag.templatetags.navtag import NavLinkNode
original_render = NavLinkNode.render
def patched_render(self, context):
# Override URL node rendering
original_url_render = self.url_node.render
self.url_node.render = lambda ctx: "/courses/"
result = original_render(self, context)
self.url_node.render = original_url_render
return result
NavLinkNode.render = patched_render
try:
content = t.render(template.Context()).strip()
# 'courses' should be active (exact match)
self.assertIn('All Courses ', content)
# 'courses!' should NOT be active (requires child)
self.assertIn("Course Details ", content)
finally:
NavLinkNode.render = original_render
def test_navlink_exclude_pattern(self):
"""Test navlink with 'item!exclude' pattern"""
t = template.Template("""
{% load navtag %}
{% nav text ' class="active"' %}
{% nav "courses.special" %}
{% navlink 'courses' 'courses' %}All Courses{% endnavlink %}
{% navlink 'courses!list' 'courses' %}Course (not list){% endnavlink %}
{% navlink 'courses!special' 'courses' %}Course (not special){% endnavlink %}
""")
from django_navtag.templatetags.navtag import NavLinkNode
original_render = NavLinkNode.render
def patched_render(self, context):
# Override URL node rendering
original_url_render = self.url_node.render
self.url_node.render = lambda ctx: "/courses/"
result = original_render(self, context)
self.url_node.render = original_url_render
return result
NavLinkNode.render = patched_render
try:
content = t.render(template.Context()).strip()
# 'courses' should be active (parent match)
self.assertIn('All Courses ', content)
# 'courses!list' should be active (special is not list)
self.assertIn(
'Course (not list) ', content
)
# 'courses!special' should NOT be active (special is excluded)
self.assertIn("Course (not special) ", content)
finally:
NavLinkNode.render = original_render
def test_navlink_exclude_pattern_with_list(self):
"""Test navlink with 'item!exclude' pattern when list is active"""
t = template.Template("""
{% load navtag %}
{% nav text ' class="active"' %}
{% nav "courses.list" %}
{% navlink 'courses' 'courses' %}All Courses{% endnavlink %}
{% navlink 'courses!list' 'courses' %}Course (not list){% endnavlink %}
{% navlink 'courses!special' 'courses' %}Course (not special){% endnavlink %}
""")
from django_navtag.templatetags.navtag import NavLinkNode
original_render = NavLinkNode.render
def patched_render(self, context):
# Override URL node rendering
original_url_render = self.url_node.render
self.url_node.render = lambda ctx: "/courses/"
result = original_render(self, context)
self.url_node.render = original_url_render
return result
NavLinkNode.render = patched_render
try:
content = t.render(template.Context()).strip()
# 'courses' should be active (parent match)
self.assertIn('All Courses ', content)
# 'courses!list' should NOT be active (list is excluded)
self.assertIn("Course (not list) ", content)
# 'courses!special' should be active (list is not special)
self.assertIn(
'Course (not special) ', content
)
finally:
NavLinkNode.render = original_render
def test_nav_iter_basic(self):
"""Test Nav.__iter__ returns active path components"""
t = template.Template("""
{% load navtag %}
{% nav "home" %}
{% for component in nav %}{{ component }}|{% endfor %}
""")
content = t.render(template.Context()).strip()
self.assertEqual(content, "home|")
def test_nav_iter_hierarchical(self):
"""Test Nav.__iter__ with hierarchical paths"""
t = template.Template("""
{% load navtag %}
{% nav "products.electronics.phones" %}
{% for component in nav %}{{ component }}|{% endfor %}
""")
content = t.render(template.Context()).strip()
self.assertEqual(content, "products|electronics|phones|")
def test_nav_iter_empty(self):
"""Test Nav.__iter__ when no navigation is set"""
t = template.Template("""
{% load navtag %}
{% for component in nav %}{{ component }}|{% endfor %}EMPTY
""")
content = t.render(template.Context()).strip()
self.assertEqual(content, "EMPTY")
def test_nav_iter_with_list(self):
"""Test Nav.__iter__ can be converted to list"""
from django_navtag.templatetags.navtag import Nav
nav = Nav()
nav.update({"products": {"electronics": {"phones": True}}})
components = list(nav)
self.assertEqual(components, ["products", "electronics", "phones"])
def test_nav_iter_on_exact_path(self):
"""Test Nav.__iter__ when accessing exact matching path"""
t = template.Template("""
{% load navtag %}
{% nav "products" %}
{% for component in nav.products %}{{ component }}|{% endfor %}END
""")
content = t.render(template.Context()).strip()
# When products is the exact match, nav.products returns True
# We should still be able to iterate (even if empty)
self.assertEqual(content, "END")
django-navtag-3.3.1/pyproject.toml 0000664 0000000 0000000 00000003275 15040033232 0017151 0 ustar 00root root 0000000 0000000 [build-system]
requires = ["setuptools>=77.0", "wheel"]
build-backend = "setuptools.build_meta"
[project]
name = "django-navtag"
version = "3.3.1"
description = "A simple Django navigation template tag"
readme = "README.rst"
authors = [{ name = "Chris Beaven", email = "smileychris@gmail.com" }]
license = "MIT"
keywords = ["django", "templates"]
classifiers = [
"Development Status :: 5 - Production/Stable",
"Environment :: Web Environment",
"Intended Audience :: Developers",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Framework :: Django",
"Framework :: Django :: 3.2",
"Framework :: Django :: 4.2",
"Framework :: Django :: 5.0",
"Framework :: Django :: 5.1",
]
requires-python = ">=3.9"
dependencies = []
[project.urls]
Homepage = "https://github.com/SmileyChris/django-navtag"
[dependency-groups]
dev = [
"tox",
"tox-uv",
"django",
"pytest",
"pytest-django",
"pytest-cov",
"ruff",
"coverage[toml]",
]
[tool.setuptools]
zip-safe = false
include-package-data = true
[tool.setuptools.packages.find]
where = ["."]
include = ["django_navtag*"]
exclude = ["django_navtag.tests*"]
[tool.setuptools.package-data]
django_navtag = ["templates/**/*.txt"]
[tool.setuptools.exclude-package-data]
"*" = ["templates/navtag_tests/**"]
[tool.coverage.run]
source = ["django_navtag"]
[tool.pytest.ini_options]
DJANGO_SETTINGS_MODULE = "django_navtag.tests.settings"
filterwarnings = "module"
django-navtag-3.3.1/tox.ini 0000664 0000000 0000000 00000002335 15040033232 0015544 0 ustar 00root root 0000000 0000000 [tox]
requires = tox>=4
env_list =
py39-django32
py{39,310,311,312}-django42
py{310,311,312}-django{50,51}
lint
coverage
readme
isolated_build = true
skip_missing_interpreters = true
[testenv]
package = editable
deps =
django32: Django>=3.2,<4.0
django42: Django>=4.2,<4.3
django50: Django>=5.0,<5.1
django51: Django>=5.1,<5.2
pytest
pytest-django
pytest-cov
setenv =
DJANGO_SETTINGS_MODULE = django_navtag.tests.settings
commands =
pytest {posargs}
[testenv:lint]
skip_install = true
deps =
ruff
commands =
ruff check {posargs:django_navtag}
ruff format --check {posargs:django_navtag}
[testenv:coverage]
package = editable
deps =
coverage[toml]
pytest
pytest-django
pytest-cov
django
commands =
coverage erase
pytest --cov --cov-append --cov-report=
coverage report --include="django_navtag/tests/*" --fail-under=100
coverage report --omit="django_navtag/tests/*" --fail-under=90 -m
coverage html
[testenv:readme]
skip_install = true
deps =
readme-renderer[md]
docutils
commands =
python -m readme_renderer README.rst -o /dev/null
[gh-actions]
python =
3.9: py39
3.10: py310
3.11: py311
3.12: py312