Commit: 15ed07eac5a3e5abd07f655e35178545f4d2d9e4 - allura (git)

allura

Commit MetaInfo

• Revisión: 15ed07eac5a3e5abd07f655e35178545f4d2d9e4 (tree)
• Tiempo: 2011-04-30 02:08:35
• Autor: Rick Copeland <rcopeland@geek...>
• Commiter: Rick Copeland

Log Message

[#1831] Refactor tg compatibility shim

Signed-off-by: Rick Copeland <[e-mail]>

Cambiar Resumen

• modified: Allura/allura/factory.py
• modified: Allura/tg/__init__.py
• modified: Allura/tg/decorators.py
• modified: Allura/tg/shim.py
• modified: Allura/tg/util.py
• add: Allura/tg/view.py
• modified: ForgeDiscussion/forgediscussion/tests/functional/test_forum.py

Diferencia incremental

--- a/Allura/allura/factory.py
+++ b/Allura/allura/factory.py
@@ -9,9 +9,11 @@ from paste.registry import RegistryManager
 from pyramid.config import Configurator
 from pyramid.session import UnencryptedCookieSessionFactoryConfig
 
-import tg.error
 import ew
 import ming
+import tg.view
+import tg.error
+import tg.traversal
 from ming.orm.middleware import MingMiddleware
 from tg.shim import RootFactory
 
@@ -45,10 +47,11 @@ def main(global_config, **settings):
             secret=settings['session.secret'],
             cookie_name=settings['session.key']))
     config.add_view(
-        tg.shim.tg_view,
-        context='tg.shim.Resource',
-        renderer='allura:templates/mytemplate.pt')
-    config.add_view(tg.shim.error_view, context=exc.WSGIHTTPException)
+        tg.view.tg_view,
+        context=tg.traversal.Resource)
+    config.add_view(
+        tg.view.error_view,
+        context=exc.WSGIHTTPException)
     app = config.make_wsgi_app()
 
     if asbool(conf.get('auth.method', 'local')=='sfx'):

--- a/Allura/tg/__init__.py
+++ b/Allura/tg/__init__.py
@@ -1,3 +1,3 @@
 from .tg_globals import c, g, response, request, config, session, environ
-from .shim import redirect, url
+from .util import redirect, url
 from .decorators import expose, validate

--- a/Allura/tg/decorators.py
+++ b/Allura/tg/decorators.py
@@ -16,7 +16,9 @@ class _tg_deco(object):
 class expose(_tg_deco): pass
 class validate(_tg_deco): pass
 class before_validate(_tg_deco): pass
-class override_template(_tg_deco): pass
+
+def override_template(func, template):
+    c.override_template = template
 
 def without_trailing_slash(func):
     from tg import redirect
@@ -54,6 +56,7 @@ class Decoration(object):
 
     def expose(self, template=None, content_type=None):
         self.exposed = True
+        assert not self._templates, 'Multiple @expose not supported in shim'
         if template or content_type:
             self._templates[content_type] = template
 
@@ -86,24 +89,32 @@ class Decoration(object):
         return params
 
     def do_render_response(self, result):
-        if len(self._templates) == 1:
-            ct, tname = self._templates.items()[0]
-            if ct is not None:
-                response.content_type = ct
-            if tname in ('json', 'json:'):
-                engine, tname = 'json', 'json'
-                response.content_type = 'application/json'
-            else:
-                engine, tname = tname.split(':', 1)
-            f = ew.render.File(tname, engine)
-            rendered_result = f(result)
-        elif self._templates:
-            assert False, 'Multiple @expose not supported in shim'
+        tname = self._lookup_template()
+        if tname in ('json', 'json:'):
+            engine, tname = 'json', 'json'
+            response.content_type = 'application/json'
+        elif tname is None:
+            return self._make_iter(result)
         else:
-            rendered_result = result
-        if isinstance(rendered_result, unicode):
-            return [ rendered_result.encode('utf-8') ]
-        elif isinstance(rendered_result, str):
-            return [ rendered_result ]
+            engine, tname = tname.split(':', 1)
+        f = ew.render.File(tname, engine)
+        return self._make_iter(f(result))
+
+    def _lookup_template(self):
+        tpl = getattr(c, 'override_template', None)
+        if tpl is not None: return tpl
+        if len(self._templates) > 1:
+            assert False, 'Multiple @expose not supported in shim'
+        if not self._templates: return None
+        ct, tname = self._templates.items()[0]
+        if ct is not None:
+            response.content_type = ct
+        return tname
+
+    def _make_iter(self, result):
+        if isinstance(result, unicode):
+            return [ result.encode('utf-8') ]
+        elif isinstance(result, str):
+            return [ result ]
         else:
