fabiommendes/hyperpython

from functools import wraps

from markupsafe import Markup
from sidekick import import_later, Proxy

from .core import Text, Element, Block, Blob
from .utils.role_dispatch import role_singledispatch, error

django_loader = import_later("django.template.loader")


def render(obj, role=None, **kwargs):
    """
    Like :func:`render`, but return a string of HTML code instead of a
    Hyperpython object.
    """
    return html(obj, role=role, **kwargs).__html__()


@role_singledispatch
def html(obj, role=None, **kwargs):
    """
    Convert object into a hyperpython structure.

    Args:
        obj:
            Input object.
        role:
            Optional description

        Additional context variables for the rendering process can be passed as
        keyword arguments.

    Returns:
        A hyperpython object.
    """
    # Try the html_role interface.
    try:
        method = obj.html_role
    except AttributeError:
        pass
    else:
        return method(role=role, **kwargs)

    # If role is given, we adopt a more strict behavior
    if role is not None:
        raise error(type(obj), role)

    # Fallback to __html__ or string renderers for role-less calls
    try:
        raw = obj.__html__()
    except AttributeError:
        return Text(str(obj))
    else:
        return Blob(raw)


#
# Auxiliary functions
#
def register_template(cls, template, role=None):
    """
    Decorator that registers a template-based renderer.

    (Currently, only Django is supported).

    Args:
        cls:
            Type of input object.
        template:
            Template name or list of template names.
        role:
            Optional role for the template.

    Examples:
        The decorated function must receive an instance of `cls` as first
        argument and any number of keyword arguments. It should return a context
        dictionary that is passed to the template to render the final HTML
        string.

        @render.register_template(User, 'users/user-contact.html', 'contact')
        def user_contact(user, **kwargs):
            return {
                'name': user.name,
                'email': user.get_public_email(),
                # ...
            }

        The role can be omitted to register a fallback implementation for the
        given model. The fallback receives the passed role as a keyword
        argument.

        @render.register_template(User, 'users/user-generic.html')
        def user_contact(user, role=None, **kwargs):
            return {
                'user': user,
                'role': role,
            }
    """
    template = django_loader.get_template(template)
    renderer = template.render

    def decorator(func):
        @html.register(cls, role)
        def wrapped(obj, **kwargs):
            ctx = func(obj, **kwargs)
            request = ctx.get("request")
            data = renderer(context=ctx, request=request)
            return Blob(data)

        return wrapped

    return decorator


html.register_template = register_template


#
# Register default renderers
#
def no_role(func):
    @wraps(func)
    def wrapped(x, role=None, **kwargs):
        if role is None:
            return func(x, **kwargs)
        raise error(type(x), role)

    return wrapped


html.register(Markup)(no_role(lambda x: Blob(x)))
html.register(str)(no_role(lambda x: Text(x)))
html.register(Proxy)(lambda x, **kwargs: html(x._obj__, **kwargs))

for _cls in (Element, Text, Block):
    html.register(_cls)(no_role(lambda x: x))