Commits

zzzeek  committed 99fcd1f

initial revision

  • Participants

Comments (0)

Files changed (40)

+include formhelpers/config/deployment.ini_tmpl
+recursive-include formhelpers/public *
+recursive-include formhelpers/templates *
+This file is for you to describe the formhelpers application. Typically
+you would include information such as the information below:
+
+Installation and Setup
+======================
+
+Install ``formhelpers`` using easy_install::
+
+    easy_install formhelpers
+
+Make a config file as follows::
+
+    paster make-config formhelpers config.ini
+
+Tweak the config file as appropriate and then setup the application::
+
+    paster setup-app config.ini
+
+Then you are ready to go.

File development.ini

+#
+# formhelpers - Pylons development environment configuration
+#
+# The %(here)s variable will be replaced with the parent directory of this file
+#
+[DEFAULT]
+debug = true
+# Uncomment and replace with the address which should receive any error reports
+#email_to = you@yourdomain.com
+smtp_server = localhost
+error_email_from = paste@localhost
+
+[server:main]
+use = egg:Paste#http
+host = 0.0.0.0
+port = 5000
+
+[app:main]
+use = egg:formhelpers
+full_stack = true
+cache_dir = %(here)s/data
+beaker.session.key = formhelpers
+beaker.session.secret = somesecret
+
+# If you'd like to fine-tune the individual locations of the cache data dirs
+# for the Cache data, or the Session saves, un-comment the desired settings
+# here:
+#beaker.cache.data_dir = %(here)s/data/cache
+#beaker.session.data_dir = %(here)s/data/sessions
+
+# WARNING: *THE LINE BELOW MUST BE UNCOMMENTED ON A PRODUCTION ENVIRONMENT*
+# Debug mode will enable the interactive debugging tool, allowing ANYONE to
+# execute malicious code after an exception is raised.
+#set debug = false
+
+
+# Logging configuration
+[loggers]
+keys = root, formhelpers
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARN
+handlers = console
+
+[logger_formhelpers]
+level = DEBUG
+handlers =
+qualname = formhelpers
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(asctime)s,%(msecs)03d %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S

File docs/index.txt

