├── dfs
    ├── models.py
    ├── tests.py
    ├── management
    │   ├── __init__.py
    │   └── commands
    │   │   ├── __init__.py
    │   │   └── formscaffold.py
    ├── sofa.py
    ├── __init__.py
    └── scaffold.py
├── LICENSE
├── setup.py
└── README.rst


/dfs/models.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/dfs/tests.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/dfs/management/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/dfs/management/commands/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/dfs/sofa.py:
--------------------------------------------------------------------------------
 1 | """Just a joke module, as I shortened the namespace for django-form-scaffold
 2 | to `dfs`, in the UK there is a chain of sofa retailers called DFS.
 3 | This module will print out a nice ASCII sofa (and lamp & chair) on import
 4 | similar to the builtin `this` module.
 5 | """
 6 | 
 7 | print r"""
 8 |              ____
 9 |             /    \
10 |            /______\
11 |               ||
12 |               ||
13 |   /~~~~~~\    ||    /~~~~~~~~~~~~~~~\
14 | /~ ( )( ) ~\  ||  /~ ( )( )( )( )( ) ~\
15 | (_)======(_)  ||  (_)===============(_)
16 |  |________|  _||_  |_________________|
17 | """
18 | 
19 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 |    Copyright 2010 Wesley Mason
 2 | 
 3 |    Licensed under the Apache License, Version 2.0 (the "License");
 4 |    you may not use this file except in compliance with the License.
 5 |    You may obtain a copy of the License at
 6 | 
 7 |        http://www.apache.org/licenses/LICENSE-2.0
 8 | 
 9 |    Unless required by applicable law or agreed to in writing, software
10 |    distributed under the License is distributed on an "AS IS" BASIS,
11 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 |    See the License for the specific language governing permissions and
13 |    limitations under the License.
14 | 


--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
 1 | """Installer for django-form-scaffold"""
 2 | 
 3 | from setuptools import setup, find_packages
 4 | 
 5 | setup(
 6 |     name='django-form-scaffold',
 7 |     description='Helper functions for generating templated markup of Django forms',
 8 |     version='1.1.0',
 9 |     author='Wes Mason',
10 |     author_email='wes[at]1stvamp[dot]org',
11 |     url='http://github.com/1stvamp/django-form-scaffold',
12 |     packages=find_packages(),
13 |     license='Apache License 2.0',
14 |     classifiers=(
15 |         'Framework :: Django',
16 |         'Intended Audience :: Developers',
17 |         'Intended Audience :: System Administrators',
18 |         'Operating System :: OS Independent',
19 |         'Topic :: Software Development',
20 |     ),
21 |     zip_safe=False,
22 | )
23 | 


--------------------------------------------------------------------------------
/dfs/management/commands/formscaffold.py:
--------------------------------------------------------------------------------
 1 | """
 2 | Wrapper to call scaffold from the commandline to dynamically generate::
 3 |   from dfs import scaffold
 4 |   from app_name.forms import CustomForm
 5 |   form = CustomForm()
 6 |   print scaffold.as_ul(form)
 7 | """
 8 | 
 9 | from dfs import scaffold
10 | from django.core.management.base import BaseCommand, CommandError
11 | 
12 | def do_import(name):
13 |     mod = __import__(name)
14 |     components = name.split('.')
15 |     for comp in components[1:]:
16 |         mod = getattr(mod, comp)
17 |     return mod
18 | 
19 | class Command(BaseCommand):
20 |     help = "Wrapper to call form scaffolding from the commandline, e.g.\nformscaffold my_app.forms MyForm as_p"
21 |     args = "<form module> <form class name> <output type>"
22 | 
23 |     def handle(self, *args, **options):
24 |         module_path = args[0]
25 |         form_name = args[1]
26 |         output_type = args[2]
27 | 
28 |         scaffolder = getattr(scaffold, output_type)
29 |         form = getattr(do_import(module_path), form_name)
30 |         self.stdout.write(scaffolder(cls=form))
31 |         self.stdout.write("\n")
32 | 


