gistfile1.py

"""
For Pylons 0.97, optionally with asplake's Routes fork with {.format} parameter support
1) fill_render(), a render() that encodes repeating groups properly
2) A refactored @validate with
a) JSON support
b) cleaned-up form_errors that render properly in the presence of repeating groups
c) some possibility of extensibility
3) JSON-related helpers: sent_json(), accepts_json(), render_json()
4) formatted_url(), a url() that remembers any format extension on the request
5) BaseSchema, a formencode.Schema with sensible defaults

Further to 2c, validation can be done without the @validator like so:

    def update(self):
        try:
            self._parse(request, schema=MyForm())
            # Here self.form_result is populated as normal
            # as is self.params, the decoded but unconverted form params or
            # json request.  You could do more stuff here that raises
            # formencode.Invalid, validated model updates for example.
        except Invalid as e:
            return self._render_invalid(e, form='edit')
        # Do more stuff with self.form_result, e.g.
        if accepts_json():
            return render_json(json_serialisable_thing_made_from_form_result)
        else:
            return render('template')

See:
[1] @validate revisited, JSON support, content negotiation - http://groups.google.com/group/pylons-discuss/browse_thread/thread/927f4367d5367fc2/c0e325c804680bb6?lnk=gst&q=revisited#c0e325c804680bb6
[2] asplake/routes - http://bitbucket.org/asplake/routes/
[3] Experimental {.format} in Routes - http://positiveincline.com/?p=617
"""
from decorator import decorator
import json
import logging
import formencode
from formencode import htmlfill
from formencode import variabledecode
from formencode.schema import format_compound_error
from pylons import request, response, session, tmpl_context as c, url
from pylons.controllers import WSGIController
from pylons.controllers.util import abort
from pylons.decorators import (PylonsFormEncodeState,
                               determine_response_charset,
                               encode_formencode_errors)
from pylons.templating import render_mako as render
from webob.multidict import UnicodeMultiDict


log = logging.getLogger(__name__)


def fill_render(template_name, values):
    return htmlfill.render(render(template_name),
                           variabledecode.variable_encode(values))

def url_format_extension():
    if 'wsgiorg.routing_args' in request.environ:
        return request.environ['wsgiorg.routing_args'][1].get('format', None)
    else:
        return None

def sent_json():
    return url_format_extension() == 'json' or \
           'application/json' in request.headers.get('content-type', '')

def accepts_json():
    return url_format_extension() == 'json' or \
           'application/json' in request.headers.get('accept', '')

def render_json(thing, **json_options):
    response.headers['Content-Type'] = 'application/json'
    return json.dumps(thing, **json_options)

def formatted_url(*args, **params):
    return url(*args, format=url_format_extension(), **params)


class BaseSchema(formencode.Schema):
    """
    Base form schema
    """
    allow_extra_fields = True
    filter_extra_fields = True
    pre_validators = [variabledecode.NestedVariables()]

    
