def __init__(self, *args, **kw): super(RoutedController, self).__init__(*args, **kw) routes = [] for name in dir(self): value = getattr(self.__class__, name, None) if value is None: continue deco = None if inspect.ismethod(value): # pragma: no cover # PY2 deco = Decoration.get_decoration(value.__func__) elif inspect.isfunction(value): # pragma: no cover # PY3 deco = Decoration.get_decoration(value) if deco is None: continue if hasattr(deco, '_tgext_routes'): routes.extend(deco._tgext_routes) if routes: instance_mapper = Mapper() if self.mapper is not None: instance_mapper.extend(self.mapper.matchlist) instance_mapper.extend(routes) self.mapper = instance_mapper
def test_backward_compatibility_decorator(self): deco = Decoration.get_decoration(BasicTGController.two_validators) validated_params = sorted(list(deco.validation.validators.keys())) assert validated_params == ["a", "someemail"], validated_params deco = Decoration.get_decoration(BasicTGController.tw2form_error_handler) assert deco.validation is None, deco.validation
def __call__(self): log.debug("Registering %s for hook %s on controller %s", self.func, self.hook_name, self.controller) if self.hook_name == 'controller_wrapper': deco = Decoration.get_decoration(self.controller) deco._register_controller_wrapper(self.func) else: deco = Decoration.get_decoration(self.controller) deco._register_hook(self.hook_name, self.func)
def replace_template_hook(remainder, params, output): req = request._current_obj() try: dispatch_state = req._controller_state except: dispatch_state = req.controller_state try: if req.validation['exception']: controller = req.validation['error_handler'] else: controller = dispatch_state.method except (AttributeError, KeyError): controller = dispatch_state.method decoration = Decoration.get_decoration(controller) if 'tg.locals' in req.environ: content_type, engine, template, exclude_names = decoration.lookup_template_engine(req.environ['tg.locals'])[:4] else: content_type, engine, template, exclude_names = decoration.lookup_template_engine(req)[:4] replaced_template = config._pluggable_templates_replacements.get(template) if replaced_template: override_template(decoration.controller, replaced_template)
def plugin(f, *args, **kw): results_dict = f(*args, **kw) user = args[0].user residence_var = "residence" plugins_templates = list() # un plugin est defini pour le scope et residence est defini if scope in plugins_config.mappings and residence_var in results_dict: residence_dn = Residences.get_dn_by_name(user, results_dict[residence_var]) scope_mappings = plugins_config.mappings[scope] for function in scope_mappings: plugin_name = plugin_name_from_function(function) plugin_activated = Plugins.get_by_name(user, residence_dn, plugin_name) if plugin_activated is None: continue #end if template_name = None # obtenir le nom du template à partir du decorator "expose" deco = Decoration.get_decoration(function) try: template_name = deco.engines["text/html"][1] except: pass if template_name is not None: # transformer le nom de template en chemin fichier template_path = ( tg.config['pylons.app_globals'] .dotted_filename_finder .get_dotted_filename(template_name, template_extension='.html') ) # ajouter dans les plugin templates plugins_templates.append(template_path) #end if # executer la fonction du plugin mapping_results = function(results_dict) # constuire le nom de regroupement des variable de ce plugin method_name = function.__name__ plugin_section = str.lower(plugin_name + "_" + method_name) # ajout du groupe au dictionnaire de la methode du controlleur results_dict[plugin_section] = PluginVars(mapping_results) #end for #end if # ajout des templates dans un champs spécial du dictionnaire pour le rendu results_dict["_plugins_templates"] = plugins_templates return results_dict
def test_no_requirements_backward_compatibility(self): deco = Decoration.get_decoration(RootController.force_commit) reqs = deco.requirements deco.requirements = [] requirement = deco.requirement deco.requirements = reqs assert requirement is None, requirement
def __call__(self, path, **params): config = tg.config._current_obj() try: func = config['_pluggable_partials_cache'][path] except: func = config['_pluggable_partials_cache'][path] = self.resolve(path) result = func(**params) if not isinstance(result, dict): return result #Expect partials not to expose more than one template available_engines = list(Decoration.get_decoration(func).engines.values()) engine_name, template_name, exclude_names = available_engines[0][:3] replaced_template = config.get('_pluggable_templates_replacements', {}).get(template_name) if replaced_template: engine_name, template_name = replaced_template.split(':', 1) #Avoid placing the doctype declaration in genshi templates render_params = {} if engine_name == 'genshi': render_params['doctype'] = None return tg_render(template_vars=result, template_engine=engine_name, template_name=template_name, **render_params)
def test_lazy_inheritance_with_3nested_template(self): milestones.renderers_ready._reset() class BaseController(tg.TGController): @tg.expose('template.html') @tg.expose('template.html', content_type='text/plain') @tg.expose('template.html', content_type='text/javascript') def func(self): pass class SubController(BaseController): @tg.expose('new_template.html', inherit=True) @tg.expose('new_template.html', content_type='text/plain') @tg.expose('new_template.html', content_type='text/javascript') def func(self): pass class SubSubController(SubController): @tg.expose('new2_template.html', inherit=True) @tg.expose('new2_template.html', content_type='text/javascript') def func(self): pass class SubSubSubController(SubSubController): @tg.expose('new3_template.html', inherit=True) def func(self): pass milestones.renderers_ready.reach() deco = Decoration.get_decoration(SubSubSubController.func) assert len(deco.engines) == 3, deco.engines assert deco.engines['text/html'][1] == 'new3_template.html', deco.engines assert deco.engines['text/plain'][1] == 'new_template.html', deco.engines assert deco.engines['text/javascript'][1] == 'new2_template.html', deco.engines
def notify(self, hook_name, args=None, kwargs=None, controller=None, context_config=None): """Notifies a TurboGears hook. Each function registered for the given hook will be executed, ``args`` and ``kwargs`` will be passed to the registered functions as arguments. It permits to notify both application hooks:: tg.hooks.notify('custom_global_hook') Or controller hooks:: tg.hooks.notify('before_render', args=(remainder, params, output), controller=RootController.index) """ if context_config is None: #pragma: no cover context_config = tg.config._current_obj() args = args or [] kwargs = kwargs or {} try: syswide_hooks = context_config['hooks'][hook_name] for func in syswide_hooks: func(*args, **kwargs) except KeyError: #pragma: no cover pass if controller is not None: controller = default_im_func(controller) deco = Decoration.get_decoration(controller) for func in deco.hooks.get(hook_name, []): func(*args, **kwargs)
def notify_with_value(self, hook_name, value, controller=None, context_config=None): """Notifies a TurboGears hook which is expected to return a value. hooks with values are expected to accept an input value an return a replacement for it. Each registered function will receive as input the value returned by the previous function in chain. The resulting value will be returned by the ``notify_with_value`` call itself:: app = tg.hooks.notify_with_value('before_config', app) """ if context_config is None: #pragma: no cover context_config = tg.config._current_obj() try: syswide_hooks = context_config['hooks'][hook_name] for func in syswide_hooks: value = func(value) except KeyError: #pragma: no cover pass if controller is not None: controller = default_im_func(controller) deco = Decoration.get_decoration(controller) for func in deco.hooks[hook_name]: value = func(value) return value
def __call__(self, func): deco = decorator(self.wrap, func) exposed = Decoration.get_decoration(deco) deco.signatures = self.signatures deco.helpstr = self.helpstr exposed.register_template_engine(\ 'text/xml', config.get('default_renderer', ['mako'])[0], '', [], {}) return deco
def __call__(self, func): deco = Decoration.get_decoration(func) if not hasattr(deco, '_tgext_routes'): deco._tgext_routes = [] deco._tgext_routes.append(Route(func.__name__, self.routing_path, controller=route.CURRENT_CONTROLLER, action=func.__name__, **self.routing_args)) return func
def __call__(self): log.debug("Registering %s for hook %s on controller %s", self.func, self.hook_name, self.controller) if self.hook_name == 'controller_wrapper': config = tg.config._current_obj() dedicated_wrappers = config['dedicated_controller_wrappers'] dedicated_wrappers.setdefault(self.controller, []).append(self.func) else: deco = Decoration.get_decoration(self.controller) deco._register_hook(self.hook_name, self.func)
def render_widget(mount_point, widget_name): app = c.project.app_instance(mount_point) method = getattr(app.widget(app), widget_name) with push_config(c, app=app): result = method() if isinstance(result, dict): deco = Decoration.get_decoration(method) content_type, engine, template, exclude_names = \ deco.lookup_template_engine(request) template_vars = dict((k,v) for k,v in result.iteritems() if k not in exclude_names) return render(template_vars, engine, template) return result
def test_decoration_run_hooks_backward_compatibility(self): # TODO: Remove test when Decoration.run_hooks gets removed def func(*args, **kw): pass def hook(*args, **kw): hook.did_run = True hook.did_run = False milestones.renderers_ready.reach() tg.hooks.register('before_call', hook, controller=func) deco = Decoration.get_decoration(func) deco.run_hooks(Bunch(config=None), 'before_call') assert hook.did_run is True
def replace_template_hook(remainder, params, output): req = request._current_obj() try: dispatch_state = req._controller_state except: dispatch_state = req.controller_state decoration = Decoration.get_decoration(dispatch_state.method) if 'tg.locals' in req.environ: content_type, engine, template, exclude_names = decoration.lookup_template_engine(req.environ['tg.locals'])[:4] else: content_type, engine, template, exclude_names = decoration.lookup_template_engine(req)[:4] replaced_template = config._pluggable_templates_replacements.get(template) if replaced_template: override_template(dispatch_state.method, replaced_template)
def test_lazy_inheritance(self): milestones.renderers_ready._reset() class BaseController(tg.TGController): @tg.expose('template.html') def func(self): pass class SubController(BaseController): @tg.expose(inherit=True) def func(self): pass milestones.renderers_ready.reach() deco = Decoration.get_decoration(SubController.func) assert len(deco.engines) == 1, deco.engines assert deco.engines['text/html'][1] == 'template.html', deco.engines
def __call__(self, path, **params): config = tg.config._current_obj() try: func = config['_pluggable_partials_cache'][path] except: func = config['_pluggable_partials_cache'][path] = self.resolve(path) result = func(**params) if not isinstance(result, dict): return result #Expect partials not to expose more than one template engine_name, template_name, exclude_names = Decoration.get_decoration(func).engines.values()[0][:3] replaced_template = config.get('_pluggable_templates_replacements', {}).get(template_name) if replaced_template: engine_name, template_name = replaced_template.split(':', 1) return tg_render(template_vars=result, template_engine=engine_name, template_name=template_name, doctype=None)
def add_expose_info(app, what, name, obj, options, lines): if (what != 'method' or not hasattr(obj, 'decoration') or not obj.im_class.__name__.endswith('Controller')): return deco = Decoration.get_decoration(obj) if not hasattr(deco, 'expose'): return try: # TODO: This ignores all but the first tmpl engine engine = deco.engines.values()[0] if engine[0] == 'genshi': template = engine[1] lines.append("\n") lines.append("\n") lines.append("Renders: :data:`%s`" % template) except: pass
def test_expose_idempotent(self): base_config = TestConfig(folder = 'dispatch', values = {'use_sqlalchemy': False, 'use_toscawidgets': False, 'use_toscawidgets2': False, 'ignore_parameters': ["ignore", "ignore_me"] }) app = app_from_config(base_config) exposition = tg.expose('nonexisting') @exposition @exposition def func(*args, **kw): pass milestones.renderers_ready.reach() deco = Decoration.get_decoration(func) assert len(deco.engines) == 1, deco.engines
def register_controller_wrapper(self, wrapper, controller=None): """Registers a TurboGears controller wrapper. Controller Wrappers are much like a **decorator** applied to every controller. They receive the next handler in chain and are expected to return a new handler that performs whatever it requires and then calls the next handler. A simple example for a controller wrapper is a simple logging wrapper:: def controller_wrapper(caller): def call(*args, **kw): try: print 'Before handler!' return caller(*args, **kw) finally: print 'After Handler!' return call base_config.register_controller_wrapper(controller_wrapper) It is also possible to register wrappers for a specific controller:: base_config.register_controller_wrapper(controller_wrapper, controller=RootController.index) """ if milestones.environment_loaded.reached: log.warning('Controller Wrapper %s registered after environment loaded ' 'milestone has been reached, the wrapper will be used only ' 'for future TGApp instances.', wrapper) log.debug("Registering %s controller wrapper for controller: %s", wrapper, controller or 'ALL') if controller is None: self._controller_wrappers.append(wrapper) else: from tg.decorators import Decoration deco = Decoration.get_decoration(controller) deco._register_controller_wrapper(wrapper)
def multiple_engines(self): deco = Decoration.get_decoration(self.multiple_engines) used_engine = deco.engines.get('text/html')[0] return dict(format=used_engine, status='ok')
def test_multiple_requirements_backward_compatibility(self): deco = Decoration.get_decoration(RootController.force_commit) predicate = deco.requirement.predicate assert isinstance(predicate, has_permission), predicate
def test_multiple_requirements_all_registered(self): deco = Decoration.get_decoration(RootController.force_commit) assert len(deco.requirements) == 2, deco.requirements
def __call__(self, func): decoration = Decoration.get_decoration(func) decoration.register_hook('before_validate', self.before_validate) decoration.register_hook('before_call', self.before_call) return func