return {'form':form.render()} # the form just needs rendering
"""
pstruct = peppercorn.parse(controls)
e = None
try:
cstruct = self.deserialize(pstruct)
except colander.Invalid, e:
# fill in errors raised by widgets
self.widget.handle_error(self, e)
cstruct = e.value
try:
appstruct = self.schema.deserialize(cstruct)
except colander.Invalid, e:
# fill in errors raised by schema nodes
self.widget.handle_error(self, e)
if e:
raise exception.ValidationFailure(self, cstruct, e)
return appstruct
def __repr__(self):
return '<%s.%s object at %d (schemanode %r)>' % (
self.__module__,
self.__class__.__name__,
id(self),
self.schema.name,
)
def validate(self, controls):
"""
Validate the set of controls returned by a form submission
against the schema associated with this field or form.
``controls`` should be a *document-ordered* sequence of
two-tuples that represent the form submission data. Each
two-tuple should be in the form ``(key, value)``. ``node``
should be the schema node associated with this widget.
For example, using WebOb, you can compute a suitable value for
``controls`` via::
request.POST.items()
Or, if you're using a ``cgi.FieldStorage`` object named
``fs``, you can compute a suitable value for ``controls``
via::
controls = []
if fs.list:
for control in fs.list:
if control.filename:
controls.append((control.name, control))
else:
controls.append((control.name, control.value))
Equivalent ways of computing ``controls`` should be available to
any web framework.
When the ``validate`` method is called:
- if the fields are successfully validated, a data structure
represented by the deserialization of the data as per the
schema is returned. It will be a mapping.
- If the fields cannot be successfully validated, a
:exc:`deform.exception.ValidationFailure` exception is raised.
The typical usage of ``validate`` in the wild is often
something like this (at least in terms of code found within
the body of a :mod:`pyramid` view function, the particulars
will differ in your web framework)::
from webob.exc import HTTPFound
from deform.exception import ValidationFailure
from deform import schema
from deform.form import Form
from my_application import do_something
class MySchema(schema.MappingSchema):
color = schema.SchemaNode(schema.String())
schema = MySchema()
form = Form(schema)
if 'submit' in request.POST: # the form submission needs validation
controls = request.POST.items()
try:
deserialized = form.validate(controls)
do_something(deserialized)
return HTTPFound(location='http://example.com/success')
except ValidationFailure, e:
return {'form':e.render()}
else:
return {'form':form.render()} # the form just needs rendering
"""
pstruct = peppercorn.parse(controls)
exc = None
try:
cstruct = self.deserialize(pstruct)
except colander.Invalid as e:
# fill in errors raised by widgets
self.widget.handle_error(self, e)
cstruct = e.value
exc = e
try:
appstruct = self.schema.deserialize(cstruct)
except colander.Invalid as e:
# fill in errors raised by schema nodes
self.widget.handle_error(self, e)
exc = e
if exc:
raise exception.ValidationFailure(self, cstruct, exc)
return appstruct