class BaseController(WSGIController):
    def __init__(self, *args, **kwargs):
        super(BaseController, self).__init__(*args, **kwargs)
        # This is set by the @validate decorator but not defined on the class
        self.form_result = None

    def __call__(self, environ, start_response):
        """Invoke the Controller"""
        # WSGIController.__call__ dispatches to the Controller method
        # the request is routed to. This routing information is
        # available in environ['pylons.routes_dict']
        try:
            return WSGIController.__call__(self, environ, start_response)
        finally:
            meta.Session.remove()

    def _get_decoded(self, variable_decode=False, dict_char='.',
                     list_char='-', post_only=True):
        # If they want post args only, use just the post args
        if post_only:
            if sent_json():
                params = json.loads(request.body)
            else:
                params = request.POST
        else:
            params = request.params

        if hasattr(params, 'mixed'):
            params = params.mixed()

        if variable_decode:
            log.debug("Running variable_decode on params")
            return variabledecode.variable_decode(params, dict_char,
                                                     list_char)
        else:
            return params
    
    def _convert(self, decoded, schema=None, validators=None, state=None,
                 variable_decode=False, dict_char='.', list_char='-'):
        converted = {}
        errors = {}
        if schema:
            log.debug("Validating against a schema")
            try:
                converted = schema.to_python(decoded, state)
            except formencode.Invalid, e:
                errors = e.unpack_errors(variable_decode, dict_char, list_char)
        if validators:
            log.debug("Validating against provided validators")
            if isinstance(validators, dict):
                for field, validator in validators.iteritems():
                    try:
                        converted[field] = \
                            validator.to_python(decoded.get(field), state)
                    except formencode.Invalid, error:
                        errors[field] = error
        # remove cruft
        clean_errors = dict(
            (k, v)
            for k, v in variabledecode.variable_encode(errors).items()
            if v and not k.endswith('--repetitions'))
        return converted, clean_errors
        
    def _parse(self, request, schema=None, validators=None, state=None,
               variable_decode=False, dict_char='.', list_char='-',
               on_get=False, post_only=True):
        if state is None:
            state = PylonsFormEncodeState
        # Skip the validation if on_get is False and its a GET
        if not on_get and request.environ['REQUEST_METHOD'] == 'GET':
            return {}

        self.params = self._get_decoded(
                                variable_decode, dict_char, list_char,
                                post_only)
        self.form_result, self.form_errors = self._convert(
                                self.params, schema, validators, state,
                                variable_decode, dict_char, list_char)
        if self.form_errors:
            raise formencode.Invalid(
                format_compound_error(self.form_errors),
                self.params, state,
                error_dict=self.form_errors) 
        else:
            return self.form_result

    def _render_invalid(self, invalid=None, errors=None, params=None,
                        form=None, htmlfill_kwargs=None,
                        func=None, *args, **kwargs):
        log.debug("Rendering errors found in validation")
        
        if errors is None:
            if invalid and hasattr(invalid, 'unpack_errors'):
                errors = invalid.unpack_errors()
            else:
                errors = self.form_errors

        if params is None:
            params = self.params
            
        if htmlfill_kwargs is None:
            htmlfill_kwargs = {}

        if accepts_json():
            return render_json(dict(errors=errors))

        request.environ['REQUEST_METHOD'] = 'GET'
    
        # If there's no form supplied, just continue with the current
        # function call.
        if not form:
            if func:
                return func(self, *args, **kwargs)
            else:
                raise TypeError("Neither form nor func supplied")
            
        request.environ['pylons.routes_dict']['action'] = form
        response = self._dispatch_call()
        # XXX: Legacy WSGIResponse support
        legacy_response = False
        if hasattr(response, 'content'):
            form_content = ''.join(response.content)
            legacy_response = True
        else:
            form_content = response
            response = self._py_object.response
            
        # If the form_content is an exception response, return it
        if hasattr(form_content, '_exception'):
            return form_content
        
        # Ensure htmlfill can safely combine the form_content, params and
        # errors variables (that they're all of the same string type)
        if not isinstance(params, UnicodeMultiDict):
            log.debug("Raw string form params: ensuring the '%s' form and "
                      "FormEncode errors are converted to raw strings for "
                      "htmlfill", form)
            encoding = determine_response_charset(response)
    
            # WSGIResponse's content may (unlikely) be unicode
            if isinstance(form_content, unicode):
                form_content = form_content.encode(encoding)
    
            # FormEncode>=0.7 errors are unicode (due to being localized
            # via ugettext). Convert any of the possible formencode
            # unpack_errors formats to contain raw strings
            errors = encode_formencode_errors(errors, encoding)
        elif not isinstance(form_content, unicode):
            log.debug("Unicode form params: ensuring the '%s' form is "
                      "converted to unicode for htmlfill", form)
            encoding = determine_response_charset(response)
            form_content = form_content.decode(encoding)
    
        form_content = htmlfill.render(form_content, defaults=params,
                                       errors=errors, **htmlfill_kwargs)
        if legacy_response:
            # Let the Controller merge the legacy response
            response.content = form_content
            return response
        else:
            return form_content

def validate(schema=None, validators=None, form=None, variable_decode=False,
             dict_char='.', list_char='-', post_only=True, state=None,
             on_get=False, **htmlfill_kwargs):
    """The Pylons @validate decorator refactored, with most of the work done
    by controller methods defined on BaseController.  Enhanced to accept JSON.
    
    Validate input either for a FormEncode schema, or individual
    validators

    Given a form schema or dict of validators, validate will attempt to
    validate the schema or validator list.

    If validation was successful, the valid result dict will be saved
    as ``self.form_result``. Otherwise, the action will be re-run as if
    it was a GET, and the output will be filled by FormEncode's
    htmlfill to fill in the form field errors.

    ``schema``
        Refers to a FormEncode Schema object to use during validation.
    ``form``
        Method used to display the form, which will be used to get the 
        HTML representation of the form for error filling.
    ``variable_decode``
        Boolean to indicate whether FormEncode's variable decode
        function should be run on the form input before validation.
    ``dict_char``
        Passed through to FormEncode. Toggles the form field naming 
        scheme used to determine what is used to represent a dict. This
        option is only applicable when used with variable_decode=True.
    ``list_char``
        Passed through to FormEncode. Toggles the form field naming
        scheme used to determine what is used to represent a list. This
        option is only applicable when used with variable_decode=True.
    ``post_only``
        Boolean that indicates whether or not GET (query) variables
        should be included during validation.
        
        .. warning::
            ``post_only`` applies to *where* the arguments to be
            validated come from. It does *not* restrict the form to
            only working with post, merely only checking POST vars.
    ``state``
        Passed through to FormEncode for use in validators that utilize
        a state object.
    ``on_get``
        Whether to validate on GET requests. By default only POST
        requests are validated.

    Example::

        class SomeController(BaseController):

            def create(self, id):
                return render('/myform.mako')

            @validate(schema=model.forms.myshema(), form='create')
            def update(self, id):
                # Do something with self.form_result
                pass

    """
    if state is None:
        state = PylonsFormEncodeState
    def wrapper(func, self, *args, **kwargs):
        """Decorator Wrapper function"""
        request = self._py_object.request
        
        # Skip the validation if on_get is False and its a GET
        if not on_get and request.environ['REQUEST_METHOD'] == 'GET':
            return func(self, *args, **kwargs)
        
        try:
            self._parse(request, schema, validators, state,
               variable_decode, dict_char, list_char, on_get, post_only)
        except formencode.Invalid, e:
            return self._render_invalid(e, self.form_errors, self.params,
                                        form, htmlfill_kwargs,
                                        func, *args, **kwargs)
        return func(self, *args, **kwargs)
    return decorator(wrapper)