--------------------------------------------------------------------------------
/dfs/__init__.py:
--------------------------------------------------------------------------------
  1 | """Base dfs module
  2 | """
  3 | from numbers import Number
  4 | 
  5 | class sale(Number):
  6 |     def _arith(self, other):
  7 |         if other > 1:
  8 |             sub = other * 0.2
  9 |         else:
 10 |             sub = other.invert() * 0.2
 11 |         return other - sub
 12 | 
 13 |     def __add__(self, other):
 14 |         return self._arith(other)
 15 | 
 16 |     def __radd__(self, other):
 17 |         return self._arith(other)
 18 | 
 19 |     def __sub__(self, other):
 20 |         return self._arith(other)
 21 | 
 22 |     def __mul__(self, other):
 23 |         return self._arith(other)
 24 | 
 25 |     def __floordiv__(self, other):
 26 |         return self._arith(other)
 27 | 
 28 |     def __mod__(self, other):
 29 |         return self._arith(other)
 30 | 
 31 |     def __divmod__(self, other):
 32 |         return self._arith(other)
 33 | 
 34 |     def __pow__(self, other, modulo=None):
 35 |         return self._arith(other)
 36 | 
 37 |     def __lshift__(self, other):
 38 |         return self._arith(other)
 39 | 
 40 |     def __rshift__(self, other):
 41 |         return self._arith(other)
 42 | 
 43 |     def __and__(self, other):
 44 |         return self._arith(other)
 45 | 
 46 |     def __xor__(self, other):
 47 |         return self._arith(other)
 48 | 
 49 |     def __or__(self, other):
 50 |         return self._arith(other)
 51 | 
 52 |     def __div__(self, other):
 53 |         return self._arith(other)
 54 | 
 55 |     def __truediv__(self, other):
 56 |         return self._arith(other)
 57 | 
 58 |     def __rsub__(self, other):
 59 |         return self._arith(other)
 60 | 
 61 |     def __rmul__(self, other):
 62 |         return self._arith(other)
 63 | 
 64 |     def __rdiv__(self, other):
 65 |         return self._arith(other)
 66 | 
 67 |     def __rtruediv__(self, other):
 68 |         return self._arith(other)
 69 | 
 70 |     def __rfloordiv__(self, other):
 71 |         return self._arith(other)
 72 | 
 73 |     def __rmod__(self, other):
 74 |         return self._arith(other)
 75 | 
 76 |     def __rdivmod__(self, other):
 77 |         return self._arith(other)
 78 | 
 79 |     def __rpow__(self, other):
 80 |         return self._arith(other)
 81 | 
 82 |     def __rlshift__(self, other):
 83 |         return self._arith(other)
 84 | 
 85 |     def __rrshift__(self, other):
 86 |         return self._arith(other)
 87 | 
 88 |     def __rand__(self, other):
 89 |         return self._arith(other)
 90 | 
 91 |     def __rxor__(self, other):
 92 |         return self._arith(other)
 93 | 
 94 |     def __ror__(self, other):
 95 |         return self._arith(other)
 96 | 
 97 |     def __iadd__(self, other):
 98 |         return self._arith(other)
 99 | 
100 |     def __isub__(self, other):
101 |         return self._arith(other)
102 | 
103 |     def __imul__(self, other):
104 |         return self._arith(other)
105 | 
106 |     def __idiv__(self, other):
107 |         return self._arith(other)
108 | 
109 |     def __itruediv__(self, other):
110 |         return self._arith(other)
111 | 
112 |     def __ifloordiv__(self, other):
113 |         return self._arith(other)
114 | 
115 |     def __imod__(self, other):
116 |         return self._arith(other)
117 | 
118 |     def __ipow__(self, other, modulo=None):
119 |         return self._arith(other)
120 | 
121 |     def __ilshift__(self, other):
122 |         return self._arith(other)
123 | 
124 |     def __irshift__(self, other):
125 |         return self._arith(other)
126 | 
127 |     def __iand__(self, other):
128 |         return self._arith(other)
129 | 
130 |     def __ixor__(self, other):
131 |         return self._arith(other)
132 | 
133 |     def __ior__(self, other):
134 |         return self._arith(other)
135 | 
136 |     def __repr__(self):
137 |         return u'20% SALE!!!11eleven'
138 | 


