Changeset 16384


Ignore:
Timestamp:
Mar 25, 2017, 12:31:47 AM (3 years ago)
Author:
Ryan J Ollos
Message:

TracForms 0.5dev: Conform to PEP8

Location:
tracformsplugin/trunk
Files:
15 edited

Legend:

Unmodified
Added
Removed

  • tracformsplugin/trunk/setup.py

    r15445 r16384  
     1#!/usr/bin/env python
    12# -*- coding: utf-8 -*-
    23
    … …  
    67
    78try:
    8     from trac.util.dist  import  get_l10n_cmdclass
     9    from trac.util.dist import get_l10n_cmdclass
     10
    911    cmdclass = get_l10n_cmdclass()
    1012    if cmdclass:
    1113        extra['cmdclass'] = cmdclass
    1214        extractors = [
    13             ('**.py',                'python', None),
     15            ('**.py', 'python', None),
    1416            ('**/templates/**.html', 'genshi', None),
    1517        ]
    … …  
    2123    pass
    2224
    23 
    2425VERSION = '0.5'
    2526
    2627setup(
    27     name = 'TracForms',
    28     description = 'Universal form provider for tickets and wiki',
    29     version = VERSION,
     28    name='TracForms',
     29    description='Universal form provider for tickets and wiki',
     30    version=VERSION,
    3031    author='Rich Harkins',
    3132    author_email='rich@worldsinfinite.com',
    32     maintainer = 'Steffen Hoffmann',
    33     maintainer_email = 'hoff.st@web.de',
    34     url = 'http://trac-hacks.org/wiki/TracFormsPlugin',
    35     license = 'GPL',
    36     packages = ['tracforms'],
    37     package_data = {
     33    maintainer='Steffen Hoffmann',
     34    maintainer_email='hoff.st@web.de',
     35    url='https://trac-hacks.org/wiki/TracFormsPlugin',
     36    license='GPL',
     37    packages=['tracforms'],
     38    package_data={
    3839        'tracforms': [
    3940            'htdocs/*', 'locale/*/LC_MESSAGES/*.mo', 'locale/.placeholder',
    … …  
    4142        ]
    4243    },
    43     zip_safe = True,
    44     install_requires = ['Trac >= 0.11'],
    45     extras_require = {'Babel': 'Babel>= 0.9.5', 'Trac': 'Trac >= 0.12'},
    46     entry_points = {
     44    zip_safe=True,
     45    install_requires=['Trac'],
     46    extras_require={'Babel': 'Babel>= 0.9.5'},
     47    entry_points={
    4748        'trac.plugins': [
    4849            'tracforms.api = tracforms.api',

  • tracformsplugin/trunk/tracforms/__init__.py

    r9924 r16384  
     1import pkg_resources
     2pkg_resources.require('Trac >= 1.0')

  • tracformsplugin/trunk/tracforms/api.py

    r11137 r16384  
    11# -*- coding: utf-8 -*-
    22
    3 from genshi.builder import Markup, tag
     3from urllib import unquote_plus
     4
    45from pkg_resources import resource_filename
    5 from urllib import unquote_plus
    66
    77from trac.core import Component, ExtensionPoint, Interface, implements
    88from trac.perm import IPermissionRequestor
    9 from trac.resource import IResourceManager, Resource, ResourceNotFound, \
     9from trac.resource import IResourceManager, ResourceNotFound, \
    1010                          get_resource_name, get_resource_shortname, \
    1111                          get_resource_url
    12 
    13 # Import i18n methods.  Fallback modules maintain compatibility to Trac 0.11
    14 # by keeping Babel optional here.
    15 try:
    16     from trac.util.translation import domain_functions
    17     add_domain, _, tag_ = \
    18         domain_functions('tracforms', ('add_domain', '_', 'tag_'))
    19     dgettext = None
    20 except ImportError:
    21     from genshi.builder import tag as tag_
    22     from trac.util.translation import gettext
    23     _ = gettext
    24     def add_domain(a,b,c=None):
    25         pass
    26     def dgettext(domain, string, **kwargs):
    27         return safefmt(string, kwargs)
    28     def safefmt(string, kwargs):
    29         if kwargs:
    30             try:
    31                 return string % kwargs
    32             except KeyError:
    33                 pass
    34         return string
    35 
     12from trac.util.html import Markup, tag
     13from trac.util.translation import domain_functions
    3614from trac.web import IRequestHandler
    37 from trac.web.api import HTTPBadRequest, HTTPUnauthorized
    38 
    39 # Import AccountManagerPlugin methods, if plugin is installed.
     15from trac.web.api import HTTPBadRequest
     16
    4017try:
    4118    from acct_mgr.api import IPasswordStore
    42     can_check_user = True
    4319except ImportError:
    4420    can_check_user = False
    45 
     21else:
     22    can_check_user = True
    4623from compat import json
     24
     25add_domain, _, tag_ = \
     26    domain_functions('tracforms', ('add_domain', '_', 'tag_'))
     27dgettext = None
    4728
    4829
    … …  
    6445    def form_deleted(form):
    6546        """Called when a form is deleted."""
    66     # DEVEL: not implemented yet
     47        # DEVEL: not implemented yet
    6748
    6849
    … …  
    8465
    8566    def save_tracform(self, src, state, updater,
    86                         base_version=None, keep_history=False,
    87                         track_fields=False, cursor=None):
     67                      base_version=None, keep_history=False,
     68                      track_fields=False, cursor=None):
    8869        pass
    8970
    … …  
    9576
    9677    def reset_tracform(self, src, field=None, author=None, step=0,
    97                         cursor=None):
     78                       cursor=None):
    9879        pass
    9980
    … …  
    10687        def builder(fn):
    10788            return tracob_first(fn, default)
     89
    10890        return builder
    10991    else:
    … …  
    11698            else:
    11799                return default
     100
    118101        wrapper.__name__ = fn.__name__
    119102        wrapper.__doc__ = fn.__doc__
    … …  
    203186                 tag.a(parent_name, href=parent_url) or parent_name
    204187        # DEVEL: resource description not implemented yet
    205         #if format == 'summary':
     188        # if format == 'summary':
    206189        #    return Form(self.env, resource).description
    207190        if resource.id:
    … …  
    211194            # TRANSLATOR: Most verbose title, i.e. for form history page
    212195            return tag(Markup(_("Form %(form_id)s (in %(parent)s)",
    213                         form_id=resource.id, parent=parent)))
     196                                form_id=resource.id, parent=parent)))
    214197        else:
    215198            # TRANSLATOR: Title printed i.e. in form select page
    … …  
    220203    def get_resource_url(self, resource, href, **kwargs):
    221204        # use parent's url instead
    222         return get_resource_url(self.env, resource.parent, href)       
     205        return get_resource_url(self.env, resource.parent, href)
    223206
    224207    def resource_exists(self, resource):
    225208        try:
    226209            if get_tracform_meta(resource.id)[1] is not None:
    227                return True
     210                return True
    228211        except ResourceNotFound:
    229212            return False
    … …  
    258241            backpath = args.pop('__backpath__', None)
    259242            context = json.loads(unquote_plus(
    260                           args.pop('__context__', '[null, null, null]')))
     243                args.pop('__context__', '[null, null, null]')))
    261244            if None in context:
    262245                # TRANSLATOR: HTTP error message
    … …  
    279262            result = json.dumps(args, separators=(',', ':'))
    280263            self.save_tracform(context, result, who, basever,
    281                                 keep_history=keep_history,
    282                                 track_fields=track_fields)
     264                               keep_history=keep_history,
     265                               track_fields=track_fields)
    283266            buffer = 'OK'
    284267            if backpath is not None:
    … …  
    302285            req.end_headers()
    303286            req.write(buffer)
    304 

  • tracformsplugin/trunk/tracforms/compat.py

    r10484 r16384  
    11# -*- coding: utf-8 -*-
    22
    3 # 2011 Steffen Hoffmann
    4 
    5 """Various classes and functions to provide backwards-compatibility with
    6 previous versions of Python from 2.4 onward.
    7 """
    8 
    9 # json was introduced in 2.6, use simplejson for older versions
    10 # parse_qs was copied to urlparse and deprecated in cgi in 2.6
    11 import sys
    12 if sys.version_info[0] == 2 and sys.version_info[1] > 5:
     3try:
    134    import json
    14     from urlparse import parse_qs
    15 else:
     5except ImportError:
    166    import simplejson as json
    17     from cgi import parse_qs
    18 
    19 # A Trac issue rather than a Python one:
    20 # Provide `resource_exists`, that has been backported to Trac 0.11.8 only.
    21 try:
    22     from trac.resource import resource_exists
    23 except ImportError:
    24     from trac.resource import ResourceSystem
    25     def resource_exists(env, resource):
    26         """Checks for resource existence without actually instantiating a
    27         model.
    28 
    29         :return: `True` if the resource exists, `False` if it doesn't
    30         and `None` in case no conclusion could be made (i.e. when
    31         `IResourceManager.resource_exists` is not implemented).
    32         """
    33         manager = ResourceSystem(env).get_resource_manager(resource.realm)
    34         if manager and hasattr(manager, 'resource_exists'):
    35             return manager.resource_exists(resource)
    36         elif resource.id is None:
    37             return False
    38 

  • tracformsplugin/trunk/tracforms/environment.py

    r10044 r16384  
    4242
    4343    def __init__(self, base=None, prefixes=()):
     44        super(FormEnvironment, self).__init__()
    4445        if base is not None:
    4546            self.update(base)
    … …  
    4748        self.prefixes = prefixes + ('',)
    4849
    49     def __getitem__(self, key, NOT_FOUND=KeyError):
    50         obj = self.get(key, NOT_FOUND)
    51         if obj is NOT_FOUND:
     50    def __getitem__(self, key, default=KeyError):
     51        obj = self.get(key, default)
     52        if obj is default:
    5253            raise KeyError(key)
    5354        else:
    … …  
    5657    def get(self, search, default=None, singleton=True, all=False):
    5758        values = tuple(dict.__getitem__(self, key)
    58                         for key in sorted(self.keyset(search, all)))
     59                       for key in sorted(self.keyset(search, all)))
    5960        if singleton:
    6061            if not values:
    … …  
    9394
    9495    _sorted = None
     96
    9597    @property
    9698    def sorted_keys(self):
    … …  
    108110            for key in keys:
    109111                self[key] = tuple(value)
    110 

  • tracformsplugin/trunk/tracforms/errors.py

    r10079 r16384  
    3333
    3434    message = _("ERROR: No TracForms command '%r'")
    35 

  • tracformsplugin/trunk/tracforms/formdb.py

    r11137 r16384  
    11# -*- coding: utf-8 -*-
    22
    3 #import copy
    43import re
    54import time
    6 import unittest
     5import urlparse
    76
    87from trac.config import BoolOption, ListOption, Option
    9 from trac.core import Component, implements
     8from trac.core import implements
    109from trac.db import Column, DatabaseManager, Index, Table
    11 from trac.resource import Resource
     10from trac.resource import Resource, resource_exists
    1211from trac.search.api import search_to_sql
    1312from trac.web.chrome import Chrome
    1413
    1514from api import IFormDBObserver, _
    16 from compat import json, parse_qs, resource_exists
     15from compat import json
    1716from tracdb import DBComponent
    1817from util import is_number, parse_history, resource_from_page, xml_unescape
    … …  
    9190        cursor = db.cursor()
    9291        sql = """
    93             SELECT  id,
    94                     realm,
    95                     resource_id,
    96                     subcontext,
    97                     author,
    98                     time,
    99                     keep_history,
    100                     track_fields
    101             FROM    forms
    102             """
     92                SELECT id, realm, resource_id, subcontext, author, time,
     93                       keep_history, track_fields
     94                FROM forms
     95                """
    10396        if not is_number(src):
    10497            sql += """
    … …  
    119112        else:
    120113            form_id = src
    121             src = tuple([src],)
     114            src = tuple([src], )
    122115        cursor.execute(sql, src)
    123116        return cursor.fetchone() or \
    … …  
    142135                WHERE   id=%s
    143136                """
    144             src = tuple([src],)
     137            src = tuple([src], )
    145138        cursor.execute(sql, src)
    146139        row = cursor.fetchone()
    … …  
    152145                return True
    153146        else:
    154             if not path_or_realm in self.parent_blacklisted.keys():
     147            if path_or_realm not in self.parent_blacklisted.keys():
    155148                return True
    156149            else:
    … …  
    162155
    163156    def save_tracform(self, src, state, author,
    164                         base_version=None, keep_history=False,
    165                         track_fields=False, db=None):
     157                      base_version=None, keep_history=False,
     158                      track_fields=False, db=None):
    166159        (form_id, realm, resource_id, subcontext, last_updater,
    167             last_updated_on, form_keep_history,
    168             form_track_fields) = self.get_tracform_meta(src, db=db)
     160         last_updated_on, form_keep_history,
     161         form_track_fields) = self.get_tracform_meta(src, db=db)
    169162
    170163        if form_keep_history is not None:
    … …  
    178171
    179172        if ((base_version is None and last_updated_on is None) or
    180             (base_version == last_updated_on)):
     173                (base_version == last_updated_on)):
    181174            if state != old_state and self.save_tracform_allowed(realm,
    182175                                                                 resource_id):
    … …  
    191184                            VALUES (%s, %s, %s, %s, %s, %s)
    192185                        """, (realm, resource_id, subcontext,
    193                         state, author, updated_on))
    194                     form_id = db.get_last_id(cursor, 'forms') 
     186                              state, author, updated_on))
     187                    form_id = db.get_last_id(cursor, 'forms')
    195188                else:
    196189                    cursor.execute("""
    … …  
    207200                                    VALUES (%s, %s, %s, %s)
    208201                            """, (form_id, last_updated_on,
    209                                 last_updater, old_state))
     202                                  last_updater, old_state))
    210203                if track_fields:
    211204                    # Break down old version and new version.
    … …  
    245238                author = last_updater
    246239            return ((form_id, realm, resource_id, subcontext, state,
    247                     author, updated_on),
     240                     author, updated_on),
    248241                    (form_id, realm, resource_id, subcontext, old_state,
    249                     last_updater, last_updated_on))
     242                     last_updater, last_updated_on))
    250243        else:
    251244            raise ValueError(_("Conflict"))
    … …  
    324317            now = int(time.time())
    325318            author, updated_on, old_state = self.get_tracform_history(
    326                                             form_id, db=db)[0] or \
     319                form_id, db=db)[0] or \
    327320                                            (author, now, '{}')
    328321            if updated_on == now:
    … …  
    415408        # A reference is enough, as long as we ensure strictly read-only
    416409        # access and short lifetime of the reference. Change later, if needed.
    417         #users = copy.deepcopy(self.known_users)
     410        # users = copy.deepcopy(self.known_users)
    418411        users = self.known_users
    419412        return users
    … …  
    454447            return users
    455448
    456     ##########################################################################
    457449    # TracForms schemas
    458450    # Hint: See older versions of this file for the original SQL statements.
    459451    #   Most of them have been rewritten to imrove compatibility with Trac.
    460452
    461     #def dbschema_2008_06_14_0000(self, cursor):
     453    # def dbschema_2008_06_14_0000(self, cursor):
    462454    #    """This was a simple test for the schema base class."""
    463455
    … …  
    477469                Column('old_states')]
    478470        ]
    479         db_connector, _ = DatabaseManager(env)._get_connector()
     471        db_connector = DatabaseManager(env).get_connector()[0]
    480472        for table in tables:
    481473            for stmt in db_connector.to_sql(table):
    … …  
    558550            Index(['tracform_id', 'field'], unique=True)
    559551        ]
    560         db_connector, _ = DatabaseManager(env)._get_connector()
     552        db_connector = DatabaseManager(env).get_connector()[0]
    561553        for stmt in db_connector.to_sql(table):
    562554            cursor.execute(stmt)
    … …  
    566558
    567559        Migrate to slicker named major tables and associated indexes too.
    568         """ 
     560        """
    569561        table = Table('forms', key='id')[
    570562            Column('id', auto_increment=True),
    … …  
    579571            Index(['time'])
    580572        ]
    581         db_connector, _ = DatabaseManager(env)._get_connector()
     573        db_connector = DatabaseManager(env).get_connector()[0]
    582574        for stmt in db_connector.to_sql(table):
    583575            cursor.execute(stmt)
    … …  
    607599            values = form.values()
    608600            sql = "INSERT INTO forms (" + ", ".join(fields) + \
    609               ") VALUES (" + ", ".join(["%s" for I in xrange(len(fields))]) \
    610               + ")"
     601                  ") VALUES (" + ", ".join(
     602                ["%s" for I in xrange(len(fields))]) \
     603                  + ")"
    611604            cursor.execute(sql, values)
    612605
    … …  
    649642        for row in history:
    650643            sql = "UPDATE forms_history SET old_state=%s " + \
    651               "WHERE id=%s AND time=%s"
     644                  "WHERE id=%s AND time=%s"
    652645            cursor.execute(sql, (row['old_state'], row['id'], row['time']))
    653646
    … …  
    698691
    699692    def db14(self, env, cursor):
    700         """Split context into proper Trac resource descriptors.""" 
     693        """Split context into proper Trac resource descriptors."""
    701694        cursor.execute("""
    702695            CREATE TABLE forms_old
    … …  
    721714            Index(['time'])
    722715        ]
    723         db_connector, _ = DatabaseManager(env)._get_connector()
     716        db_connector = DatabaseManager(env).get_connector()[0]
    724717        for stmt in db_connector.to_sql(table):
    725718            cursor.execute(stmt)
    … …  
    742735            values = form.values()
    743736            sql = "INSERT INTO forms (" + ", ".join(fields) + \
    744               ") VALUES (" + ", ".join(["%s" for I in xrange(len(fields))]) \
    745               + ")"
     737                  ") VALUES (" + ", ".join(
     738                ["%s" for I in xrange(len(fields))]) \
     739                  + ")"
    746740            cursor.execute(sql, values)
    747741
    … …  
    764758    return Chrome(env).format_author(req, author)
    765759
     760
    766761def _url_to_json(state_url):
    767762    """Convert urlencoded state serial to JSON state serial."""
    768     state = parse_qs(state_url)
     763    state = urlparse.parse_qs(state_url)
    769764    for name, value in state.iteritems():
    770765        if isinstance(value, (list, tuple)):
    … …  
    774769            state[name] = xml_unescape(value)
    775770    return json.dumps(state, separators=(',', ':'))
     771
    776772
    777773def _context_to_resource(env, context):
    … …  
    806802        realm = ''
    807803    return realm, resource_id, subcontext
    808 
    809 
    810 if __name__ == '__main__':
    811     from trac.test import EnvironmentStub
    812     env = EnvironmentStub()
    813     db = FormDBComponent(env)
    814     db.upgrade_environment(None)
    815     updated_on_1 = db.save_tracform('/', 'hello world', 'me')[0][4]
    816     assert db.get_tracform_state('/') == 'hello world'
    817     updated_on_2 = \
    818         db.save_tracform('/', 'ack oop', 'you', updated_on_1)[0][4]
    819     assert db.get_tracform_state('/') == 'ack oop'
    820     assert tuple(db.get_tracform_history('/')) == (
    821         ('me', updated_on_1, 'hello world'),
    822         )
    823 

  • tracformsplugin/trunk/tracforms/htdocs/tracforms.css

    r10123 r16384  
    88 margin-right: auto;
    99}
     10
    1011#content.tracforms #form {
    1112 background: #eef;
    … …  
    2324 width: 100%;
    2425}
     26
    2527#form table.properties td {
    2628 width: 40%;
    2729}
     30
    2831#form table.properties th {
    2932 width: 20%;
    3033}
     34
    3135#form table.properties td, #form table.properties th {
    3236 font-size: 80%;
    … …  
    3539 vertical-align: top;
    3640}
     41
    3742#form table.properties .author, #form table.properties .date {
    3843 color: #990;
    3944}
    4045
    41 #changelog { border: 1px outset #996; padding: 1em }
     46#changelog {
     47 border: 1px outset #996;
     48 padding: 1em
     49}
     50
    4251#changelog h3, #ticketchange h3 {
    4352 border-bottom: 1px solid #d7d7d7;
    … …  
    4655 font-weight: normal;
    4756}
    48 #changelog .changes { list-style: square; margin-left: 2em; padding: 0 }
    4957
     58#changelog .changes {
     59 list-style: square;
     60 margin-left: 2em;
     61 padding: 0
     62}
     63

  • tracformsplugin/trunk/tracforms/macros.py

    r11283 r16384  
    66import time
    77import traceback
    8 
    98from math import modf
    109
     10from api import FormDBUser, PasswordStoreUser, _
     11from compat import json
     12from errors import FormError, FormTooManyValuesError
     13from formdb import format_author
    1114from trac.util.datefmt import format_datetime
    1215from trac.util.text import to_unicode
     16from trac.wiki.formatter import Formatter
    1317from trac.wiki.macros import WikiMacroBase
    14 from trac.wiki.formatter import Formatter
    15 
    16 from api import FormDBUser, PasswordStoreUser, _
    17 from compat import json
    18 from environment import FormEnvironment
    19 from errors import FormError, FormTooManyValuesError
    20 from formdb import format_author
    2118from util import resource_from_page, xml_escape
    2219
    … …  
    2421argstrRE = re.compile('%(.*?)%')
    2522tfRE = re.compile('\['
    26     'tf(?:\.([a-zA-Z_]+?))?'
    27     '(?::([^\[\]]*?))?'
    28     '\]')
     23                  'tf(?:\.([a-zA-Z_]+?))?'
     24                  '(?::([^\[\]]*?))?'
     25                  '\]')
    2926chartrans = {
    30     u'"'        : u'"',
    31     u'\t'       : u'	',
    32     u'\n'       : u'
',
    33     u'\r'       : u'
',
    34     }
     27    u'"': u'"',
     28    u'\t': u'	',
     29    u'\n': u'
',
     30    u'\r': u'
',
     31}
    3532kwtrans = {
    36     'class'     : '_class',
    37     'id'        : '_id',
    38     'mode'      : '_mode',
    39     'title'     : '_title',
    40     }
     33    'class': '_class',
     34    'id': '_id',
     35    'mode': '_mode',
     36    'title': '_title',
     37}
    4138
    4239
    … …  
    4441    """Docs for TracForms macro..."""
    4542
    46     def expand_macro(self, formatter, name, args):
    47         processor = FormProcessor(self, formatter, name, args)
     43    def expand_macro(self, formatter, name, content, args=None):
     44        processor = FormProcessor(self, formatter, name, content)
    4845        return processor.execute()
    4946
    … …  
    7269        self.args = args
    7370        self.name = name
     71        self.env = None
     72        self.context = None
     73        self.subform = None
     74        self.updated = None
     75        self.form_realm = None
     76        self.form_resource_id = None
     77        self.form_subcontext = None
     78        self.form_updater = None
     79        self.form_updated_on = None
     80        self.form_keep_history = None
     81        self.form_track_fields = None
     82        self.form_id = None
    7483
    7584    def execute(self):
    7685        formatter = self.formatter
    7786        args = self.args
    78         name = self.name
    7987
    8088        # Look in the formatter req object for evidence we are executing.
    … …  
    113121                            except FormError, e:
    114122                                errors.append(str(e))
    115                             except Exception, e:
     123                            except Exception:
    116124                                errors.append(traceback.format_exc())
    117125            else:
    … …  
    123131        # Determine our destination context and load the current state.
    124132        self.context = tuple([realm, resource_id,
    125                               self.subcontext is not None and \
     133                              self.subcontext is not None and
    126134                              self.subcontext or ''])
    127135        state = self.macro.get_tracform_state(self.context)
    … …  
    136144        self.sorted_env = None
    137145        (self.form_id, self.form_realm, self.form_resource_id,
    138             self.form_subcontext, self.form_updater, self.form_updated_on,
    139             self.form_keep_history, self.form_track_fields) = \
     146         self.form_subcontext, self.form_updater, self.form_updated_on,
     147         self.form_keep_history, self.form_track_fields) = \
    140148            self.macro.get_tracform_meta(self.context)
    141149        self.form_id = self.form_id is not None and int(self.form_id) or None
    … …  
    170178            dest = self.formatter.req.href('/form/update')
    171179            yield ('<FORM class="printableform" ' +
    172                     'method="POST" action=%r' % str(dest) +
    173                     (form_cssid is not None
    174                         and ' id="%s"' % form_cssid
    175                         or '') +
    176                     (form_name is not None
    177                         and ' name="%s"' % form_name
    178                         or '') +
    179                     (form_class is not None
    180                         and ' class="%s"' % form_class
    181                         or '') +
    182                     '>')
     180                   'method="POST" action=%r' % str(dest) +
     181                   (form_cssid is not None
     182                    and ' id="%s"' % form_cssid
     183                    or '') +
     184                   (form_name is not None
     185                    and ' name="%s"' % form_name
     186                    or '') +
     187                   (form_class is not None
     188                    and ' class="%s"' % form_class
     189                    or '') +
     190                   '>')
    183191            yield text
    184192            if self.allow_submit:
    … …  
    205213                self.context, separators=(',', ':'))
    206214            yield '<INPUT type="hidden" ' + \
    207                 'name="__context__" value=%r>' % context
     215                  'name="__context__" value=%r>' % context
    208216            backpath = self.formatter.req.href(self.formatter.req.path_info)
    209217            yield '<INPUT type="hidden" ' \
    210                     'name="__backpath__" value=%s>' % str(backpath)
     218                  'name="__backpath__" value=%s>' % str(backpath)
    211219            form_token = self.formatter.req.form_token
    212220            yield '<INPUT type="hidden" ' \
    213                     'name="__FORM_TOKEN" value=%r>' % str(form_token)
     221                  'name="__FORM_TOKEN" value=%r>' % str(form_token)
    214222            yield '</FORM>'
    215223        else:
    … …  
    226234                    arg = (str(float(arg)))
    227235                    yield arg
    228                 except ValueError, e:
     236                except ValueError:
    229237                    name, value = (arg[1:].split('=', 1) + [True])[:2]
    230238                    kw[str(kwtrans.get(name, name))] = value
    … …  
    291299                return tuple(value)
    292300            else:
    293                 return (value,)
     301                return value,
    294302        else:
    295303            if isinstance(value, (list, tuple)):
    … …  
    360368
    361369    def cmd_submit_name(self, name):
    362         self.submit_name
     370        self.submit_name = name
    363371
    364372    def cmd_setenv(self, name, value):
    … …  
    370378        self.sorted_env = None
    371379
    372     def cmd_operation(_self, _name, _op, *_args, **_kw):
     380    def cmd_operation(self, _name, _op, *_args, **_kw):
    373381        if _op in ('is', 'as'):
    374382            _op, _args = _args[0], _args[1:]
    375         op = getattr(_self, 'op_' + _op, None)
     383        op = getattr(self, 'op_' + _op, None)
    376384        if op is None:
    377385            raise FormTooManyValuesError(str(_name))
     386
    378387        def partial(*_newargs, **_newkw):
    379388            if _kw or _newkw:
    … …  
    383392                kw = {}
    384393            return op(*(_newargs + _args), **kw)
    385         _self.env['op:' + _name] = partial
     394
     395        self.env['op:' + _name] = partial
    386396
    387397    def wiki(self, text):
    388398        out = StringIO.StringIO()
    389         Formatter(self.formatter.env, self.formatter.context).format(text, out)
     399        Formatter(self.formatter.env, self.formatter.context).format(text,
     400                                                                     out)
    390401        return out.getvalue()
    391402
    … …  
    414425            except FormError, e:
    415426                return '<PRE>' + str(e) + '</PRE>'
    416             except Exception, e:
     427            except Exception:
    417428                return '<PRE>' + traceback.format_exc() + '</PRE>'
    418429
    … …  
    450461                (readonly is True and ' readonly="readonly"' or '') +
    451462                (content is not None and (' value="%s"'
    452                                            % xml_escape(content)) or '') +
     463                                          % xml_escape(content)) or '') +
    453464                '>')
    454465
    … …  
    483494        _title = kw.pop('_title', None)
    484495        current = self.get_field(field)
    485         result = []
    486         result.append("<SELECT name='%s'" % field +
    487                 (_id is not None and ' id="%s"' % _id or '') +
    488                 (_class is not None and ' class="%s"' % _class or '') +
    489                 (_title is not None and ' title="%s"' % _title or '') +
    490                 '>')
     496        result = ["<SELECT name='%s'" % field +
     497                  (_id is not None and ' id="%s"' % _id or '') +
     498                  (_class is not None and ' class="%s"' % _class or '') +
     499                  (_title is not None and ' title="%s"' % _title or '') +
     500                  '>']
    491501        for value in values:
    492502            value, label = (value.split('//', 1) + [value])[:2]
    493503            result += ("<OPTION value='%s'" % value.strip() +
    494                     (current == value and ' selected' or '') +
    495                     '>' + label.strip() + '</OPTION>')
     504                       (current == value and ' selected' or '') +
     505                       '>' + label.strip() + '</OPTION>')
    496506        result.append("</SELECT>")
    497507        return ''.join(result)
    … …  
    505515        if _mode == 'ro' or (_mode == 'once' and current is not None):
    506516            readonly = True
    507         return ((_mode != 'rd' and "<TEXTAREA name='%s'" % field or \
     517        return ((_mode != 'rd' and "<TEXTAREA name='%s'" % field or
    508518                 "<TEXTAREA ") +
    509519                (cols is not None and ' cols="%s"' % cols or '') +
    … …  
    522532        # TRANSLATOR: Default updater name
    523533        who = self.macro.get_tracform_fieldinfo(
    524                 self.form_id is not None and self.form_id or self.context,
    525                 field)[0] or _("unknown")
     534            self.form_id is not None and self.form_id or self.context,
     535            field)[0] or _("unknown")
    526536        return format_author(self.formatter.env, self.formatter.req, who)
    527        
     537
    528538    def op_when(self, field, format='%m/%d/%Y %H:%M:%S'):
    529539        when = self.macro.get_tracform_fieldinfo(
    530             self.form_id is not None and self.form_id or \
     540            self.form_id is not None and self.form_id or
    531541            self.context, field)[1]
    532542        return (when is not None and format_datetime(
    533                 when, format=str(format)) or _("unknown"))
     543            when, format=str(format)) or _("unknown"))
    534544
    535545    def op_id(self):
    … …  
    556566           values
    557567        """
    558         ## msum() from http://code.activestate.com/recipes/393090/ (r5)
     568        # msum() from http://code.activestate.com/recipes/393090/ (r5)
    559569        # Depends on IEEE-754 arithmetic guarantees.
    560         partials = []               # sorted, non-overlapping partial sums
     570        partials = []  # sorted, non-overlapping partial sums
    561571        for x in values:
    562572            x = float(x)
    … …  
    629639        return ''.join(result)
    630640
     641
    631642def _xml_escape(text):
    632643    """Escape literal '&' first to prevent evaluation of valid HTML escape
    … …  
    638649        text = text.replace(k, chartrans[k])
    639650    return text
    640 

  • tracformsplugin/trunk/tracforms/model.py

    r10211 r16384  
    3232            self.resource = form_resource_or_parent_realm
    3333            parent = self.resource.parent
    34             if self.siblings == []:
     34            if not self.siblings:
    3535                self._get_siblings(parent.realm, parent.id)
    3636        else:
    … …  
    4040            else:
    4141                self.id = None
    42             if self.id is not None and (parent_realm is None or \
    43                     parent_id is None or subcontext is None):
     42            if self.id is not None and \
     43                    (parent_realm is None or parent_id is None or
     44                     subcontext is None):
    4445                # get complete context, required as resource parent
    4546                ctxt = self.forms.get_tracform_meta(self.id)[1:4]
    … …  
    4849                self.subcontext = ctxt[2]
    4950            elif isinstance(parent_realm, basestring) and \
    50                     parent_id is not None and self.id is None:
     51                            parent_id is not None and self.id is None:
    5152                # find form(s), if parent descriptors are available
    5253                if subcontext is not None:
    … …  
    5556            self._get_siblings(parent_realm, parent_id)
    5657            if isinstance(parent_realm, basestring) and \
    57                     parent_id is not None:
     58                            parent_id is not None:
    5859                self.resource = Resource(parent_realm, parent_id
    59                                 ).child('form', self.id, version)
     60                                         ).child('form', self.id, version)
    6061            else:
    6162                raise ResourceNotFound(
    … …  
    6465                      """, realm=parent_realm, parent_id=parent_id),
    6566                    subcontext and _("with subcontext %(subcontext)s",
    66                     subcontext=subcontext) or '')
     67                                     subcontext=subcontext) or '')
    6768
    6869    def _get_siblings(self, parent_realm, parent_id):
    … …  
    7879    def has_data(self):
    7980        """Return whether there is any form content stored."""
    80         return (self.forms.get_tracform_fields(self.id) is not None or \
    81                 self.forms.get_tracform_history(self.id) is not None or \
     81        return (self.forms.get_tracform_fields(self.id) is not None or
     82                self.forms.get_tracform_history(self.id) is not None or
    8283                self.forms.get_tracform_state(self.id) not in [None, '{}'])
    83 

  • tracformsplugin/trunk/tracforms/templates/form.html

    r11561 r16384  
    44<html xmlns="http://www.w3.org/1999/xhtml"
    55      xmlns:py="http://genshi.edgewall.org/"
    6       xmlns:xi="http://www.w3.org/2001/XInclude"     
     6      xmlns:xi="http://www.w3.org/2001/XInclude"
    77      xmlns:i18n="http://genshi.edgewall.org/i18n"
    88      i18n:domain="tracforms">

  • tracformsplugin/trunk/tracforms/templates/switch.html

    r10487 r16384  
    44<html xmlns="http://www.w3.org/1999/xhtml"
    55      xmlns:py="http://genshi.edgewall.org/"
    6       xmlns:xi="http://www.w3.org/2001/XInclude"     
     6      xmlns:xi="http://www.w3.org/2001/XInclude"
    77      xmlns:i18n="http://genshi.edgewall.org/i18n"
    88      i18n:domain="tracforms">

  • tracformsplugin/trunk/tracforms/tracdb.py

    r10211 r16384  
    9090        if installed is None:
    9191            self.log.info(
    92                     'Installing TracForm plugin schema %s' % db_version)
    93             db_connector, _ = DatabaseManager(self.env)._get_connector()
     92                'Installing TracForm plugin schema %s' % db_version)
     93            db_connector = DatabaseManager(self.env).get_connector()[0]
    9494            db = self._get_db(db)
    9595            cursor = db.cursor()
    … …  
    117117
    118118    def get_installed_version(self, db):
    119         version = self.get_system_value(db, self.plugin_name + '_version', -1)
     119        version = self.get_system_value(db, self.plugin_name + '_version')
    120120        if version is None:
    121121            # check for old naming schema
    122             oldversion = self.get_system_value(
    123                 db, 'TracFormDBComponent:version', -1)
     122            oldversion = self.get_system_value(db,
     123                                               'TracFormDBComponent:version')
    124124            version = _db_oldversion_dict.get(oldversion)
    125125        if version is None:
    … …  
    144144    # Trac db 'system' table management methods for TracForms entry
    145145
    146     def get_system_value(self, db, key, default=None):
     146    def get_system_value(self, db, key):
    147147        db = self._get_db(db)
    148148        cursor = db.cursor()
    … …  
    156156        cursor = db.cursor()
    157157        cursor.execute(
    158                 "UPDATE system SET value=%s WHERE name=%s", (value, key))
     158            "UPDATE system SET value=%s WHERE name=%s", (value, key))
    159159        cursor.execute("SELECT value FROM system WHERE name=%s", (key,))
    160160        if not cursor.fetchone():
    … …  
    173173    'dbschema_2008_06_15_0004': 4, 'dbschema_2008_06_15_0010': 10,
    174174    'dbschema_2008_06_15_0011': 11, 'dbschema_2008_06_15_0012': 12,
    175     }
    176 
     175}

  • tracformsplugin/trunk/tracforms/util.py

    r11561 r16384  
    55import htmlentitydefs
    66import re
    7 import unittest
     7import codecs
    88
    9 from codecs          import getencoder
    10 from genshi.builder  import Markup, tag
     9from trac.resource import ResourceSystem
     10from trac.util.html import Markup, tag
     11from trac.util.text import to_unicode
    1112
    12 from trac.resource   import ResourceSystem
    13 from trac.util.text  import to_unicode
     13from api import _
     14from compat import json
    1415
    15 from api             import _
    16 from compat          import json
    17 
    18 __all__ = ['parse_history', 'resource_from_page',
    19            'xml_escape', 'xml_unescape']
     16__all__ = ['parse_history', 'resource_from_page', 'xml_escape',
     17           'xml_unescape']
    2018
    2119
    … …  
    2624    a dict of field change lists for stepwise form reset.
    2725    """
    28     fieldhistory = {}
     26    field_history = {}
    2927    history = []
    30     if not fieldwise == False:
    31         def _add_change(fieldhistory, field, author, time, old, new):
    32             if field not in fieldhistory.keys():
    33                 fieldhistory[field] = [{'author': author, 'time': time,
     28    if fieldwise is not False:
     29        def _add_change(field_history, field, author, time, old, new):
     30            if field not in field_history.keys():
     31                field_history[field] = [{'author': author, 'time': time,
    3432                                        'old': old, 'new': new}]
    3533            else:
    36                 fieldhistory[field].append({'author': author, 'time': time,
     34                field_history[field].append({'author': author, 'time': time,
    3735                                            'old': old, 'new': new})
    38             return fieldhistory
     36            return field_history
    3937
    4038    new_fields = None
     39    last_author = last_change = None
    4140    for changeset in changes:
    4241        # break down old and new version
    … …  
    5756            new_value = new_fields.get(field)
    5857            if new_value != old_value:
    59                 if fieldwise == False:
     58                if fieldwise is False:
    6059                    change = _render_change(old_value, new_value)
    6160                    if change is not None:
    6261                        updated_fields[field] = change
    6362                else:
    64                     fieldhistory = _add_change(fieldhistory, field,
    65                                                last_author, last_change,
    66                                                old_value, new_value)
     63                    field_history = _add_change(field_history, field,
     64                                                last_author, last_change,
     65                                                old_value, new_value)
    6766        for field in new_fields:
    6867            if old_fields.get(field) is None:
    69                 if fieldwise == False:
     68                if fieldwise is False:
    7069                    change = _render_change(None, new_fields[field])
    7170                    if change is not None:
    7271                        updated_fields[field] = change
    7372                else:
    74                     fieldhistory = _add_change(fieldhistory, field,
    75                                                last_author, last_change,
    76                                                None, new_fields[field])
     73                    field_history = _add_change(field_history, field,
     74                                                last_author, last_change,
     75                                                None, new_fields[field])
    7776        new_fields = old_fields
    7877        history.append({'author': last_author,
    … …  
    8180        last_author = changeset['author']
    8281        last_change = changeset['time']
    83     return fieldwise == False and history or fieldhistory
     82    return fieldwise is False and history or field_history
     83
    8484
    8585def _render_change(old, new):
    … …  
    103103    return rendered
    104104
     105
    105106# adapted from code published by Daniel Goldberg on 09-Dec-2008 at
    106107# http://stackoverflow.com/questions/354038
    … …  
    112113        return False
    113114
     115
    114116# code from an article published by Uche Ogbuji on 15-Jun-2005 at
    115117# http://www.xml.com/pub/a/2005/06/15/py-xml.html
    116118def xml_escape(text):
    117     enc = getencoder('us-ascii')
     119    enc = codecs.getencoder('us-ascii')
    118120    return enc(to_unicode(text), 'xmlcharrefreplace')[0]
     121
    119122
    120123# adapted from code published by John J. Lee on 06-Jun-2007 at
    … …  
    123126unichresc_RE = re.compile(r'&#?[A-Za-z0-9]+?;')
    124127
     128
    125129def xml_unescape(text):
    126130    return unichresc_RE.sub(_replace_entities, text)
     131
    127132
    128133def _unescape_charref(ref):
    … …  
    134139        base = 16
    135140    return unichr(int(name, base))
     141
    136142
    137143def _replace_entities(match):
    … …  
    145151        repl = ent
    146152    return repl
     153
    147154
    148155def resource_from_page(env, page):
    … …  
    158165    else:
    159166        return page, None
    160 
    161 
    162 class UnescapeTests(unittest.TestCase):
    163 
    164     def test_unescape_charref(self):
    165         self.assertEqual(unescape_charref(u"&#38;"), u"&")
    166         self.assertEqual(unescape_charref(u"&#x2014;"), u"\N{EM DASH}")
    167         self.assertEqual(unescape_charref(u"—"), u"\N{EM DASH}")
    168 
    169     def test_unescape(self):
    170         self.assertEqual(unescape(u"&amp; &lt; &mdash; — &#x2014;"),
    171             u"& < %s %s %s" % tuple(u"\N{EM DASH}"*3)
    172         )
    173         self.assertEqual(unescape(u"&a&amp;"), u"&a&")
    174         self.assertEqual(unescape(u"a&amp;"), u"a&")
    175         self.assertEqual(unescape(u"&nonexistent;"), u"&nonexistent;")
    176 
    177 #    unittest.main()
    178 

  • tracformsplugin/trunk/tracforms/web_ui.py

    r15447 r16384  
    22
    33import re
    4 
    5 from genshi.builder import Markup, tag
    64from pkg_resources import resource_filename
    75
    … …  
    119from trac.search.api import ISearchSource, shorten_result
    1210from trac.util.datefmt import to_datetime
     11from trac.util.html import Markup, tag
    1312from trac.web.api import IRequestFilter, IRequestHandler
    1413from trac.web.chrome import ITemplateProvider, add_ctxtnav, add_stylesheet
    … …  
    2019from util import parse_history, resource_from_page
    2120
    22 tfpageRE = re.compile('/form(/\d+|$)')
     21tf_page_re = re.compile('/form(/\d+|$)')
    2322
    2423
    … …  
    4443        realm, resource_id = resource_from_page(env, page)
    4544        # break (recursive) search for form in forms realm
    46         if tfpageRE.match(page) == None and resource_id is not None:
     45        if tf_page_re.match(page) is None and resource_id is not None:
    4746            if page == '/wiki' or page == '/wiki/':
    4847                page = '/wiki/WikiStart'
    … …  
    5150                if len(form.siblings) == 0:
    5251                    # no form record found for this parent resource
    53                     return (template, data, content_type)
     52                    return template, data, content_type
    5453                elif form.resource.id is not None:
    5554                    # single form record found
    … …  
    6867                                     resource_id=parent.id)
    6968                add_ctxtnav(req, _("Back to forms list"), href=href)
    70         return (template, data, content_type)
     69        return template, data, content_type
    7170
    7271    # ITemplateProvider methods
    … …  
    108107
    109108        if req.args.get('action') == 'select':
    110             realm=req.args.get('realm')
    111             resource_id=req.args.get('resource_id')
     109            realm = req.args.get('realm')
     110            resource_id = req.args.get('resource_id')
    112111            if realm is not None and resource_id is not None:
    113112                form = Form(env, realm, resource_id)
    … …  
    139138        # show reset button in case of existing data and proper permission
    140139        data['allow_reset'] = req.perm(form.resource) \
    141                               .has_permission('FORM_RESET') and form.has_data
     140                                  .has_permission(
     141            'FORM_RESET') and form.has_data
    142142        add_stylesheet(req, 'tracforms/tracforms.css')
    143143        return 'form.html', data, None
    144144
    145145    def _do_switch(self, env, req, form):
    146         data = {'_dgettext': dgettext}
    147         data['page_title'] = get_resource_description(env, form.resource,
    148                                                       href=req.href)
    149         data['title'] = get_resource_shortname(env, form.resource)
    150         data['siblings'] = []
     146        data = {
     147            '_dgettext': dgettext,
     148            'page_title': get_resource_description(env, form.resource,
     149                                                   href=req.href),
     150            'title': get_resource_shortname(env, form.resource),
     151            'siblings': []
     152        }
    151153        for sibling in form.siblings:
    152154            form_id = tag.strong(tag.a(
    153                           _("Form %(form_id)s", form_id=sibling[0]),
    154                             href=req.href.form(sibling[0])))
     155                _("Form %(form_id)s", form_id=sibling[0]),
     156                href=req.href.form(sibling[0])))
    155157            if sibling[1] == '':
    156158                data['siblings'].append(form_id)
    … …  
    158160                # TRANSLATOR: Form list entry for form select page
    159161                data['siblings'].append(tag(Markup(_(
    160                               "%(form_id)s (subcontext = '%(subcontext)s')",
    161                               form_id=form_id, subcontext = sibling[1]))))
     162                    "%(form_id)s (subcontext = '%(subcontext)s')",
     163                    form_id=form_id, subcontext=sibling[1]))))
    162164        add_stylesheet(req, 'tracforms/tracforms.css')
    163165        return 'switch.html', data, None
    … …  
    165167    def _do_reset(self, env, req, form):
    166168        author = req.authname
     169        step = None
    167170        if 'rewind' in req.args:
    168171            step = -1
    … …  
    207210
    208211    def get_search_results(self, req, terms, filters):
    209         if not 'form' in filters:
     212        if 'form' not in filters:
    210213            return
    211214        env = self.env
    212215        results = self.search_tracforms(env, terms)
    213216
    214         for id, realm, parent, subctxt, state, author, updated_on in results:
     217        for id_, realm, parent, subctxt, state, author, updated_on in results:
    215218            # DEVEL: support for handling form revisions not implemented yet
    216             #form = Form(env, realm, parent, subctxt, id, version)
    217             form = Form(env, realm, parent, subctxt, id)
     219            # form = Form(env, realm, parent, subctxt, id, version)
     220            form = Form(env, realm, parent, subctxt, id_)
    218221            if 'FORM_VIEW' in req.perm(form.resource):
    219222                form = form.resource
    … …  
    232235        fields.append(''.join([name, delimiter, value]))
    233236    return '; '.join(fields)
    234 
Note: See TracChangeset for help on using the changeset viewer.