djmvc 0.0.1__tar.gz

djmvc-0.0.1/.gitignore

@@ -0,0 +1,7 @@
+__pycache__
+db.sqlite3
+.claude/
+build/
+dist/
+node_modules/
+*egg-info*

djmvc-0.0.1/PKG-INFO

@@ -0,0 +1,167 @@
+Metadata-Version: 2.4
+Name: djmvc
+Version: 0.0.1
+Summary: Django CRUD utilities
+Author-email: Your Name <your.email@example.com>
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: django>=5.1
+Requires-Dist: django-tables2>=2.7
+Requires-Dist: django-crispy-forms>=2.0
+Provides-Extra: bulma
+Requires-Dist: django-crispy-forms>=2.0; extra == "bulma"
+Requires-Dist: crispy-bulma>=0.1; extra == "bulma"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-django>=4.5; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: black>=23.0; extra == "dev"
+Requires-Dist: ruff>=0.1; extra == "dev"
+
+# Faster Django development
+
+Get more out of less with a few design patterns:
+
+- Skip manual URL routing with MVC pattern and sane defaults
+- Dynamic navigation menus with tagged views
+- Skip `get_context_data` overrides by consuming the `view` object directly in
+  templates
+- `{% eval %}` template tag to skip making template tags every time you want to
+  call a function or method (like in Jinja2)
+- Secure by default: views allow only superusers by default, it's up to you to
+  open permissions as-needed.
+
+Install with:
+
+```
+pip install djmvc[bulma]
+```
+
+## Routing
+
+Skip manual URL routing definition by nesting views and controllers:
+
+```python
+from djmvc.controller import Controller
+from djmvc.view import View
+
+
+# definition by sub-classing
+class SubController(Controller):
+    name = 'sub-controller'
+    routes = [
+        View.clone(
+            name='sub-view',
+        )
+    ]
+
+
+# or just define by cloning
+Site = Controller.clone(
+    name='controller',
+    routes=[
+        View.clone(
+            name='view',
+        ),
+        SubController,
+    ]
+)
+
+# define some importable url patterns to include
+urlpatterns = Site().urlpatterns
+
+# it will define reverseable urls
+assert reverse('controller:view') == '/controller/view/'
+assert reverse('controller:sub-controller:sub-view') == '/controller/sub-controller/sub-view/'
+```
+
+## Templates
+
+Ain't no way I'm defining get_context_data for everything I add to a view, I
+consider that adding a method or property to the view should make it directly
+accessible from the template, as such, the default TemplateMixin provides a
+`get_context_data` which already returns the `view` as context object.
+
+```python
+from djmvc.views import generic
+
+class MyView(generic.TemplateView):
+    @property
+    def something(self):
+        return Some.thing()
+```
+
+Allows directly that in the template: `{{ view.something }}`.
+
+Also, ain't no way I'm defining a templatetag for everything, loved the liberty
+Jinja2 gave me, taking it back with Django engine with the eval tag provided by
+djmvc.
+
+```python
+class MyView(generic.TemplateView):
+    def something(self, some_var, user):
+        return Some.thing(some_var, user)
+```
+
+Becomes available as:
+
+```jinja2
+{% load eval %}
+{% eval view.some_method "some test var" view.request.user as result %}
+{{ result }}
+```
+
+## Dynamic menus
+
+Add any tags you like to your views:
+
+```python
+class YourView(generic.TemplateView):
+    tags = ['topbar']
+
+    def has_permission(self):
+        return self.request.user.is_authenticated  # the default
+```
+
+And use the `get_tagged_view()` method of the controller to get all views
+tagged `"topbar"` as such:
+
+```jinja2
+{% eval view.root_controller.get_tagged_views 'topbar' request=request as topbar_menu %}
+```
+
+Here, we're passing the `request` kwarg to `get_tagged_views()` which will
+instanciate the view object with passed kwargs and call `has_permission()`
+prior to returning the tagged view.
+
+It also works with per-object permissions as such:
+
+```python
+class YourModelDetailView(generic.DetailView):
+    tags = ['object']
+
+    def has_permission(self):
+        return (
+            self.request.user.is_superuser
+            or self.object.owner == self.request.user
+        )
+```
+
+Which will make that view show conditionnaly based on the request user, so that
+you can get all the views authorized for a user on a given object in the
+"object" tag as such:
+
+```jinja2
+{% eval view.root_controller.get_tagged_views 'object' request=request object=object as object_menu %}
+```

