Metadata-Version: 1.0
Name: deform
Version: 0.7
Summary: Another form generation library
Home-page: http://www.repoze.org
Author: Agendaless Consulting
Author-email: repoze-dev@lists.repoze.org
License: BSD-derived (http://www.repoze.org/LICENSE.txt)
Description: Deform
        ======
        
        A Python HTML form library.  Please see `http://docs.repoze.org/deform
        <http://docs.repoze.org/deform>`_ for the documentation.
        
        
        
        Changes
        =======
        
        0.7 (2010-10-10)
        ----------------
        
        - Added Danish locale.
        
        - Added Spanish locale:  thanks to David Cerna for the translations!
        
        Features
        ~~~~~~~~
        
        - ``DatePartsWidget`` now renders error "Required" if all blank or
        "Incomplete" if partially blank for consistency with the other widgets.
        
        - Different styling involving <li> and <ul> for checkbox choice,
        checked input, radio choice, checked password, and dateparts widgets
        (via Ergo^). See http://bugs.repoze.org/issue165.
        
        Dependencies
        ~~~~~~~~~~~~
        
        - Deform now depends on ``colander`` version 0.8 or better (the demo
        wants to use schema bindings).
        
        - Deform now depends on ``Chameleon`` (uppercase) rather than
        ``chameleon`` to allow for non-PyPI servers.
        
        Demo
        ~~~~
        
        - New addition to the demonstration application: schema binding.
        
        0.6 (2010-09-03)
        ----------------
        
        Features
        ~~~~~~~~
        
        - Sequence widgets are no longer ``structural`` by default; they now
        print the label of the sequence above the sequence adder.
        
        - Radio buttons in a radio button choice widget are now spaced closer
        together and the button is on the left hand side.
        
        - The sequence remove button is no longer an image.
        
        - The sequence widget now puts the sequence adding link *after* any
        existing items in the sequence (previously the link was always
        beneath the sequence title).
        
        - It is now possible to associate a widget with a schema node within
        the schema directly.  For example::
        
        import colander
        import deform.widget
        
        class MySchema(Schema):
        description = colander.SchemaNode(
        colander.String(),
        widget=deform.widget.RichTextWidget()
        )
        
        For more information, see "Changing the Default Widget Associated
        With a Field" in the documentation.
        
        - The constructor of ``deform.Field`` objects (and thus
        ``deform.Form`` objects) now accept arbitrary keyword arguments,
        each of which is attached to the field or form object being
        constructed, as well as being attached to its descendant fields
        recursively.
        
        - The form object's template now respects the ``css_class`` argument /
        attribute of the form node.
        
        - CheckboxChoice and RadioChoice widgets now use <ul> and <li> to
        display individual choice elements (thanks to Ergo^), and both
        widgets put the label after the element instead of before as
        previously.
        
        - The ``deform.widget.AutocompleteInputWidget`` widget now uses
        `JQuery UI's autocomplete sublibrary
        <http://docs.jquery.com/UI/Autocomplete>` instead of the
        ``jquery.autocomplete`` library to perform its job in order to
        reduce the number of libraries needed by Deform.  Some options have
        been changed as a result, and the set of resources returned by
        ``form.get_widget_resources`` has changed.
        
        This change also implies that when a widget which uses a remote URL
        as a ``values`` input, the remote URL must return a JSON structure
        instead of a ``\n``-delimited list of values.
        
        Requirements
        ~~~~~~~~~~~~
        
        - This Deform version requires ``colander`` version 0.7.3 or better.
        
        Bug Fixes
        ~~~~~~~~~
        
        - ``RichTextWidget``, ``AutocompleteInputWidget``, ``TextInputWidget``
        with input masks, and ``CheckedInputWidget`` with input masks could
        not be used properly within sequences.  Now they can be.  See also
        ``Internal`` and ``Backwards Incompatibilities`` within this
        release's notes.  This necessitated new required ``deform.load()``
        and ``deform.addCallback()`` JavaScript APIs.
        
        - Radio choice widgets included within a submapping no longer put
        their selections on separate lines.
        
        - Rich text widgets are now 500 pixels wide by default instead of 640.
        
        - RadioChoiceWidgets did not work when they were used within
        sequences.  Making them work required some changes to the its
        template and it added a dependency on ``peppercorn`` >= 0.3.
        
        - To make radio choice widgets work within sequences, the
        deform.addSequenceItem JavaScript method needed to be changed.  It
        will now change the value of ``name`` attributes which contain a
        marker that looks like an field oid (e.g. ``deformField1``), and,
        like the code which changes ids in the same manner, appends a random
        component (e.g. ``deformField1-HL6sgP``).  This is to support radio
        button groupings.
        
        - The mapping and sequence item templates now correctly display errors
        with ``msg`` values that are lists.  Previously, a repr of a Python
        list was displayed when a widget had an error with a ``msg`` value
        that was a list; now multiple <p> nodes are inserted into the
        rendering, each <p> node containing an individual error message.
        (Note that this change requires colander 0.7.3).
        
        Backwards Incompatibilities
        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        
        - The JavaScript function ``deform.load()`` now *must* be called by
        the HTML page (usually in a script tag near the end of the page, ala
        ``<script..>deform.load()</script>``) which renders a Deform form in
        order for widgets which use JavaScript to do proper event and
        behavior binding.  If this function is not called, built-in widgets
        which use JavaScript will no longer function properly.
        
        - The JavaScript function ``deformFocusFirstInput`` was removed.  This
        is now implied by ``deform.load()``.
        
        - The ``closebutton_url`` argument to the SequenceWidget no longer
        does anything.  Style the widget template via CSS to add an image.
        
        Internal
        ~~~~~~~~
        
        - Provided better instructions for running the demo app and running
        the tests for the demo app in ``deformdemo/README.txt``.
        
        - Try to prevent false test failures by injecting sleep statements in
        things that use ``browser.key_press``.
        
        - Moved ``deformdemo/tests/test_demo.py`` to ``deformdemo/test.py`` as
        well as moving ``deformdemo/tests/selenium.py`` to
        ``deformdemo/selenium.py``.  Removed the ``deformdemo/tests``
        subdirectory.
        
        - The date input widget now uses JQueryUI's ``datepicker``
        functionality rather than relying on JQuery Tools' ``date`` input.
        The latter was broken for sequences, and the former works fine.
        
        - The various deform* JavaScript functions in ``deform.js`` have now
        been moved into a top-level namespace.  For example, where it was
        necessary to call ``deformFocusFirstInput()`` before, it is now
        necessary to call ``deform.focusFirstInput()``.
        
        - Make the TinyMCE rich text widget use ``mode: 'exact'`` instead of
        ``mode: 'textareas'``.
        
        - ``richtext``, ``autocomplete_input``, ``textinput``,
        ``checked_input``, and ``dateinput``, and ``form`` templates now use
        the new ``deform.addCallback`` indirection instead of each
        registering their own JQuery callback or performing their own
        initialization logic, so that each may be used properly within
        sequences.
        
        - Change sequence adding logic to be slightly simpler.
        
        - The sample app form page now calls ``deform.load()`` rather than
        ``deformFocusFirstInput()``.
        
        - Added new demo app views for showing a sequence of autocompletes, a
        sequence of dateinputs, a sequence of richtext fields, a sequence of
        radio choice widgets and a sequence of text inputs with masks and
        tests for same.
        
        Documentation
        ~~~~~~~~~~~~~
        
        - Added a note about ``get_widget_resources`` to the "Basics"
        chapter.
        
        - Added a note about ``deform.load()`` JavaScript requiredness to the
        "Basics" chapter.
        
        - Add new top-level sections named ``Widget Templates`` and ``Widget
        JavaScript`` to the "Widgets" chapter.
        
        0.5 (2010-08-25)
        ----------------
        
        Features
        ~~~~~~~~
        
        - Added features which make it possible to inquire about which
        resources (JavaScript and CSS resources) are required by all the
        widgets that make up a form rendering.  Also make it possible for a
        newly created widget to specify its requirements.  See "Widget
        Requirements and Resources" in the widgets chapter of the
        documentation.
        
        - Add the ``get_widget_requirements`` method to ``deform.Field``
        objects.
        
        - Add the ``get_widget_resources`` method to ``deform.Field``
        objects.
        
        - Allow ``deform.Field`` (and ``deform.Form``) objects to accept a
        "resource registry" as a constructor argument.
        
        - Add the ``deform.Field.set_widgets`` method, which allows a
        (potentially nested) set of widgets to be applied to children fields
        of the field upon which it is called.
        
        - Add the ``deform.widget.TextInputCSV`` widget.  This widget is
        exactly like the ``deform.widget.TextAreaCSV`` widget except it
        accepts a single line of input only.
        
        - The default widget for ``colander.Tuple`` schema types is now
        ``deform.widget.TextInputCSV``.
        
        - The ``deform.widget.FileUploadWidget`` now returns an instance of
        ``deform.widget.filedict`` instead of a plain dictionary to make it
        possible (using isinstance) to tell the difference between file
        upload data and a plain data dictionary for highly generalized
        persistence code.
        
        0.4 (2010-08-22)
        ----------------
        
        Bug Fixes
        ~~~~~~~~~
        
        - When the hidden widget is used to deserialize a field, return
        ``colander.null`` rather than the empty string so that it may be
        used to represent non-text fields such as ``colander.Integer``.
        This is isomorphic to the change done previously to
        ``deform.TextInputWidget`` to support nontextual empty fields.
        
        - Fix typo about overriding templates using set_zpt_renderer in
        templating chapter.
        
        - Fix link to imperative schema within in Colander docs within "Basics".
        
        - Remove duplicate ``deform.widget.DateInputWidget`` class definition.
        
        Features
        ~~~~~~~~
        
        - Add a ``deform.widget.RichTextWidget`` widget, which adds the
        TinyMCE WYSIWIG javascript editor to a text area.
        
        - Add a ``deform.widget.AutocompleteInputWidget`` widget, which adds
        a text input that can be supplied a URL or iterable of choices to
        ease the search and selection of a finite set of choices.
        
        - The ``deform.widget.Widget`` class now accepts an extra keyword
        argument in its constructor: ``css_class``.
        
        - All widgets now inherit a ``css_class`` attribute from the base
        ``deform.widget.Widget`` class.  If `css_class`` contains a value,
        the "primary" element in the rendered widget will get a CSS
        ``class`` attribute equal to the value ("primary" is defined by the
        widget template's implementor).
        
        - The ``deform.Field`` class now as an ``__iter__`` method which
        iterates over the children fields of the field upon which it is
        called (``for item in field`` == ``for item in field.children``).
        
        0.3 (2010-06-09)
        ----------------
        
        Bug Fixes
        ~~~~~~~~~
        
        - Change default form action to the empty string (rather than ``.``).
        Thanks to Kiran.
        
        Features
        ~~~~~~~~
        
        - Add ``deform.widget.DateInputWidget`` widget, which is a date picker
        widget.  This has now become the default widget for the
        ``colander.Date`` schema type, preferred to the date parts widget.
        
        - Add text input mask capability to ``deform.widget.TextInputWidget``.
        
        - Add text input mask capability to
        ``deform.widget.CheckedInputWidget``.
        
        Backwards Incompatibilities
        ~~~~~~~~~~~~~~~~~~~~~~~~~~~
        
        - Custom widgets must now check for ``colander.null`` rather than
        ``None`` as the null sentinel value.
        
        - Dependency on a new (0.7) version of Colander, which has been
        changed to make using proper defaults possible; if you've used the
        ``default`` argument to a ``colander.SchemaNode``, or if you've
        defined a custom Colander type, you'll want to read `the updated
        Colander documentation <http://docs.repoze.org/colander>`_
        (particularly the changelist).  Short story: use the ``missing``
        argument instead.
        
        - If you've created a custom widget, you will need to tweak it
        slightly to handle the value ``colander.null`` as input to both
        ``serialize`` and ``deserialize``.  See the Deform docs at
        `http://docs.repoze.org/deform <http://docs.repoze.org/deform>`_ for
        more information.
        
        0.2 (2010-05-13)
        ----------------
        
        - Every form has a formid now, defaulting to ``deform``.  The formid
        is used to compute the id of the form tag as well as the button ids
        in the form.  Previously, if a formid was not passed to the Form
        constructor, no id would be given to the rendered form and the
        form's buttons would not be prefixed with any formid.
        
        - The ``deform.Form`` class now accepts two extra keyword arguments in
        its constructor: ``use_ajax`` and ``ajax_options``.
        
        If ``use_ajax`` is ``True``, the page is not reloaded when a submit
        button is pressed.  Instead, the form is posted, and the result
        replaces the DOM node on the page.
        
        ``ajax_options`` is a string which allows you to pass extra options
        to the underlying AJAX form machinery when ``use_ajax`` is True.
        
        - Added a couple Ajax examples to the demo app.
        
        - Add a rudimentary Ajax chapter to the docs.
        
        0.1 (2010-05-09)
        ----------------
        
        - Initial release.
        
Keywords: web forms form generation schema validation
Platform: UNKNOWN
Classifier: Intended Audience :: Developers
Classifier: Programming Language :: Python