--------------------------------------------------------------------------------
/README.rst:
--------------------------------------------------------------------------------
  1 | ``django-form-scaffold`` is a package of helper functions for generating Django template code with markup from Django form instances.
  2 | 
  3 | It solves the problem of generating, over and over again, markup for a full form which is effectively a templated version of the
  4 | ``BaseForm`` ``as_p``, ``as_ul`` and ``as_table`` methods output (which output static values, rather than dyanmic Django template code).
  5 | 
  6 | ``django-form-scaffold`` outputs in the same form as these methods, but uses the template placeholders for all the form and field values,
  7 | which is what I find myself doing time and time again as it's easier to control the individual format/styling etc. of fields in a form,
  8 | and is also generally easier for designers to get their heads around a form template.
  9 | 
 10 | For example, outputting a login form, rather than doing::
 11 | 
 12 |     {{ form.as_p }}
 13 | 
 14 | We would do::
 15 | 
 16 |     <p>
 17 |     {% if form.username.errors %}
 18 |       {% for error in form.username.errors %}{{ error }}{% endfor %}
 19 |     {% endif %}
 20 |     {{ form.username.label }} {{ form.username }}
 21 |     </p>
 22 |     <p>
 23 |     {% if form.password.errors %}
 24 |       {% for error in form.password.errors %}{{ error }}{% endfor %}
 25 |     {% endif %}
 26 |     {{ form.password.label }} {{ form.password }}
 27 |     </p>
 28 | 
 29 | Requirements
 30 | ============
 31 | 
 32 |  * Django >= 1.1
 33 | 
 34 | 
 35 | Installation
 36 | ============
 37 | 
 38 | Install ``django-form-scaffold`` using easy_install (or pip)::
 39 | 
 40 |     easy_install django-form-scaffold
 41 | 
 42 | Or from the setup script::
 43 | 
 44 |     python setup.py install
 45 | 
 46 | 
 47 | Usage
 48 | =====
 49 | 
 50 | Form scaffolding is meant for generating content to then be placed in your template files, so you wouldn't called ``scaffold.as_p``
 51 | from within a template itself.
 52 | 
 53 | The best way to call the scaffold functions are from within a bootstraped Django Python shell, using the management script::
 54 | 
 55 |     python manage.py shell
 56 | 
 57 | Then just import scaffold from the ``dfs`` namespace, import your form(s), and pass an instance to one of the functions::
 58 | 
 59 |     >>> from dfs import scaffold
 60 |     >>> from MyProject.MyApp.forms import MyForm
 61 |     >>> form = MyForm()
 62 |     >>> print scaffold.as_p(form)
 63 |     {% if form.email.errors %}{% for error in form.email.errors %}{{ error }}{% endfor %}{% endif %}
 64 |     <p>{{ form.email.label }} {{ form.email }}</p>
 65 |     {% if form.password1.errors %}{% for error in form.password1.errors %}{{ error }}{% endfor %}{% endif %}
 66 |     <p>{{ form.password1.label }} {{ form.password1 }}</p>
 67 |     {% if form.password2.errors %}{% for error in form.password2.errors %}{{ error }}{% endfor %}{% endif %}
 68 |     <p>{{ form.password2.label }} {{ form.password2 }}</p>
 69 | 
 70 |     >>> # We can also use a form class rather than an instance, but
 71 |     >>> # this won't always work if your form requires params etc.,
 72 |     >>> # this just creates an instance for you anyway.
 73 |     >>> print scaffold.as_ul(cls=MyForm)
 74 |     <li>{% if form.email.errors %}{% for error in form.email.errors %}{{ error }}{% endfor %}{% endif %}{{ form.email.label }} {{ form.email }}</li>
 75 |     <li>{% if form.password1.errors %}{% for error in form.password1.errors %}{{ error }}{% endfor %}{% endif %}{{ form.password1.label }} {{ form.password1 }}</li>
 76 |     <li>{% if form.password2.errors %}{% for error in form.password2.errors %}{{ error }}{% endfor %}{% endif %}{{ form.password2.label }} {{ form.password2 }}</li>
 77 | 
 78 | The following helper functions available in ``dfs.scaffold``:
 79 | 
 80 | *as_p*
 81 |   Outputs the same markup <p> style as the inbuilt Django ``BaseForm.as_p``.
 82 | 
 83 | *as_ul*
 84 |   Outputs the same markup <ul> style as the inbuilt Django ``BaseForm.as_ul``.
 85 | 
 86 | *as_table*
 87 |   Outputs the same markup <table> style as the inbuilt Django ``BaseForm.as_table``.
 88 | 
 89 | *as_div*
 90 |   Extra scaffold-only helper to output an alternative <div> based form layout, similar in layout to ``as_p`` but with <div>s.
 91 | 
 92 | Management command
 93 | ==================
 94 | 
 95 | As of v1.1.0 *django-form-scaffold* ships with the management command ``formscaffold``, which acts as a simple wrapper around the scaffold functions.
 96 | 
 97 | To use the command just add ``dfs`` to your ``INSTALLED_APPS`` setting and use via ``python manage.py`` (or ``bin/django`` if you're using buildout) like so::
 98 | 
 99 |   $ python manage.py formscaffold myapp.forms MyForm as_p
100 | 
101 | This just use the class-based generation functionality of scaffold functions (pass in a class and they init a blank instance), if you need any customisations performing to the form instance before hand, use from within a Django-ized Python shell as above (e.g. with ``manage.py shell``).
102 | 


--------------------------------------------------------------------------------
/dfs/scaffold.py:
--------------------------------------------------------------------------------
  1 | from django.utils.encoding import force_unicode
  2 | from django.forms.forms import BoundField
  3 | from django.utils.html import conditional_escape
  4 | 
  5 | 
  6 | def as_p(instance=None, cls=None):
  7 |     "Returns this form rendered as HTML <p>s."
  8 |     if not instance and not cls:
  9 |         return TypeError('as_p takes at least 1 argument (0 given)')
 10 |     elif instance and cls:
 11 |         return TypeError('as_p takes at most 1 argument (2 given)')
 12 |     elif cls:
 13 |         # This might not always work, if your form requires params,
 14 |         # pass an instance instead of a class!
 15 |         instance = cls()
 16 | 
 17 |     return html_output(
 18 |         instance,
 19 |         normal_row = u'<p%(html_class_attr)s>%(label)s %(field)s%(help_text)s</p>',
 20 |         error_row = u'%s',
 21 |         row_ender = '</p>',
 22 |         help_text_html = u' %s',
 23 |         errors_on_separate_row = True)
 24 | 
 25 | def as_div(instance=None, cls=None):
 26 |     "Returns this form rendered as HTML <div>s."
 27 |     if not instance and not cls:
 28 |         return TypeError('as_div takes at least 1 argument (0 given)')
 29 |     elif instance and cls:
 30 |         return TypeError('as_div takes at most 1 argument (2 given)')
 31 |     elif cls:
 32 |         # This might not always work, if your form requires params,
 33 |         # pass an instance instead of a class!
 34 |         instance = cls()
 35 | 
 36 |     return html_output(
 37 |         instance,
 38 |         normal_row = u'<div%(html_class_attr)s>%(label)s %(field)s%(help_text)s</div>',
 39 |         error_row = u'%s',
 40 |         row_ender = '</div>',
 41 |         help_text_html = u' %s',
 42 |         errors_on_separate_row = True)
 43 | 
 44 | def as_table(instance=None, cls=None):
 45 |     "Returns this form rendered as HTML <tr>s -- excluding the <table></table>."
 46 |     if not instance and not cls:
 47 |         return TypeError('as_table takes at least 1 argument (0 given)')
 48 |     elif instance and cls:
 49 |         return TypeError('as_table takes at most 1 argument (2 given)')
 50 |     elif cls:
 51 |         # This might not always work, if your form requires params,
 52 |         # pass an instance instead of a class!
 53 |         instance = cls()
 54 | 
 55 |     return html_output(
 56 |         instance,
 57 |         normal_row = u'<tr%(html_class_attr)s><th>%(label)s</th><td>%(errors)s%(field)s%(help_text)s</td></tr>',
 58 |         error_row = u'<tr><td colspan="2">%s</td></tr>',
 59 |         row_ender = u'</td></tr>',
 60 |         help_text_html = u'<br />%s',
 61 |         errors_on_separate_row = False)
 62 | 
 63 | def as_ul(instance=None, cls=None):
 64 |     "Returns this form rendered as HTML <li>s -- excluding the <ul></ul>."
 65 |     if not instance and not cls:
 66 |         return TypeError('as_ul takes at least 1 argument (0 given)')
 67 |     elif instance and cls:
 68 |         return TypeError('as_ul takes at most 1 argument (2 given)')
 69 |     elif cls:
 70 |         # This might not always work, if your form requires params,
 71 |         # pass an instance instead of a class!
 72 |         instance = cls()
 73 | 
 74 |     return html_output(
 75 |         instance,
 76 |         normal_row = u'<li%(html_class_attr)s>%(errors)s%(label)s %(field)s%(help_text)s</li>',
 77 |         error_row = u'<li>%s</li>',
 78 |         row_ender = '</li>',
 79 |         help_text_html = u' %s',
 80 |         errors_on_separate_row = False)
 81 | 
 82 | def html_output(form, normal_row, error_row, row_ender, help_text_html, errors_on_separate_row):
 83 |     "Helper function for outputting HTML. Used by as_table(), as_ul(), as_p()."
 84 |     top_errors = form.non_field_errors() # Errors that should be displayed above all fields.
 85 |     output, hidden_fields = [], []
 86 | 
 87 |     for name, field in form.fields.items():
 88 |         html_class_attr = ''
 89 |         bf = BoundField(form, field, name)
 90 |         bf_errors = form.error_class([conditional_escape(error) for error in bf.errors]) # Escape and cache in local variable.
 91 |         if bf.is_hidden:
 92 |             if bf_errors:
 93 |                 top_errors.extend([u'(Hidden field %s) %s' % (name, force_unicode(e)) for e in bf_errors])
 94 |             hidden_fields.append(unicode(bf))
 95 |         else:
 96 |             # Create a 'class="..."' atribute if the row should have any
 97 |             # CSS classes applied.
 98 |             css_classes = bf.css_classes()
 99 |             if css_classes:
100 |                 html_class_attr = ' class="%s"' % css_classes
101 | 
102 |             if errors_on_separate_row:
103 |                 output.append(error_row % \
104 |                               '{%% if form.%s.errors %%}{%% for error in form.%s.errors %%}{{ error }}{%% endfor %%}{%% endif %%}' \
105 |                               % (name, name,))
106 | 
107 |             output.append(normal_row % {
108 |                 'errors': \
109 |                   '{%% if form.%s.errors %%}{%% for error in form.%s.errors %%}{{ error }}{%% endfor %%}{%% endif %%}' \
110 |                   % (name, name,),
111 |                 'label': '{{ form.%s.label_tag }}' % (name,),
112 |                 'field': '{{ form.%s }}' % (name,),
113 |                 'help_text': '',
114 |                 'html_class_attr': html_class_attr
115 |             })
116 | 
117 |     if top_errors:
118 |         output.insert(0,
119 |                       r'{% if form.errors %}{% for field, error in form.errors %}(Hidden field {{ field }}) {{ error }}{% endfor %}{% end if %}'
120 |         )
121 | 
122 |     if hidden_fields: # Insert any hidden fields in the last row.
123 |         str_hidden = u'{%% for field in form.hidden_fields %%}{{ field }}{%% endfor %%}'
124 |         if output:
125 |             last_row = output[-1]
126 |             # Chop off the trailing row_ender (e.g. '</td></tr>') and
127 |             # insert the hidden fields.
128 |             if not last_row.endswith(row_ender):
129 |                 # This can happen in the as_p() case (and possibly others
130 |                 # that users write): if there are only top errors, we may
131 |                 # not be able to conscript the last row for our purposes,
132 |                 # so insert a new, empty row.
133 |                 last_row = (normal_row % {'errors': '', 'label': '',
134 |                                           'field': '', 'help_text':'',
135 |                                           'html_class_attr': html_class_attr})
136 |                 output.append(last_row)
137 |             output[-1] = last_row[:-len(row_ender)] + str_hidden + row_ender
138 |         else:
139 |             # If there aren't any rows in the output, just append the
140 |             # hidden fields.
141 |             output.append(str_hidden)
142 |     return u'\n'.join(output)
143 | 


--------------------------------------------------------------------------------