Pyjoyment 0.1.0__py3-none-any.whl

Pyjoyment/Plugin/EPLRenderer.py

@@ -0,0 +1,134 @@
+"""
+Pyjoyment.Plugin.EPLRenderer - Embedded Python Lite renderer plugin
+===================================================================
+::
+
+    # Pyjoyment
+    app.plugin('EPLRenderer')
+
+    # Pyjoyment.Lite
+    plugin('EPLRenderer')
+
+:mod:`Pyjoyment.Plugin.EPLRenderer` is a renderer for ``epl`` templates,
+which are pretty much just raw :mod:`Pyjo.Template`. The template gets the
+controller as its first argument. ::
+
+    % c = args[0]
+    Hello <%= c.param('name') %>!
+
+This is a core plugin, that means it is always enabled and its code a good
+example for learning to build new plugins, you're welcome to fork it.
+
+See :mod:`Pyjoyment.Plugins` for a list of plugins that are available by
+default.
+
+See also
+--------
+
+:mod:`Pyjoyment`, https://mojolicious.org.
+
+Ported from `Mojolicious::Plugin::EPLRenderer
+<https://github.com/mojolicious/mojo/blob/v9.49/lib/Mojolicious/Plugin/EPLRenderer.pm>`_ of Mojolicious 9.49.
+"""
+
+import Pyjo.Exception
+import Pyjo.Template
+import Pyjoyment.Plugin
+
+from Pyjo.Util import encode, md5_sum
+
+import io
+
+from typing import TYPE_CHECKING, Any
+
+
+if TYPE_CHECKING:
+    import Pyjoyment
+    import Pyjoyment.Controller
+    import Pyjoyment.Renderer
+
+
+class Pyjoyment_Plugin_EPLRenderer(Pyjoyment.Plugin.object):
+    """
+    :mod:`Pyjoyment.Plugin.EPLRenderer` inherits all methods from
+    :mod:`Pyjoyment.Plugin` and implements the following new ones.
+    """
+
+    def register(self, app: 'Pyjoyment.object', conf: dict[str, Any] | None = None) -> None:
+        """::
+
+            plugin.register(Pyjoyment.new())
+
+        Register renderer in :mod:`Pyjoyment` application.
+        """
+        app.renderer.add_handler('epl', _handler)
+
+
+def _handler(
+    renderer: 'Pyjoyment.Renderer.object',
+    c: 'Pyjoyment.Controller.object',
+    output: io.StringIO,
+    options: dict[str, Any],
+) -> None:
+    _render(renderer, c, output, options, Pyjo.Template.new(), c)
+
+
+def _render(
+    renderer: 'Pyjoyment.Renderer.object',
+    c: 'Pyjoyment.Controller.object',
+    output: io.StringIO,
+    options: dict[str, Any],
+    mt: Pyjo.Template.object,
+    *args: Any,
+) -> None:
+    log = c.helpers.log()
+
+    # Cached
+    if mt.compiled is not None:
+        log.trace(f'Rendering cached {mt.name}')
+        result = mt.process(*args)
+
+    # Not cached
+    else:
+        inline = options.get('inline')
+        name = md5_sum(encode('UTF-8', inline)) if inline is not None else renderer.template_name(options)
+        if name is None:
+            return
+
+        # Inline
+        if inline is not None:
+            log.trace(f'Rendering inline template "{name}"')
+            mt.name = f'inline template "{name}"'
+            result = mt.render(inline, *args)
+
+        # File
+        else:
+            if encoding := renderer.encoding:
+                mt.encoding = encoding
+
+            # Try template
+            if (path := renderer.template_path(options)) is not None:
+                log.trace(f'Rendering template "{name}"')
+                mt.name = f'template "{name}"'
+                result = mt.render_file(path, *args)
+
+            # Try DATA section
+            elif (d := renderer.get_data_template(options)) is not None:
+                log.trace(f'Rendering template "{name}" from DATA section')
+                mt.name = f'template "{name}" from DATA section'
+                result = mt.render(d if isinstance(d, str) else d.decode('latin-1'), *args)
+
+            # No template
+            else:
+                log.trace(f'Template "{name}" not found')
+                return
+
+    # Exception
+    if isinstance(result, Pyjo.Exception.object):
+        raise result
+    output.write(result)
+
+
+new = Pyjoyment_Plugin_EPLRenderer.new
+object = Pyjoyment_Plugin_EPLRenderer
+EPLRenderer = Pyjoyment_Plugin_EPLRenderer