+formhelpers
++++++++++++
+
+This is the main index page of your documentation. It should be written in
+`reStructuredText format <http://docutils.sourceforge.net/rst.html>`_.
+
+You can generate your documentation in HTML format by running this command::
+
+    setup.py pudge
+
+For this to work you will need to download and install `buildutils`_,
+`pudge`_, and `pygments`_.  The ``pudge`` command is disabled by
+default; to ativate it in your project, run::
+
+    setup.py addcommand -p buildutils.pudge_command
+
+.. _buildutils: http://pypi.python.org/pypi/buildutils
+.. _pudge: http://pudge.lesscode.org/
+.. _pygments: http://pygments.org/
+#!python
+"""Bootstrap setuptools installation
+
+If you want to use setuptools in your package's setup.py, just include this
+file in the same directory with it, and add this to the top of your setup.py::
+
+    from ez_setup import use_setuptools
+    use_setuptools()
+
+If you want to require a specific version of setuptools, set a download
+mirror, or use an alternate download directory, you can do so by supplying
+the appropriate options to ``use_setuptools()``.
+
+This file can also be run as a script to install or upgrade setuptools.
+"""
+import sys
+DEFAULT_VERSION = "0.6c8"
+DEFAULT_URL     = "http://pypi.python.org/packages/%s/s/setuptools/" % sys.version[:3]
+
+md5_data = {
+    'setuptools-0.6b1-py2.3.egg': '8822caf901250d848b996b7f25c6e6ca',
+    'setuptools-0.6b1-py2.4.egg': 'b79a8a403e4502fbb85ee3f1941735cb',
+    'setuptools-0.6b2-py2.3.egg': '5657759d8a6d8fc44070a9d07272d99b',
+    'setuptools-0.6b2-py2.4.egg': '4996a8d169d2be661fa32a6e52e4f82a',
+    'setuptools-0.6b3-py2.3.egg': 'bb31c0fc7399a63579975cad9f5a0618',
+    'setuptools-0.6b3-py2.4.egg': '38a8c6b3d6ecd22247f179f7da669fac',
+    'setuptools-0.6b4-py2.3.egg': '62045a24ed4e1ebc77fe039aa4e6f7e5',
+    'setuptools-0.6b4-py2.4.egg': '4cb2a185d228dacffb2d17f103b3b1c4',
+    'setuptools-0.6c1-py2.3.egg': 'b3f2b5539d65cb7f74ad79127f1a908c',
+    'setuptools-0.6c1-py2.4.egg': 'b45adeda0667d2d2ffe14009364f2a4b',
+    'setuptools-0.6c2-py2.3.egg': 'f0064bf6aa2b7d0f3ba0b43f20817c27',
+    'setuptools-0.6c2-py2.4.egg': '616192eec35f47e8ea16cd6a122b7277',
+    'setuptools-0.6c3-py2.3.egg': 'f181fa125dfe85a259c9cd6f1d7b78fa',
+    'setuptools-0.6c3-py2.4.egg': 'e0ed74682c998bfb73bf803a50e7b71e',
+    'setuptools-0.6c3-py2.5.egg': 'abef16fdd61955514841c7c6bd98965e',
+    'setuptools-0.6c4-py2.3.egg': 'b0b9131acab32022bfac7f44c5d7971f',
+    'setuptools-0.6c4-py2.4.egg': '2a1f9656d4fbf3c97bf946c0a124e6e2',
+    'setuptools-0.6c4-py2.5.egg': '8f5a052e32cdb9c72bcf4b5526f28afc',
+    'setuptools-0.6c5-py2.3.egg': 'ee9fd80965da04f2f3e6b3576e9d8167',
+    'setuptools-0.6c5-py2.4.egg': 'afe2adf1c01701ee841761f5bcd8aa64',
+    'setuptools-0.6c5-py2.5.egg': 'a8d3f61494ccaa8714dfed37bccd3d5d',
+    'setuptools-0.6c6-py2.3.egg': '35686b78116a668847237b69d549ec20',
+    'setuptools-0.6c6-py2.4.egg': '3c56af57be3225019260a644430065ab',
+    'setuptools-0.6c6-py2.5.egg': 'b2f8a7520709a5b34f80946de5f02f53',
+    'setuptools-0.6c7-py2.3.egg': '209fdf9adc3a615e5115b725658e13e2',
+    'setuptools-0.6c7-py2.4.egg': '5a8f954807d46a0fb67cf1f26c55a82e',
+    'setuptools-0.6c7-py2.5.egg': '45d2ad28f9750e7434111fde831e8372',
+    'setuptools-0.6c8-py2.3.egg': '50759d29b349db8cfd807ba8303f1902',
+    'setuptools-0.6c8-py2.4.egg': 'cba38d74f7d483c06e9daa6070cce6de',
+    'setuptools-0.6c8-py2.5.egg': '1721747ee329dc150590a58b3e1ac95b',
+}
+
+import sys, os
+
+def _validate_md5(egg_name, data):
+    if egg_name in md5_data:
+        from md5 import md5
+        digest = md5(data).hexdigest()
+        if digest != md5_data[egg_name]:
+            print >>sys.stderr, (
+                "md5 validation of %s failed!  (Possible download problem?)"
+                % egg_name
+            )
+            sys.exit(2)
+    return data
+
+
+def use_setuptools(
+    version=DEFAULT_VERSION, download_base=DEFAULT_URL, to_dir=os.curdir,
+    download_delay=15
+):
+    """Automatically find/download setuptools and make it available on sys.path
+
+    `version` should be a valid setuptools version number that is available
+    as an egg for download under the `download_base` URL (which should end with
+    a '/').  `to_dir` is the directory where setuptools will be downloaded, if
+    it is not already available.  If `download_delay` is specified, it should
+    be the number of seconds that will be paused before initiating a download,
+    should one be required.  If an older version of setuptools is installed,
+    this routine will print a message to ``sys.stderr`` and raise SystemExit in
+    an attempt to abort the calling script.
+    """
+    was_imported = 'pkg_resources' in sys.modules or 'setuptools' in sys.modules
+    def do_download():
+        egg = download_setuptools(version, download_base, to_dir, download_delay)
+        sys.path.insert(0, egg)
+        import setuptools; setuptools.bootstrap_install_from = egg
+    try:
+        import pkg_resources
+    except ImportError:
+        return do_download()       
+    try:
+        pkg_resources.require("setuptools>="+version); return
+    except pkg_resources.VersionConflict, e:
+        if was_imported:
+            print >>sys.stderr, (
+            "The required version of setuptools (>=%s) is not available, and\n"
+            "can't be installed while this script is running. Please install\n"
+            " a more recent version first, using 'easy_install -U setuptools'."
+            "\n\n(Currently using %r)"
+            ) % (version, e.args[0])
+            sys.exit(2)
+        else:
+            del pkg_resources, sys.modules['pkg_resources']    # reload ok
+            return do_download()
+    except pkg_resources.DistributionNotFound:
+        return do_download()
+
+def download_setuptools(
+    version=DEFAULT_VERSION, download_base=DEFAULT_URL, to_dir=os.curdir,
+    delay = 15
+):
+    """Download setuptools from a specified location and return its filename
+
+    `version` should be a valid setuptools version number that is available
+    as an egg for download under the `download_base` URL (which should end
+    with a '/'). `to_dir` is the directory where the egg will be downloaded.
+    `delay` is the number of seconds to pause before an actual download attempt.
+    """
+    import urllib2, shutil
+    egg_name = "setuptools-%s-py%s.egg" % (version,sys.version[:3])
+    url = download_base + egg_name
+    saveto = os.path.join(to_dir, egg_name)
+    src = dst = None
+    if not os.path.exists(saveto):  # Avoid repeated downloads
+        try:
+            from distutils import log
+            if delay:
+                log.warn("""
+---------------------------------------------------------------------------
+This script requires setuptools version %s to run (even to display
+help).  I will attempt to download it for you (from
+%s), but
+you may need to enable firewall access for this script first.
+I will start the download in %d seconds.
+
+(Note: if this machine does not have network access, please obtain the file
+
+   %s
+
+and place it in this directory before rerunning this script.)
+---------------------------------------------------------------------------""",
+                    version, download_base, delay, url
+                ); from time import sleep; sleep(delay)
+            log.warn("Downloading %s", url)
+            src = urllib2.urlopen(url)
+            # Read/write all in one block, so we don't create a corrupt file
+            # if the download is interrupted.
+            data = _validate_md5(egg_name, src.read())
+            dst = open(saveto,"wb"); dst.write(data)
+        finally:
+            if src: src.close()
+            if dst: dst.close()
+    return os.path.realpath(saveto)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+def main(argv, version=DEFAULT_VERSION):
+    """Install or upgrade setuptools and EasyInstall"""
+    try:
+        import setuptools
+    except ImportError:
+        egg = None
+        try:
+            egg = download_setuptools(version, delay=0)
+            sys.path.insert(0,egg)
+            from setuptools.command.easy_install import main
+            return main(list(argv)+[egg])   # we're done here
+        finally:
+            if egg and os.path.exists(egg):
+                os.unlink(egg)
+    else:
+        if setuptools.__version__ == '0.0.1':
+            print >>sys.stderr, (
+            "You have an obsolete version of setuptools installed.  Please\n"
+            "remove it from your system entirely before rerunning this script."
+            )
+            sys.exit(2)
+
+    req = "setuptools>="+version
+    import pkg_resources
+    try:
+        pkg_resources.require(req)
+    except pkg_resources.VersionConflict:
+        try:
+            from setuptools.command.easy_install import main
+        except ImportError:
+            from easy_install import main
+        main(list(argv)+[download_setuptools(delay=0)])
+        sys.exit(0) # try to force an exit
+    else:
+        if argv:
+            from setuptools.command.easy_install import main
+            main(argv)
+        else:
+            print "Setuptools version",version,"or greater has been installed."
+            print '(Run "ez_setup.py -U setuptools" to reinstall or upgrade.)'
+
+def update_md5(filenames):
+    """Update our built-in md5 registry"""
+
+    import re
+    from md5 import md5
+
+    for name in filenames:
+        base = os.path.basename(name)
+        f = open(name,'rb')
+        md5_data[base] = md5(f.read()).hexdigest()
+        f.close()
+
+    data = ["    %r: %r,\n" % it for it in md5_data.items()]
+    data.sort()
+    repl = "".join(data)
+
+    import inspect
+    srcfile = inspect.getsourcefile(sys.modules[__name__])
+    f = open(srcfile, 'rb'); src = f.read(); f.close()
+
+    match = re.search("\nmd5_data = {\n([^}]+)}", src)
+    if not match:
+        print >>sys.stderr, "Internal error!"
+        sys.exit(2)
+
+    src = src[:match.start(1)] + repl + src[match.end(1):]
+    f = open(srcfile,'w')
+    f.write(src)
+    f.close()
+
+
+if __name__=='__main__':
+    if len(sys.argv)>2 and sys.argv[1]=='--md5update':
+        update_md5(sys.argv[2:])
+    else:
+        main(sys.argv[1:])
+
+
+
+
+