djmvc-0.0.1/README.md

@@ -0,0 +1,136 @@
+# Faster Django development
+
+Get more out of less with a few design patterns:
+
+- Skip manual URL routing with MVC pattern and sane defaults
+- Dynamic navigation menus with tagged views
+- Skip `get_context_data` overrides by consuming the `view` object directly in
+  templates
+- `{% eval %}` template tag to skip making template tags every time you want to
+  call a function or method (like in Jinja2)
+- Secure by default: views allow only superusers by default, it's up to you to
+  open permissions as-needed.
+
+Install with:
+
+```
+pip install djmvc[bulma]
+```
+
+## Routing
+
+Skip manual URL routing definition by nesting views and controllers:
+
+```python
+from djmvc.controller import Controller
+from djmvc.view import View
+
+
+# definition by sub-classing
+class SubController(Controller):
+    name = 'sub-controller'
+    routes = [
+        View.clone(
+            name='sub-view',
+        )
+    ]
+
+
+# or just define by cloning
+Site = Controller.clone(
+    name='controller',
+    routes=[
+        View.clone(
+            name='view',
+        ),
+        SubController,
+    ]
+)
+
+# define some importable url patterns to include
+urlpatterns = Site().urlpatterns
+
+# it will define reverseable urls
+assert reverse('controller:view') == '/controller/view/'
+assert reverse('controller:sub-controller:sub-view') == '/controller/sub-controller/sub-view/'
+```
+
+## Templates
+
+Ain't no way I'm defining get_context_data for everything I add to a view, I
+consider that adding a method or property to the view should make it directly
+accessible from the template, as such, the default TemplateMixin provides a
+`get_context_data` which already returns the `view` as context object.
+
+```python
+from djmvc.views import generic
+
+class MyView(generic.TemplateView):
+    @property
+    def something(self):
+        return Some.thing()
+```
+
+Allows directly that in the template: `{{ view.something }}`.
+
+Also, ain't no way I'm defining a templatetag for everything, loved the liberty
+Jinja2 gave me, taking it back with Django engine with the eval tag provided by
+djmvc.
+
+```python
+class MyView(generic.TemplateView):
+    def something(self, some_var, user):
+        return Some.thing(some_var, user)
+```
+
+Becomes available as:
+
+```jinja2
+{% load eval %}
+{% eval view.some_method "some test var" view.request.user as result %}
+{{ result }}
+```
+
+## Dynamic menus
+
+Add any tags you like to your views:
+
+```python
+class YourView(generic.TemplateView):
+    tags = ['topbar']
+
+    def has_permission(self):
+        return self.request.user.is_authenticated  # the default
+```
+
+And use the `get_tagged_view()` method of the controller to get all views
+tagged `"topbar"` as such:
+
+```jinja2
+{% eval view.root_controller.get_tagged_views 'topbar' request=request as topbar_menu %}
+```
+
+Here, we're passing the `request` kwarg to `get_tagged_views()` which will
+instanciate the view object with passed kwargs and call `has_permission()`
+prior to returning the tagged view.
+
+It also works with per-object permissions as such:
+
+```python
+class YourModelDetailView(generic.DetailView):
+    tags = ['object']
+
+    def has_permission(self):
+        return (
+            self.request.user.is_superuser
+            or self.object.owner == self.request.user
+        )
+```
+
+Which will make that view show conditionnaly based on the request user, so that
+you can get all the views authorized for a user on a given object in the
+"object" tag as such:
+
+```jinja2
+{% eval view.root_controller.get_tagged_views 'object' request=request object=object as object_menu %}
+```

djmvc-0.0.1/manage.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python
+"""Django's command-line utility for administrative tasks."""
+
+import os
+import sys
+
+
+def main():
+    """Run administrative tasks."""
+    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "djmvc_example.settings")
+    try:
+        from django.core.management import execute_from_command_line
+    except ImportError as exc:
+        raise ImportError(
+            "Couldn't import Django. Are you sure it's installed and "
+            "available on your PYTHONPATH environment variable? Did you "
+            "forget to activate a virtual environment?"
+        ) from exc
+    execute_from_command_line(sys.argv)
+
+
+if __name__ == "__main__":
+    main()

djmvc-0.0.1/pyproject.toml