Pyjoyment/Plugin/EPRenderer.py

@@ -0,0 +1,212 @@
+"""
+Pyjoyment.Plugin.EPRenderer - Embedded Python renderer plugin
+=============================================================
+::
+
+    # Pyjoyment
+    app.plugin('EPRenderer')
+    app.plugin('EPRenderer', name='foo')
+    app.plugin('EPRenderer', name='bar', template={'line_start': '.'})
+
+    # Pyjoyment.Lite
+    plugin('EPRenderer')
+    plugin('EPRenderer', name='foo')
+    plugin('EPRenderer', name='bar', template={'line_start': '.'})
+
+:mod:`Pyjoyment.Plugin.EPRenderer` is a renderer for Embedded Python
+templates, ``ep``, the default handler of :mod:`Pyjoyment`. They are
+templates of :mod:`Pyjo.Template` with automatic escaping, in which the
+values of the stash are variables, ``self`` and ``c`` are the current
+controller, and the helpers are functions. ::
+
+    % title('Welcome!')
+    <p>Hello <%= name %>, this is <%= url_for('index') %>.</p>
+
+A value of the stash hides a helper of the same name, which is still a
+method of ``c``, as is the helper ``c``, which the variable ``c`` hides. ::
+
+    % c.title('Welcome!')
+    %= c.c('a', 'b', 'c').join(', ')
+
+This is a core plugin, that means it is always enabled and its code a good
+example for learning to build new plugins, you're welcome to fork it.
+
+See :mod:`Pyjoyment.Plugins` for a list of plugins that are available by
+default.
+
+Options
+-------
+
+:mod:`Pyjoyment.Plugin.EPRenderer` supports the following options.
+
+name ::
+
+    # Pyjoyment.Lite
+    plugin('EPRenderer', name='foo')
+
+Handler name, defaults to ``ep``.
+
+template ::
+
+    # Pyjoyment.Lite
+    plugin('EPRenderer', template={'line_start': '.'})
+
+Attribute values passed to :mod:`Pyjo.Template` objects used to render
+templates.
+
+See also
+--------
+
+:mod:`Pyjoyment`, https://mojolicious.org.
+
+Ported from `Mojolicious::Plugin::EPRenderer
+<https://github.com/mojolicious/mojo/blob/v9.49/lib/Mojolicious/Plugin/EPRenderer.pm>`_ of Mojolicious 9.49.
+"""
+
+import Pyjo.Base
+import Pyjo.Exception
+import Pyjo.Template
+import Pyjoyment.Plugin.EPLRenderer
+
+from Pyjo.Util import encode, md5_sum
+
+import io
+import re
+import sys
+import types
+import weakref
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, cast
+
+
+if TYPE_CHECKING:
+    import Pyjoyment
+    import Pyjoyment.Controller
+    import Pyjoyment.Renderer
+
+
+class Pyjoyment_Plugin_EPRenderer(Pyjoyment.Plugin.EPLRenderer.object):
+    """
+    :mod:`Pyjoyment.Plugin.EPRenderer` inherits all methods from
+    :mod:`Pyjoyment.Plugin.EPLRenderer` and implements the following new ones.
+    """
+
+    def register(self, app: 'Pyjoyment.object', conf: dict[str, Any] | None = None) -> None:
+        """::
+
+            plugin.register(Pyjoyment.new())
+            plugin.register(Pyjoyment.new(), {'name': 'foo'})
+
+        Register renderer in :mod:`Pyjoyment` application.
+        """
+        conf = conf or {}
+        self._helpers = False
+
+        # Auto escape by default to prevent XSS attacks
+        ep: dict[str, Any] = {'auto_escape': True, **(conf.get('template') or {}), 'vars': True}
+        ns = ep['namespace'] = ep.get('namespace') or f'Pyjo.Template.Sandbox.{md5_sum(repr(self).encode())}'
+
+        # Unlike Mojolicious: the namespace is a module, which the plugin makes when it is not loaded, and the plugin
+        # removes the names that it adds, where Mojo removes all the names of the package, even of one that the option
+        # "template" names
+        module = sys.modules.get(ns)
+        if module is None:
+            module = sys.modules[ns] = types.ModuleType(ns)
+
+            # No spec, as the module has no source that linecache could read, which warns of a spec without a loader
+            del module.__spec__
+        else:
+            ns = None
+        names: list[str] = []
+        weakref.finalize(self, _teardown, module, names, ns)
+
+        # Make "self" and "c" available in templates
+        ep['prepend'] = 'self = c = _C()' + (f'\n{ep["prepend"]}' if ep.get('prepend') else '')
+
+        # Add "ep" handler and make it the default
+        def handler(
+            renderer: 'Pyjoyment.Renderer.object',
+            c: 'Pyjoyment.Controller.object',
+            output: io.StringIO,
+            options: dict[str, Any],
+        ) -> None:
+            name = options.get('inline')
+            if name is None:
+                name = renderer.template_name(options)
+            if name is None:
+                return
+            key = md5_sum(encode('UTF-8', name))
+
+            cache = renderer.cache
+            if (mt := cache.get(key)) is None:
+                cache.set(key, mt := Pyjo.Template.new(**ep))
+
+            # Export helpers only once
+            if not self._helpers:
+                self._helpers = True
+                _helpers(module, renderer.helpers, names)
+
+            # Make current controller available and render with "epl" handler
+            saved = module.__dict__.get('_C', _MISSING)
+            module.__dict__['_C'] = lambda: c
+            try:
+                Pyjoyment.Plugin.EPLRenderer._render(  # pyright: ignore[reportPrivateUsage]
+                    renderer, c, output, options, cast(Pyjo.Template.object, mt), c.stash()
+                )
+            except Pyjo.Exception.object as e:
+                # Not in Mojolicious: a value of the stash that hides a helper, which Perl tells apart by its sigil
+                if 'object is not callable' in e.message and (
+                    hidden := [k for k, v in c.stash().items() if k in names and not callable(v)]
+                ):
+                    e.message += ''.join(
+                        f', the value "{k}" of the stash hides the helper {k}(), which c.{k}(...) calls' for k in hidden
+                    )
+                raise
+            finally:
+                if saved is _MISSING:
+                    module.__dict__.pop('_C', None)
+                else:
+                    module.__dict__['_C'] = saved
+
+        app.renderer.default_handler = 'ep'
+        app.renderer.add_handler(conf.get('name') or 'ep', handler)
+
+
+_MISSING: Any = Pyjo.Base.object()
+
+
+# A helper of the templates, which the controller of the template calls, and whose missing attribute names the call of
+# the helper, as ua.get_p(...) is a common mistake for ua().get_p(...)
+class _Helper:
+    __slots__ = ('_module', '_name', '_sub')
+
+    def __init__(self, module: types.ModuleType, name: str, sub: Callable[..., Any]) -> None:
+        self._module, self._name, self._sub = module, name, sub
+
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
+        return self._sub(self._module.__dict__['_C'](), *args, **kwargs)
+
+    def __getattr__(self, name: str) -> Any:
+        if name.startswith('_'):
+            raise AttributeError(f"'{type(self).__name__}' object has no attribute '{name}'", name=name, obj=self)
+        message = f'Helper "{self._name}" has no attribute "{name}", call the helper first: {self._name}().{name}'
+        raise AttributeError(message, name=name, obj=self)
+
+
+def _helpers(module: types.ModuleType, helpers: dict[str, Callable[..., Any]], names: list[str]) -> None:
+    for method in [method for method in helpers if re.fullmatch(r'\w+', method)]:
+        setattr(module, method, _Helper(module, method, helpers[method]))
+        names.append(method)
+
+
+def _teardown(module: types.ModuleType, names: list[str], ns: str | None) -> None:
+    for name in [*names, '_C']:
+        module.__dict__.pop(name, None)
+    if ns is not None and sys.modules.get(ns) is module:
+        del sys.modules[ns]
+
+
+new = Pyjoyment_Plugin_EPRenderer.new
+object = Pyjoyment_Plugin_EPRenderer
+EPRenderer = Pyjoyment_Plugin_EPRenderer