File formhelpers.egg-info/PKG-INFO

+Metadata-Version: 1.0
+Name: formhelpers
+Version: 0.1dev
+Summary: UNKNOWN
+Home-page: UNKNOWN
+Author: UNKNOWN
+Author-email: UNKNOWN
+License: UNKNOWN
+Description: UNKNOWN
+Platform: UNKNOWN

File formhelpers.egg-info/SOURCES.txt

+MANIFEST.in
+README.txt
+setup.cfg
+setup.py
+formhelpers/__init__.py
+formhelpers/websetup.py
+formhelpers.egg-info/PKG-INFO
+formhelpers.egg-info/SOURCES.txt
+formhelpers.egg-info/dependency_links.txt
+formhelpers.egg-info/entry_points.txt
+formhelpers.egg-info/not-zip-safe
+formhelpers.egg-info/paster_plugins.txt
+formhelpers.egg-info/requires.txt
+formhelpers.egg-info/top_level.txt
+formhelpers/config/__init__.py
+formhelpers/config/deployment.ini_tmpl
+formhelpers/config/environment.py
+formhelpers/config/middleware.py
+formhelpers/config/routing.py
+formhelpers/controllers/__init__.py
+formhelpers/controllers/comment.py
+formhelpers/controllers/error.py
+formhelpers/lib/__init__.py
+formhelpers/lib/app_globals.py
+formhelpers/lib/base.py
+formhelpers/lib/helpers.py
+formhelpers/lib/mako_forms.py
+formhelpers/model/__init__.py
+formhelpers/public/style.css
+formhelpers/templates/comment_form.html
+formhelpers/templates/form_tags.mako
+formhelpers/templates/thanks.html
+formhelpers/tests/__init__.py
+formhelpers/tests/test_models.py
+formhelpers/tests/functional/__init__.py
+formhelpers/tests/functional/test_comment.py

File formhelpers.egg-info/dependency_links.txt

+

File formhelpers.egg-info/entry_points.txt

+
+    [paste.app_factory]
+    main = formhelpers.config.middleware:make_app
+
+    [paste.app_install]
+    main = pylons.util:PylonsInstaller
+    

File formhelpers.egg-info/not-zip-safe

+

File formhelpers.egg-info/paster_plugins.txt

+PasteScript
+Pylons

File formhelpers.egg-info/requires.txt

+Pylons>=0.9.6

File formhelpers.egg-info/top_level.txt

+formhelpers

File formhelpers/__init__.py

Empty file added.

File formhelpers/config/__init__.py

Empty file added.

File formhelpers/config/deployment.ini_tmpl