-            return rendered_result
+            return result

--- a/Allura/tg/shim.py
+++ b/Allura/tg/shim.py
@@ -1,21 +1,11 @@
 '''TG compatibility shim
 '''
-import types
-import urllib
-
-import tg
 import pkg_resources
 import pyramid.response
-from formencode import Invalid
-from webob import exc
-
-from decorators import Decoration
 
 from . import tg_globals
 from .traversal import Resource
 
-__all__ = [ 'redirect', 'url' ]
-
 class RootFactory(object):
 
     def __init__(self, root):
@@ -43,89 +33,3 @@ class RootFactory(object):
             if hasattr(root_obj, '_cleanup_request'):
                 root_obj._cleanup_request()
 
-def tg_view(context, request):
-    deco, func = context.get_deco()
-    try:
-        if not deco or not deco.exposed: raise exc.HTTPNotFound()
-        try:
-            # Validate params
-            params = deco.do_validate_params(request.params.mixed())
-            result = func(**params)
-        except Invalid, inv:
-            tg.c.validation_exception = inv
-            eh = deco.error_handler
-            if eh:
-                result = eh(func.im_self, **request.params)
-                deco = Decoration.get(deco.error_handler, False)
-            else:
-                result = func(**request.params)
-        tg_globals.response.app_iter = deco.do_render_response(result)
-    except exc.WSGIHTTPException, err:
-        registry = request.environ['paste.registry']
-        response = request.get_response(err)
-        registry.register(tg_globals.response, response)
-    return tg_globals.response
-
-def error_view(context, request):
-    return context
-
-def redirect(*args, **kwargs):
-    found = exc.HTTPFound(location=url(*args, **kwargs))
-    raise found.exception
-
-def smart_str(s, encoding='utf-8', strings_only=False, errors='strict'):
-    """
-    Returns a bytestring version of 's', encoded as specified in 'encoding'.
-
-    If strings_only is True, don't convert (some) non-string-like objects.
-
-    This function was borrowed from Django
-    """
-    if strings_only and isinstance(s, (types.NoneType, int)):
-        return s
-    elif not isinstance(s, basestring):
-        try:
-            return str(s)
-        except UnicodeEncodeError:
-            if isinstance(s, Exception):
-                # An Exception subclass containing non-ASCII data that doesn't
-                # know how to print itself properly. We shouldn't raise a
-                # further exception.
-                return ' '.join([smart_str(arg, encoding, strings_only,
-                        errors) for arg in s])
-            return unicode(s).encode(encoding, errors)
-    elif isinstance(s, unicode):
-        r = s.encode(encoding, errors)
-        return r
-    elif s and encoding != 'utf-8':
-        return s.decode('utf-8', errors).encode(encoding, errors)
-    else:
-        return s
-
-def generate_smart_str(params):
-    for key, value in params.iteritems():
-        if value is None: continue
-        if isinstance(value, (list, tuple)):
-            for item in value:
-                yield smart_str(key), smart_str(item)
-        else:
-            yield smart_str(key), smart_str(value)
-
-def urlencode(params):
-    """
-    A version of Python's urllib.urlencode() function that can operate on
-    unicode strings. The parameters are first case to UTF-8 encoded strings and
-    then encoded as per normal.
-    """
-    return urllib.urlencode([i for i in generate_smart_str(params)])
-
-def url(base_url=None, params=None):
-    if base_url is None: base_url = '/'
-    if params is None: params = {}
-    if hasattr(base_url, '__iter__' ) and not isinstance(base_url, basestring):
-        base_url = '/'.join(base_url)
-    if base_url.startswith('/'):
-        base_url = tg.request.environ['SCRIPT_NAME'] + base_url
-    if params:
-        return '?'.join((base_url, urlencode(params)))
-    return base_url