Pyjoyment/Plugin/HeaderCondition.py

@@ -0,0 +1,98 @@
+"""
+Pyjoyment.Plugin.HeaderCondition - Header condition plugin
+==========================================================
+::
+
+    # Pyjoyment
+    app.plugin('HeaderCondition')
+    app.get('/foo').requires(headers={'Referer': re.compile(r'example\\.com')})
+
+    # Pyjoyment.Lite
+    plugin('HeaderCondition')
+
+    @get('/').requires(headers={'Referer': re.compile(r'example\\.com')})
+    def index(c): ...
+
+    # All headers need to match
+    app.get('/foo').requires(headers={'X-Secret-Header': 'Foo', 'Referer': re.compile(r'example\\.com')})
+
+    # The "agent" condition is a shortcut for the "User-Agent" header
+    @get('/').requires(agent=re.compile(r'Firefox'))
+    def firefox(c): ...
+
+    # The "host" condition is a shortcut for the detected host
+    @get('/').requires(host=re.compile(r'mojolicious\\.org'))
+    def mojolicious(c): ...
+
+:mod:`Pyjoyment.Plugin.HeaderCondition` is a route condition for header-based
+routes.
+
+This is a core plugin, that means it is always enabled and its code a good
+example for learning to build new plugins, you're welcome to fork it.
+
+See :mod:`Pyjoyment.Plugins` for a list of plugins that are available by
+default.
+
+See also
+--------
+
+:mod:`Pyjoyment`, https://mojolicious.org.
+
+Ported from `Mojolicious::Plugin::HeaderCondition
+<https://github.com/mojolicious/mojo/blob/v9.53/lib/Mojolicious/Plugin/HeaderCondition.pm>`_ of Mojolicious 9.53.
+"""
+
+import Pyjoyment.Plugin
+
+import re
+
+from typing import TYPE_CHECKING, Any, cast
+
+
+if TYPE_CHECKING:
+    import Pyjoyment
+    import Pyjoyment.Controller
+    import Pyjoyment.Routes.Route
+
+
+class Pyjoyment_Plugin_HeaderCondition(Pyjoyment.Plugin.object):
+    """
+    :mod:`Pyjoyment.Plugin.HeaderCondition` inherits all methods from
+    :mod:`Pyjoyment.Plugin` and implements the following new ones.
+    """
+
+    def register(self, app: 'Pyjoyment.object', conf: dict[str, Any] | None = None) -> None:
+        """::
+
+            plugin.register(Pyjoyment.new())
+
+        Register conditions in :mod:`Pyjoyment` application.
+        """
+        app.routes.add_condition('headers', _headers)
+        app.routes.add_condition('agent', lambda r, c, captures, agent: _headers(r, c, captures, {'User-Agent': agent}))
+        app.routes.add_condition('host', lambda r, c, captures, host: _check(c.req.url.to_abs().host, host))
+
+
+def _check(value: str | None, pattern: Any) -> bool:
+    if value and isinstance(pattern, re.Pattern) and cast(re.Pattern[str], pattern).search(value):
+        return True
+    return bool(value) and pattern is not None and pattern == value
+
+
+def _headers(
+    route: 'Pyjoyment.Routes.Route.object', c: 'Pyjoyment.Controller.object', captures: dict[str, Any], patterns: Any
+) -> bool:
+    if not patterns or not isinstance(patterns, dict):
+        return False
+
+    # All headers need to match
+    headers = c.req.headers
+    for name, pattern in cast(dict[str, Any], patterns).items():
+        if not _check(headers.header(name), pattern):
+            return False
+    return True
+
+
+new = Pyjoyment_Plugin_HeaderCondition.new
+object = Pyjoyment_Plugin_HeaderCondition
+HeaderCondition = Pyjoyment_Plugin_HeaderCondition