+#
+# formhelpers - Pylons configuration
+#
+# The %(here)s variable will be replaced with the parent directory of this file
+#
+[DEFAULT]
+debug = true
+email_to = you@yourdomain.com
+smtp_server = localhost
+error_email_from = paste@localhost
+
+[server:main]
+use = egg:Paste#http
+host = 0.0.0.0
+port = 5000
+
+[app:main]
+use = egg:formhelpers
+full_stack = true
+cache_dir = %(here)s/data
+beaker.session.key = formhelpers
+beaker.session.secret = ${app_instance_secret}
+app_instance_uuid = ${app_instance_uuid}
+
+# If you'd like to fine-tune the individual locations of the cache data dirs
+# for the Cache data, or the Session saves, un-comment the desired settings
+# here:
+#beaker.cache.data_dir = %(here)s/data/cache
+#beaker.session.data_dir = %(here)s/data/sessions
+
+# WARNING: *THE LINE BELOW MUST BE UNCOMMENTED ON A PRODUCTION ENVIRONMENT*
+# Debug mode will enable the interactive debugging tool, allowing ANYONE to
+# execute malicious code after an exception is raised.
+set debug = false
+
+
+# Logging configuration
+[loggers]
+keys = root
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = INFO
+handlers = console
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(asctime)s %(levelname)-5.5s [%(name)s] %(message)s

File formhelpers/config/environment.py

+"""Pylons environment configuration"""
+import os
+
+from mako.lookup import TemplateLookup
+from pylons import config
+
+import formhelpers.lib.app_globals as app_globals
+import formhelpers.lib.helpers
+from formhelpers.config.routing import make_map
+from formhelpers.lib.mako_forms import process_tags
+
+def load_environment(global_conf, app_conf):
+    """Configure the Pylons environment via the ``pylons.config``
+    object
+    """
+    # Pylons paths
+    root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    paths = dict(root=root,
+                 controllers=os.path.join(root, 'controllers'),
+                 static_files=os.path.join(root, 'public'),
+                 templates=[os.path.join(root, 'templates')])
+
+    # Initialize config with the basic options
+    config.init_app(global_conf, app_conf, package='formhelpers', paths=paths)
+
+    config['routes.map'] = make_map()
+    config['pylons.app_globals'] = app_globals.Globals()
+    config['pylons.h'] = formhelpers.lib.helpers
+
+    # Create the Mako TemplateLookup, with the default auto-escaping
+    config['pylons.app_globals'].mako_lookup = TemplateLookup(
+        directories=paths['templates'],
+        module_directory=os.path.join(app_conf['cache_dir'], 'templates'),
+        input_encoding='utf-8', output_encoding='utf-8',
+        imports=['from webhelpers.html import escape'],
+        default_filters=['escape'],
+        preprocessor=process_tags  # add "taglib" preprocessor
+        )
+        
+    # CONFIGURATION OPTIONS HERE (note: all config options will override
+    # any Pylons config options)

File formhelpers/config/middleware.py

+"""Pylons middleware initialization"""
+from beaker.middleware import CacheMiddleware, SessionMiddleware
+from paste.cascade import Cascade
+from paste.registry import RegistryManager
+from paste.urlparser import StaticURLParser
+from paste.deploy.converters import asbool
+from pylons import config
+from pylons.middleware import ErrorHandler, StatusCodeRedirect
+from pylons.wsgiapp import PylonsApp
+from routes.middleware import RoutesMiddleware
+
+from formhelpers.config.environment import load_environment
+
+def make_app(global_conf, full_stack=True, **app_conf):
+    """Create a Pylons WSGI application and return it
+
+    ``global_conf``
+        The inherited configuration for this application. Normally from
+        the [DEFAULT] section of the Paste ini file.
+
+    ``full_stack``
+        Whether or not this application provides a full WSGI stack (by
+        default, meaning it handles its own exceptions and errors).
+        Disable full_stack when this application is "managed" by
+        another WSGI middleware.
+
+    ``app_conf``
+        The application's local configuration. Normally specified in the
+        [app:<name>] section of the Paste ini file (where <name>
+        defaults to main).
+    """
+    # Configure the Pylons environment
+    load_environment(global_conf, app_conf)
+
+    # The Pylons WSGI app
+    app = PylonsApp()
+    
+    # CUSTOM MIDDLEWARE HERE (filtered by error handling middlewares)
+    
+    # Routing/Session/Cache Middleware
+    app = RoutesMiddleware(app, config['routes.map'])
+    app = SessionMiddleware(app, config)
+    app = CacheMiddleware(app, config)
+    
+    if asbool(full_stack):
+        # Handle Python exceptions
+        app = ErrorHandler(app, global_conf, **config['pylons.errorware'])
+
+        # Display error documents for 401, 403, 404 status codes (and
+        # 500 when debug is disabled)
+        if asbool(config['debug']):
+            app = StatusCodeRedirect(app)
+        else:
+            app = StatusCodeRedirect(app, [400, 401, 403, 404, 500])
+
+    # Establish the Registry for this application
+    app = RegistryManager(app)
+
+    # Static files (If running in production, and Apache or another web 
+    # server is handling this static content, remove the following 3 lines)
+    static_app = StaticURLParser(config['pylons.paths']['static_files'])
+    app = Cascade([static_app, app])
+    return app

File formhelpers/config/routing.py