@@ -0,0 +1,85 @@
+[build-system]
+requires = ["setuptools>=64", "setuptools-scm>=8"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "djmvc"
+dynamic = ["version"]
+description = "Django CRUD utilities"
+readme = "README.md"
+requires-python = ">=3.8"
+license = {text = "MIT"}
+authors = [
+    {name = "Your Name", email = "your.email@example.com"}
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.14",
+]
+dependencies = [
+    "django>=5.1",
+    "django-tables2>=2.7",
+    "django-crispy-forms>=2.0",
+]
+
+[project.optional-dependencies]
+bulma = [
+    "django-crispy-forms>=2.0",
+    "crispy-bulma>=0.1",
+]
+dev = [
+    "pytest>=7.0",
+    "pytest-django>=4.5",
+    "pytest-cov>=4.0",
+    "black>=23.0",
+    "ruff>=0.1",
+]
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["*"]
+namespaces = false
+
+[tool.setuptools_scm]
+# Git-based versioning configuration
+# This will automatically determine the version from git tags
+# Tag format should be: v1.0.0, v0.1.0, etc.
+fallback_version = "0.0.0"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+DJANGO_SETTINGS_MODULE = "djmvc_example.settings"
+pythonpath = ["src/djmvc_example"]
+addopts = [
+    "--reuse-db",
+    "--strict-markers",
+    "-ra",
+]
+markers = [
+    "bulma: marks tests specific to the Bulma frontend",
+    "bootstrap: marks tests specific to the Bootstrap frontend",
+    "django_db: mark test that requires Django database",
+]
+
+[tool.black]
+line-length = 88
+target-version = ['py38']
+include = '\.pyi?$'
+
+[tool.ruff]
+line-length = 88
+target-version = "py38"

djmvc-0.0.1/setup.cfg

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

djmvc-0.0.1/src/djmvc/__init__.py

@@ -0,0 +1,4 @@
+from .controller import Controller
+from .view import View
+from .model import ModelController, ModelMixin
+from .views import generic

djmvc-0.0.1/src/djmvc/admin.py

@@ -0,0 +1,3 @@
+from django.contrib import admin
+
+# Register your models here.

djmvc-0.0.1/src/djmvc/apps.py

@@ -0,0 +1,5 @@
+from django.apps import AppConfig
+
+
+class DjmvcConfig(AppConfig):
+    name = "djmvc"

djmvc-0.0.1/src/djmvc/clonable.py

@@ -0,0 +1,11 @@
+
+
+class Clonable:
+    @classmethod
+    def clone(cls, *mixins, **attributes):
+        """Return a subclass with the given attributes.
+
+        If a model is found, it will prefix the class name with the model.
+        """
+        name = cls.__name__
+        return type(name, (cls,) + mixins, attributes)

djmvc-0.0.1/src/djmvc/controller.py

@@ -0,0 +1,83 @@
+from django.urls import include, path
+
+from .clonable import Clonable
+from .route import Route
+
+
+class Routes(list):
+    def __init__(self, controller, routes):
+        self.controller = controller
+
+        for route in routes:
+            route.controller = self.controller
+
+        routes = [
+            route() if isinstance(route, type) else route
+            for route in routes
+        ]
+
+        super().__init__(routes)
+
+    def __getitem__(self, codename_or_index):
+        try:
+            return super().__getitem__(codename_or_index)
+        except TypeError:
+            for route in self:
+                if route.codename == codename_or_index:
+                    return route
+            raise Exception()
+
+
+class Controller(Clonable, Route):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        if not isinstance(self.routes, Routes):
+            self.routes = Routes(self, self.routes)
+
+    @property
+    def codename(self):
+        return super().codename.replace('controller', '')
+
+    def get_tagged_views(self, tag, **kwargs):
+        def process(controller):
+            views = []
+            for route in controller.routes:
+                if isinstance(route, Controller):
+                    views += process(route)
+                    continue
+
+                if tag not in getattr(route, 'tags', []):
+                    continue
+
+                view = type(route)(**kwargs)
+                if view.has_permission():
+                    views.append(view)
+            return views
+        return process(self)
+
+    @property
+    def root(self):
+        controller = getattr(self, 'controller', None)
+        if not controller:
+            return self
+
+        while hasattr(controller, 'controller'):
+            controller = controller.controller
+        return controller
+
+    @property
+    def urlpatterns(self):
+        patterns = []
+
+        for route in self.routes:
+            patterns += route.urlpatterns
+
+        return [
+            path(
+                self.urlpath,
+                include(
+                    (patterns, self.urlname),
+                    namespace=self.urlname,
+                ),
+            )
+        ]