Changeset 5151

Show
Ignore:
Timestamp:
08/18/08 13:37:09 (5 months ago)
Author:
mramm
Message:

Updating rendering. Now if there is no use_legacy_renderer option turned on in config, the new rendering functions are used.

We may want to turn use_legacy_renderer on by default because:

* Currently the genshi template loader does not accept dotted notation
* The new renderers are not tested extensively yet

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/docs/main/Config.rst

    r5134 r5151  
    7777  base_config.default_renderer = 'mako' 
    7878  base_config.renderers.append('mako') 
     79   
    7980 
    8081Configuration in the INI files 
  • trunk/tg/config.py

    r5150 r5151  
    5555        self.serve_static = True 
    5656        self.paths = Bunch() 
     57        self.render_functions = Bunch() 
    5758     
    5859    def setup_paths(self): 
    5960        root = os.path.dirname(os.path.abspath(self.package.__file__)) 
    6061        # The default paths: 
    61         paths = dict(root=root, 
     62        paths = Bunch(root=root, 
    6263                     controllers=os.path.join(root, 'controllers'), 
    6364                     static_files=os.path.join(root, 'public'), 
     
    6768        paths.update(self.paths) 
    6869        self.paths = paths 
    69                       
     70 
    7071    def init_config(self, global_conf, app_conf): 
    7172        # Initialize config with the basic options 
     
    117118            imports=['from webhelpers.html import escape'], 
    118119            default_filters=['escape']) 
    119         config['pylons.app_globals'].renderer_functions = render_mako 
     120         
     121        self.renderer_functions.mako = render_mako 
    120122         
    121123    def setup_genshi_renderer(self): 
     
    127129            "Plug-in our i18n function to Genshi." 
    128130            genshi.template.filters.insert(0, Translator(ugettext)) 
    129  
    130         config['pylons.app_globals'].genshi_loader = TemplateLoader( 
    131             self.paths['templates'], auto_reload=True) 
    132  
    133         config['pylons.app_globals'].renderer_functions = render_genshi 
     131        loader = TemplateLoader(search_path=self.paths.templates,  
     132                                auto_reload=True) 
     133                                 
     134        config['pylons.app_globals'].genshi_loader = loader 
     135 
     136        self.render_functions.genshi = render_genshi 
    134137     
    135138    def setup_jinja_renderer(self): 
     
    143146        config['pylons.strict_c'] = True 
    144147 
    145         config['pylons.app_globals'].renderer_functionsloa = render_jinja 
     148        self.renderer_functions.jinja = render_jinja 
    146149     
    147150    def setup_default_renderer(self): 
     
    177180            self.setup_routes() 
    178181            self.setup_helpers_and_globals() 
     182             
    179183            if self.auth_backend == "sqlalchemy":  
    180184                self.setup_sa_auth_backend() 
     
    183187                self.setup_mako_renderer() 
    184188 
    185             if 'genshi' in self.renderers: 
    186                 self.setup_genshi_renderer() 
     189            self.setup_genshi_renderer() 
    187190             
    188191            if 'jinja' in self.renderers: 
  • trunk/tg/controllers.py

    r5146 r5151  
    2525    HTTPClientError) 
    2626from tg.render import get_tg_vars 
     27from tg.render import render as tg_render 
    2728from tw.api import Widget 
    2829from webob.exc import HTTPForbidden 
     
    215216        req = pylons.request._current_obj() 
    216217        tmpl_context = pylons.tmpl_context._current_obj() 
    217         buffet = pylons.buffet._current_obj() 
    218  
     218        use_legacy_renderer = pylons.config.get("use_legacy_renderer", False) 
     219         
     220        if use_legacy_renderer:  
     221            buffet = pylons.buffet._current_obj() 
     222         
    219223        if template_name is None: 
    220224            return response 
     
    230234 
    231235        # Prepare the engine, if it's not already been prepared. 
    232         if engine_name not in _configured_engines(): 
    233             from pylons import config 
    234             template_options = dict(config).get('buffet.template_options', {}) 
    235             buffet.prepare(engine_name, **template_options) 
    236             _configured_engines().add(engine_name) 
     236        if use_legacy_renderer: 
     237            if engine_name not in _configured_engines(): 
     238                from pylons import config 
     239                template_options = dict(config).get('buffet.template_options', {}) 
     240                buffet.prepare(engine_name, **template_options) 
     241                _configured_engines().add(engine_name) 
    237242 
    238243        #if there is an identity, push it to the pylons template context 
     
    259264 
    260265        # Render the result. 
    261         result = buffet.render(engine_name=engine_name, 
     266        if use_legacy_renderer: 
     267            result = buffet.render(engine_name=engine_name, 
    262268                               template_name=template_name, 
    263269                               include_pylons_variables=False, 
    264270                               namespace=namespace) 
     271        else:  
     272            result = tg_render(template_vars=namespace, 
     273                      template_engine=engine_name, 
     274                      template_name=template_name) 
    265275        return result 
    266276 
  • trunk/tg/render.py

    r5132 r5151  
    133133 
    134134def render(template_vars, template_engine=None, template_name=None, **kwargs): 
    135     render_function = app_globals['renderers'].get(template_engine, None) 
     135     
     136    render_function = config['render_functions'].get(template_engine) 
     137     
    136138    if not template_vars:  
    137139        template_vars={} 
    138     tmpl_vars.update(get_tg_vars()) 
     140    template_vars.update(get_tg_vars()) 
    139141    if not render_function: 
    140         render_function = config['tg.default_renderer'
    141         render_function(template_name, template_vars, **kwargs) 
     142        render_function = config['render_functions'][config['default_renderer']
     143    return render_function(template_name, template_vars, **kwargs) 
    142144 
    143145def render_genshi(template_name, template_vars, **kwargs): 
    144146    """Render a the template_vars with the Genshi template""" 
    145147    template_vars['XML'] = XML 
    146     return templating.render_genshi(template_name, extra_vars=templat_vars,  
     148    return templating.render_genshi(template_name, extra_vars=template_vars,  
    147149                                    **kwargs) 
    148150 
  • trunk/tg/wsgiapp.py

    r5140 r5151  
    1 from pylons.wsgiapp import PylonsApp 
     1import sys 
     2from pylons.wsgiapp import PylonsApp, class_name_from_module_name 
    23from pylons.util import class_name_from_module_name 
    34import sys 
    45 
    56class TGApp(PylonsApp): 
    6  
    77    def find_controller(self, controller): 
    88        """Locates a controller by attempting to import it then grab 
     
    2626        #attach the package 
    2727        pylons_package = self.config['pylons.package'] 
    28         full_module_name = pylons_package+'.'+controller_path.replace('/', '.')+'.'+controller.replace('/', '.') 
    29  
    30         print full_module_name 
     28        full_module_name = (pylons_package+'.' +  
     29                            controller_path.replace('/', '.') + 
     30                            '.' + controller.replace('/', '.')) 
    3131 
    3232        # Hide the traceback here if the import fails (bad syntax and such)