+"""Routes configuration
+
+The more specific and detailed routes should be defined first so they
+may take precedent over the more generic routes. For more information
+refer to the routes manual at http://routes.groovie.org/docs/
+"""
+from pylons import config
+from routes import Mapper
+
+def make_map():
+    """Create, configure and return the routes Mapper"""
+    map = Mapper(directory=config['pylons.paths']['controllers'],
+                 always_scan=config['debug'])
+    map.minimization = False
+    
+    # The ErrorController route (handles 404/500 error pages); it should
+    # likely stay at the top, ensuring it can always be resolved
+    map.connect('error/:action/:id', controller='error')
+
+    # CUSTOM ROUTES HERE
+
+    map.connect('/', controller='comment', action='index')
+
+    map.connect('/:controller/index', action='index')
+    map.connect('/:controller/:action/')
+    map.connect('/:controller/:action/:id')
+
+    return map

File formhelpers/controllers/__init__.py

Empty file added.

File formhelpers/controllers/comment.py

+import logging
+
+from pylons import request, response, session
+from pylons import tmpl_context as c
+from pylons.controllers.util import abort
+
+from formhelpers.lib.mako_forms import validate
+
+from formhelpers.lib.base import BaseController, render
+
+log = logging.getLogger(__name__)
+
+import formencode
+
+HEARD_CHOICES = [
+    ('the internet', 'internet'),
+    ('from a friend', 'friend'),
+    ('on the radio (really?)', 'radio'),
+]
+
+class CommentForm(formencode.Schema):
+    allow_extra_fields = True
+    filter_extra_fields = True
+    name = formencode.validators.String(not_empty=True)
+    heard = formencode.validators.OneOf([c[1] for c in HEARD_CHOICES], not_empty=True)
+    comment = formencode.validators.String(not_empty=True)
+
+class CommentController(BaseController):
+    def index(self):
+        if not hasattr(c, 'comment_form'):
+            c.comment_form = CommentForm().from_python({})
+        c.heard_choices = HEARD_CHOICES
+        return render('/comment_form.html')
+
+    @validate("comment_form", CommentForm, input_controller=index)
+    def post(self):
+        c.name = self.form_result['name']
+        return render('/thanks.html')
+        

File formhelpers/controllers/error.py

+import cgi
+import os.path
+
+from paste.urlparser import StaticURLParser
+from pylons import request
+from pylons.controllers.util import forward
+from pylons.middleware import error_document_template, media_path
+
+from formhelpers.lib.base import BaseController
+
+class ErrorController(BaseController):
+    """Generates error documents as and when they are required.
+
+    The ErrorDocuments middleware forwards to ErrorController when error
+    related status codes are returned from the application.
+
+    This behaviour can be altered by changing the parameters to the
+    ErrorDocuments middleware in your config/middleware.py file.
+    
+    """
+    def document(self):
+        """Render the error document"""
+        resp = request.environ.get('pylons.original_response')
+        page = error_document_template % \
+            dict(prefix=request.environ.get('SCRIPT_NAME', ''),
+                 code=cgi.escape(request.GET.get('code', resp.status)),
+                 message=cgi.escape(request.GET.get('message', resp.body)))
+        return page
+
+    def img(self, id):
+        """Serve Pylons' stock images"""
+        return self._serve_file(os.path.join(media_path, 'img'), id)
+
+    def style(self, id):
+        """Serve Pylons' stock stylesheets"""
+        return self._serve_file(os.path.join(media_path, 'style'), id)
+
+    def _serve_file(self, root, path):
+        """Call Paste's FileApp (a WSGI application) to serve the file
+        at the specified path
+        """
+        static = StaticURLParser(root)
+        request.environ['PATH_INFO'] = '/%s' % path
+        return static(request.environ, self.start_response)

File formhelpers/lib/__init__.py

Empty file added.

File formhelpers/lib/app_globals.py

+"""The application's Globals object"""
+
+class Globals(object):
+    """Globals acts as a container for objects available throughout the
+    life of the application
+    """
+
+    def __init__(self):
+        """One instance of Globals is created during application
+        initialization and is available during requests via the 'g'
+        variable
+        """
+        pass

File formhelpers/lib/base.py

+"""The base Controller API
+
+Provides the BaseController class for subclassing.
+"""
+from pylons.controllers import WSGIController
+from pylons.templating import render_mako as render
+
+class BaseController(WSGIController):
+
+    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']
+
+        return WSGIController.__call__(self, environ, start_response)

File formhelpers/lib/helpers.py

+"""Helper functions
+
+Consists of functions to typically be used within templates, but also
+available to Controllers. This module is available to both as 'h'.
+"""
+from webhelpers import *
+
+from routes import url_for
+from webhelpers.html.tags import *

File formhelpers/lib/mako_forms.py