--- a/Allura/tg/util.py
+++ b/Allura/tg/util.py
@@ -1,3 +1,10 @@
+import types
+import urllib
+
+from webob import exc
+
+from .tg_globals import request
+
 def call_wsgi_application(application, environ, catch_exc_info=False):
     """
     Call the given WSGI application, returning ``(status_string,
@@ -30,3 +37,65 @@ def call_wsgi_application(application, environ, catch_exc_info=False):
         return (captured[0], captured[1], app_iter, captured[2])
     else:
         return (captured[0], captured[1], app_iter)
+
+
+def redirect(*args, **kwargs):
+    found = exc.HTTPFound(location=url(*args, **kwargs))
+    raise found.exception
+
+def smart_str(s, encoding='utf-8', strings_only=False, errors='strict'):
+    """
+    Returns a bytestring version of 's', encoded as specified in 'encoding'.
+
+    If strings_only is True, don't convert (some) non-string-like objects.
+
+    This function was borrowed from Django
+    """
+    if strings_only and isinstance(s, (types.NoneType, int)):
+        return s
+    elif not isinstance(s, basestring):
+        try:
+            return str(s)
+        except UnicodeEncodeError:
+            if isinstance(s, Exception):
+                # An Exception subclass containing non-ASCII data that doesn't
+                # know how to print itself properly. We shouldn't raise a
+                # further exception.
+                return ' '.join([smart_str(arg, encoding, strings_only,
+                        errors) for arg in s])
+            return unicode(s).encode(encoding, errors)
+    elif isinstance(s, unicode):
+        r = s.encode(encoding, errors)
+        return r
+    elif s and encoding != 'utf-8':
+        return s.decode('utf-8', errors).encode(encoding, errors)
+    else:
+        return s
+
+def generate_smart_str(params):
+    for key, value in params.iteritems():
+        if value is None: continue
+        if isinstance(value, (list, tuple)):
+            for item in value:
+                yield smart_str(key), smart_str(item)
+        else:
+            yield smart_str(key), smart_str(value)
+
+def urlencode(params):
+    """
+    A version of Python's urllib.urlencode() function that can operate on
+    unicode strings. The parameters are first case to UTF-8 encoded strings and
+    then encoded as per normal.
+    """
+    return urllib.urlencode([i for i in generate_smart_str(params)])
+
+def url(base_url=None, params=None):
+    if base_url is None: base_url = '/'
+    if params is None: params = {}
+    if hasattr(base_url, '__iter__' ) and not isinstance(base_url, basestring):
+        base_url = '/'.join(base_url)
+    if base_url.startswith('/'):
+        base_url = request.environ['SCRIPT_NAME'] + base_url
+    if params:
+        return '?'.join((base_url, urlencode(params)))
+    return base_url

--- /dev/null
+++ b/Allura/tg/view.py
@@ -0,0 +1,31 @@
+from formencode import Invalid
+from webob import exc
+
+from . import tg_globals
+from .decorators import Decoration
+
+def tg_view(context, request):
+    deco, func = context.get_deco()
+    try:
+        if not deco or not deco.exposed: raise exc.HTTPNotFound()
+        try:
+            # Validate params
+            params = deco.do_validate_params(request.params.mixed())
+            result = func(**params)
+        except Invalid, inv:
+            tg_globals.c.validation_exception = inv
+            eh = deco.error_handler
+            if eh:
+                result = eh(func.im_self, **request.params)
+                deco = Decoration.get(deco.error_handler, False)
+            else:
+                result = func(**request.params)
+        tg_globals.response.app_iter = deco.do_render_response(result)
+    except exc.WSGIHTTPException, err:
+        registry = request.environ['paste.registry']
+        response = request.get_response(err)
+        registry.register(tg_globals.response, response)
+    return tg_globals.response
+
+def error_view(context, request):
+    return context

--- a/ForgeDiscussion/forgediscussion/tests/functional/test_forum.py
+++ b/ForgeDiscussion/forgediscussion/tests/functional/test_forum.py
@@ -303,9 +303,9 @@ class TestForum(TestController):
         # beautiful soup is getting some unicode error here - test without it
         assert thread.html.findAll('div',{'class':'display_post'})[0].find('p').string == 'aaa'
         assert thread.html.findAll('div',{'class':'display_post'})[1].find('p').string == 'bbb'
-        assert thread.response.body.count('<div class="promote_to_thread_form') == 1
-        assert thread.response.body.count('<div class="row reply_post_form') == 2
-        assert thread.response.body.count('<div class="edit_post_form') == 2
+        assert thread.body.count('<div class="promote_to_thread_form') == 1
+        assert thread.body.count('<div class="row reply_post_form') == 2
+        assert thread.body.count('<div class="edit_post_form') == 2
 
     def get_table_rows(self, response, closest_id):
         tbody = response.html.find('div', {'id': closest_id}).find('tbody')