+import logging
+import formencode
+from formencode import variabledecode
+from formhelpers.lib.base import render
+from pylons.decorators import PylonsFormEncodeState
+from pylons.decorators import decorator
+from formencode.variabledecode import variable_decode
+
+import re
+from pylons import tmpl_context
+
+log = logging.getLogger(__name__)
+
+def validate(name, schema, input_controller=None, post_only=True, on_get=False):
+    """Validate input using FormEncode.
+    
+    Given a form name and FormSchema object, this decorator will
+    validate the form, and set the fully validated result
+    dictionary on the controller as ``self.form_result``.
+    
+    In all cases, the original dictionary of parameters is placed
+    on the ``c`` request context using the given name as the
+    attribute name.  If form validation was successful, this will
+    be the result of the ``from_python()`` method of the given 
+    ``FormSchema``, else it will be the original ``request.params``
+    dict.   The form tags in ``form_tags.mako`` are designed to
+    read from this dictionary to get their display values, and the
+    name given to the ``<%form>`` tag in that library should match
+    the name given here.
+    
+    Validation errors are placed in a dictionary at
+    ``self.form_errors`` as well as ``c.form_errors`` - this is the
+    validation dictionary returned from the ``FormSchema``.  When 
+    validation fails, the ``self.form_result`` dictionary is
+    not available.  The ``form_errors`` dictionary is available in all cases
+    even if validation succeeds, and can be directly manipulated
+    by the controller to place error messages which are generated
+    by the controller method itself.
+    
+    An ``input controller`` method is usually specified, which is
+    a reference to a local controller method which will be called
+    if validation fails, instead of the decorated function.  
+    If validation succeeds, a callable 
+    is placed at ``self.on_error()`` which when called with no 
+    arguments will invoke this "input controller".  This allows the
+    controller method to perform additional validation and redirect
+    control to the "error" page (typically after it places messages
+    within the ``form_errors`` dictionary).
+      
+    This function is a focused and enhanced version of Pylons' decorators.validate,
+    intended to be used with form controls that read from the request
+    as well as the ``c.form_errors`` dictionary for reporting errors.
+
+    """
+    state = PylonsFormEncodeState
+        
+    def wrapper(func, self, *args, **kwargs):
+        """Decorator Wrapper function"""
+        request = self._py_object.request
+        errors = {}
+        
+        # switch on GET/POST options
+        if not on_get and request.environ['REQUEST_METHOD'] == 'GET':
+            return func(self, *args, **kwargs)
+            
+        if post_only:
+            params = request.POST
+        else:
+            params = request.params
+        
+        params = params.mixed()
+        decoded = params
+        
+        try:
+            self.form_result = schema.to_python(decoded, state)
+            setattr(tmpl_context, name, schema.from_python(self.form_result, state))
+            
+        except formencode.Invalid, e:
+            errors = e.unpack_errors(variable_decode)
+            setattr(tmpl_context, name, decoded)
+        
+        self.form_errors = tmpl_context.form_errors = errors
+        self.on_error = lambda: input_controller(self, *args, **kwargs)
+        if errors:
+            if not input_controller:
+                return func(self, *args, **kwargs)
+            else:
+                return input_controller(self, *args, **kwargs)
+
+        return func(self, *args, **kwargs)
+    return decorator(wrapper)
+
+tag_regexp = re.compile(r'<(\/)?%(\w+):(\w+)\s*(.*?)(\/)?>', re.S)
+attr_regexp = re.compile(r"\s*(\w+)\s*=\s*(?:(?<!\\)'(.*?)(?<!\\)'|(?<!\\)\"(.*?)(?<!\\)\")")
+expr_regexp = re.compile(r'\${(.+?)}')
+def process_tags(source):
+    """Convert tags of the form <nsname:funcname attrs> into a <%call> tag.
+    
+    This is a quick regexp approach that can be replaced with a full blown XML parsing
+    approach, if desired.
+    
+    """
+    def process_exprs(t):
+        m = re.match(r'^\${(.+?)}$', t)
+        if m:
+            return m.group(1)
+            
+        att = []
+        def replace_expr(m):
+            att.append(m.group(1))
+            return "%s"
+        
+        t = expr_regexp.sub(replace_expr, t)
+        if att:
+            return "'%s' %% (%s)" % (t.replace("'", r"\'"), ",".join(att))
+        else:
+            return "'%s'" % t.replace("'", r"\'")
+        
+    def cvt(match):
+        if bool(match.group(1)):
+            return "</%call>"
+            
+        ns = match.group(2)
+        fname = match.group(3)
+        attrs = match.group(4)
+
+        attrs = dict([(key, process_exprs(val1 or val2)) for key, val1, val2 in attr_regexp.findall(attrs)])
+        args = attrs.pop("args", "")
+
+        attrs = ",".join(["%s=%s" % (key, value) for key, value in attrs.iteritems()])
+        
+        if bool(match.group(5)):
+            return """<%%call expr="%s.%s(%s)" args=%s/>""" % (ns, fname, attrs, args)
+        else:
+            return """<%%call expr="%s.%s(%s)" args=%s>""" % (ns, fname, attrs, args)
+    return tag_regexp.sub(cvt, source)
+

File formhelpers/model/__init__.py

Empty file added.

File formhelpers/public/style.css

+body { background-color: #fff; color: #333; }
+
+body, p {
+  font-family: verdana, arial, helvetica, sans-serif;
+  font-size:   12px;
+  line-height: 18px;
+}
+pre {
+  background-color: #eee;
+  padding: 10px;
+  font-size: 11px;
+  line-height: 13px;
+}
+
+a { color: #000; }
+a:visited { color: #666; }
+a:hover { color: #fff; background-color:#000; }
+
+.error-message{
+    color:red;
+}

File formhelpers/templates/comment_form.html

+<%namespace name="form" file="/form_tags.mako"/>
+
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+   "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<head>
+  <title>Mako Form Helpers</title>
+  <link rel="stylesheet" href="/style.css" type="text/css" />
+</head>
+<body>
+
+<h3>Using Mako Helpers</h3>
+
+<%form:form name="comment_form" controller="comment" action="post">
+<table>
+    <tr>
+        <th colspan="2">Submit your Comment</th>
+    </tr>
+    <tr>
+        <td>Your Name:</td>
+        <td><%form:text name="name"/></td>
+    </tr>
+
+    <tr>
+        <td>How did you hear about this site ?</td>
+        <td>
+            <%form:select name="heard">
+                <%form:option value="">None</%form:option>
+                % for desc, value in c.heard_choices:
+                    <%form:option value="${value}">${desc}</%form:option>
+                % endfor
+            </%form:select>
+        </td>
+    </tr>
+
+    <tr>
+        <td>Comment:</td>
+        <td><%form:textarea name="comment"/></td>
+    </tr>
+
+    <tr>
+        <td colspan="2"><%form:submit/></td>
+    </tr>
+</table>
+</%form:form>
+
+</body>
+</html>

File formhelpers/templates/form_tags.mako

+<%doc>
+    
+    Mako form tag library.
+    
+    Adapts Pylons' webhelpers.html functions into <%defs>.
+
+</%doc>
+
+<%def name="errors(name)">\
+<%doc>
+    Given a field name, produce a stylized error message from the current
+    form_errors collection, if one is present.  Else render nothing.
+</%doc>\
+% if hasattr(c, 'form_errors') and name in c.form_errors:
+<div class="error-message">${c.form_errors[name]}</div>\
+% endif
+</%def>
+
+<%def name="form(name, controller=None, action=None, multipart=False, **attrs)">
+<%doc>
+    Render an HTML <form> tag - the body contents will be rendered within.
+    
+        name - the name of a dictionary placed on 'c' which contains form values.
+        controller - controller to be POSTed to
+        action - action to be POSTed to
+</%doc><%
+    form = getattr(c, name)
+    if not isinstance(form, dict):
+        raise Exception("No form dictionary found at c.%s" % name)
+    c._form = form
+
+    url_kwargs = {'controller':controller, 'action':action}
+    
+%>\
+${h.form(url(**url_kwargs), name=name, multipart=coerce_bool(multipart), **attrs)}\
+${caller.body()}\
+${h.end_form()}\
+<%
+    del c._form
+%></%def>
+
+<%def name="text(name, **attrs)" decorator="render_error">\
+<%doc>
+    Render an HTML <input type="text"> tag.
+</%doc>\
+${h.text(name, value=form_value(c, name), **attrs)}
+</%def>
+
+<%def name="upload(name, **attrs)" decorator="render_error">\
+<%doc>
+    Render an HTML <file> tag.
+</%doc>\
+${h.file(name, **attrs)}
+</%def>
+
+<%def name="hidden(name, **attrs)">\
+<%doc>
+    Render an HTML <input type="hidden"> tag.
+</%doc>\
+${h.hidden(name, value=form_value(c, name), **attrs)}\
+</%def>
+
+<%def name="password(name, **attrs)" decorator="render_error">\
+<%doc>
+    Render an HTML <input type="password"> tag.
+</%doc>\
+${h.password(name, value=form_value(c, name), **attrs)}
+</%def>
+
+<%def name="textarea(name, **attrs)" decorator="render_error">\
+<%doc>
+    Render an HTML <textarea></textarea> tag pair with embedded content.
+</%doc>\
+${h.textarea(name, content=form_value(c, name), **attrs)}
+</%def>
+
+<%def name="select(name, options=None, **kw)" decorator="render_error">\
+<%doc>
+    Render an HTML <select> tag.  Options within the tag
+    are generated using the "option" %def.   Additional
+    items can be passed through the "options" argument -
+    these are rendered after the literal <%options> tags.
+</%doc>\
+<%
+    c._select_options = tuples = []
+    if options is None:
+        options = []
+
+    capture(caller.body)
+
+    selected = form_value(c, name)
+    if not selected:
+        i = 0
+        selected = []
+        while True:
+            v = form_value(c, name + "-%d" % i)
+            if v:
+                selected.append(v)
+                i += 1
+            else:
+                break
+%>\
+${h.select(name, selected, [(t[0], t[1]) for t in tuples] + options, **kw)}\
+<%
+    del c._select_options
+%></%def>
+
+<%def name="option(value)">\
+<%doc>
+    Render an HTML <option> tag.  This is meant to be used with 
+    the "select" %def and produces a special return value specific to
+    usage with that function.
+</%doc>\
+<%
+    c._select_options.append((value, capture(caller.body).strip()))
+%></%def>
+
+<%def name="checkbox(name, value='true')" decorator="render_error">\
+<%doc>
+    Render an HTML <checkbox> tag.  The value is rendered as 'true'
+    by default for usage with the StringBool validator.
+</%doc>
+${h.checkbox(name, value, checked=form_value(c, name) == value)}\
+${errors(name)}
+</%def>
+
+<%def name="radio(name, value)" decorator="render_error">\
+<%doc>
+    Render an HTML <radio> tag.
+</%doc>
+${h.radio(name, value, checked=form_value(c, name) == value)}\
+${errors(name)}
+</%def>
+
+<%def name="submit(value=None, name=None, **kwargs)">\
+<%doc>
+    Render an HTML <submit> tag.
+</%doc>\
+${h.submit(name=name, value=value, **kwargs)}\
+</%def>
+
+<%!
+    from pylons import tmpl_context
+
+    def render_error(fn):
+        """Decorate a form field to render an error message or asterisk."""
+
+        def decorate(context, name, *args, **kw):
+            error_message = get_error_message(context, name)
+
+            fn(name, *args, **kw)
+
+            if error_message:
+                context.write('<span id="%s_error" class="error-message">%s</span>' % (name, error_message))
+            return ''
+
+        return decorate
+
+    def get_error_message(context, name):
+        c = context['c']
+
+        if hasattr(c, 'form_errors') and \
+            name in c.form_errors:
+            error_message = c.form_errors[name]
+        else:
+            error_message = None
+
+        return error_message
+
+    def coerce_bool(arg):
+        if isinstance(arg, basestring):
+            return eval(arg)
+        elif isinstance(arg, bool):
+            return arg
+        else:
+            raise ArgumentError("%r could not be coerced to boolean" % arg)
+    
+    def form_value(c, name):
+        try:
+            return c._form.get(name)
+        except AttributeError:
+            raise Exception("Form tag used without a form "
+                "context present; ensure that c.{form name} is "
+                "populated with a dict, and that this tag is enclosed "
+                "within the %form() tag from this library.")
+%>
+

File formhelpers/templates/thanks.html

+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+   "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<head>
+  <title>Mako Form Helpers</title>
+  <link rel="stylesheet" href="/style.css" type="text/css" />
+</head>
+<body>
+Thanks for your comment, ${c.name} !
+</body>
+</html>

File formhelpers/tests/__init__.py

+"""Pylons application test package
+
+This package assumes the Pylons environment is already loaded, such as
+when this script is imported from the `nosetests --with-pylons=test.ini`
+command.
+
+This module initializes the application via ``websetup`` (`paster
+setup-app`) and provides the base testing objects.
+"""
+from unittest import TestCase
+
+from paste.deploy import loadapp
+from paste.fixture import TestApp
+from paste.script.appinstall import SetupCommand
+from pylons import config
+from routes import url_for
+
+__all__ = ['url_for', 'TestController']
+
+# Invoke websetup with the current config file
+SetupCommand('setup-app').run([config['__file__']])
+
+class TestController(TestCase):
+
+    def __init__(self, *args, **kwargs):
+        wsgiapp = loadapp('config:%s' % config['__file__'])
+        self.app = TestApp(wsgiapp)
+        TestCase.__init__(self, *args, **kwargs)

File formhelpers/tests/functional/__init__.py

Empty file added.

File formhelpers/tests/functional/test_comment.py

+from formhelpers.tests import *
+
+class TestCommentController(TestController):
+
+    def test_index(self):
+        response = self.app.get(url_for(controller='comment'))
+        # Test response...

File formhelpers/tests/test_models.py

Empty file added.

File formhelpers/websetup.py

+"""Setup the formhelpers application"""
+import logging
+
+from formhelpers.config.environment import load_environment
+
+log = logging.getLogger(__name__)
+
+def setup_app(command, conf, vars):
+    """Place any commands to setup formhelpers here"""
+    load_environment(conf.global_conf, conf.local_conf)
+[egg_info]
+tag_build = dev
+tag_svn_revision = true
+
+[easy_install]
+find_links = http://www.pylonshq.com/download/
+
+[nosetests]
+with-pylons=test.ini
+
+# Babel configuration
+[compile_catalog]
+domain = formhelpers
+directory = formhelpers/i18n
+statistics = true
+
+[extract_messages]
+add_comments = TRANSLATORS:
+output_file = formhelpers/i18n/formhelpers.pot
+width = 80
+
+[init_catalog]
+domain = formhelpers
+input_file = formhelpers/i18n/formhelpers.pot
+output_dir = formhelpers/i18n
+
+[update_catalog]
+domain = formhelpers
+input_file = formhelpers/i18n/formhelpers.pot
+output_dir = formhelpers/i18n
+previous = true
+try:
+    from setuptools import setup, find_packages
+except ImportError:
+    from ez_setup import use_setuptools
+    use_setuptools()
+    from setuptools import setup, find_packages
+
+setup(
+    name='formhelpers',
+    version='0.1',
+    description='',
+    author='',
+    author_email='',
+    #url='',
+    install_requires=["Pylons>=0.9.6"],
+    setup_requires=["PasteScript==dev,>=1.6.3dev-r7326"],
+    packages=find_packages(exclude=['ez_setup']),
+    include_package_data=True,
+    test_suite='nose.collector',
+    package_data={'formhelpers': ['i18n/*/LC_MESSAGES/*.mo']},
+    #message_extractors = {'formhelpers': [
+    #        ('**.py', 'python', None),
+    #        ('templates/**.mako', 'mako', None),
+    #        ('public/**', 'ignore', None)]},
+    zip_safe=False,
+    paster_plugins=['PasteScript', 'Pylons'],
+    entry_points="""
+    [paste.app_factory]
+    main = formhelpers.config.middleware:make_app
+
+    [paste.app_install]
+    main = pylons.util:PylonsInstaller
+    """,
+)
+#
+# formhelpers - Pylons testing environment configuration
+#
+# The %(here)s variable will be replaced with the parent directory of this file
+#
+[DEFAULT]
+debug = true
+# Uncomment and replace with the address which should receive any error reports
+#email_to = you@yourdomain.com
+smtp_server = localhost
+error_email_from = paste@localhost
+
+[server:main]
+use = egg:Paste#http
+host = 0.0.0.0
+port = 5000
+
+[app:main]
+use = config:development.ini
+
+# Add additional test specific configuration options as necessary.