From 0b13e1ae46ec25722f5651c73b8510e4336dedc5 Mon Sep 17 00:00:00 2001 From: Michael Merickel Date: Tue, 5 Jul 2011 18:06:34 -0500 Subject: Refactored the mount code into config.include. --- pyramid/config.py | 110 +++++++++++++++++++------------------------ pyramid/tests/test_config.py | 28 +++++------ 2 files changed, 61 insertions(+), 77 deletions(-) diff --git a/pyramid/config.py b/pyramid/config.py index 61463eb86..b39cb365e 100644 --- a/pyramid/config.py +++ b/pyramid/config.py @@ -269,7 +269,11 @@ class Configurator(object): Pyramid's caller. By default, the ``pyramid.httpexceptions.default_exceptionresponse_view`` function is used as the ``exceptionresponse_view``. This argument is new - in Pyramid 1.1. """ + in Pyramid 1.1. + + If ``route_prefix`` is passed, all routes added with + :meth:`pyramid.config.Configurator.add_route` will have the specified path + prepended to their pattern. This parameter is new in Pyramid 1.x.""" manager = manager # for testing injection venusian = venusian # for testing injection @@ -293,7 +297,7 @@ class Configurator(object): default_view_mapper=None, autocommit=False, exceptionresponse_view=default_exceptionresponse_view, - root_route_name=None, + route_prefix=None, ): if package is None: package = caller_package() @@ -303,7 +307,7 @@ class Configurator(object): self.package = name_resolver.package self.registry = registry self.autocommit = autocommit - self.root_route_name = root_route_name + self.route_prefix = route_prefix if registry is None: registry = Registry(self.package_name) self.registry = registry @@ -455,6 +459,7 @@ class Configurator(object): registerCommonDirectives(context) context.registry = self.registry context.autocommit = autocommit + context.route_prefix = self.route_prefix return context # API @@ -522,10 +527,14 @@ class Configurator(object): # unwrap and reset the context self._ctx = None - def include(self, *callables): - """Include one or more configuration callables, to support imperative + def include(self, callable, route_prefix=None): + """Include a configuration callables, to support imperative application extensibility. + .. warning:: In versions of :app:`Pyramid` prior to 1.x, this + function accepted ``*callables``, but this has been changed + to support only a single callable. + A configuration callable should be a callable that accepts a single argument named ``config``, which will be an instance of a :term:`Configurator` (be warned that it will not be the same @@ -534,7 +543,7 @@ class Configurator(object): methods on the configurator passed to it which add configuration state. The return value of a callable will be ignored. - Values allowed to be presented via the ``*callables`` argument to + Values allowed to be presented via the ``callable`` argument to this method: any callable Python object or any :term:`dotted Python name` which resolves to a callable Python object. It may also be a Python :term:`module`, in which case, the module will be searched for @@ -583,65 +592,41 @@ class Configurator(object): Included configuration statements will be overridden by local configuration statements if an included callable causes a configuration conflict by registering something with the same - configuration parameters.""" + configuration parameters. + + If the ``route_prefix`` argument is supplied, any calls to + :meth:`pyramid.config.Configurator.add_route` within the ``callable`` + will have their pattern be prefixed by ``route_prefix``. This can + be used to help mount a set of routes at a different location than + the author intended while still keeping the same route names. This + parameter is new as of Pyramid 1.x.""" _context = self._ctx if _context is None: _context = self._ctx = self._make_context(self.autocommit) - for c in callables: - c = self.maybe_dotted(c) - module = inspect.getmodule(c) - if module is c: - c = getattr(module, 'includeme') - spec = module.__name__ + ':' + c.__name__ - sourcefile = inspect.getsourcefile(c) - if _context.processSpec(spec): - context = GroupingContextDecorator(_context) - context.basepath = os.path.dirname(sourcefile) - context.includepath = _context.includepath + (spec,) - context.package = package_of(module) - config = self.__class__.with_context(context) - c(config) - - def with_route_prefix(self, route_prefix): - configurator = self.__class__(registry=self.registry, - package=self.package, - autocommit=self.autocommit) - configurator.route_prefix = route_prefix - return configurator - - def mount_subapplication(self, function, route_prefix): - """ mount subapplication with ``route_prefix`` - - - .. code-block:: python - :linenos: - - from pyramid.config import Configurator - - def main(global_config, **settings): - config = Configurator() - config.mount('myapp.myconfig.includeme', '/admin') - - ``myapp.myconfig`` is subapplication - and ``includeme`` is that mount point. - - .. code-block:: python - :linenos: - - from pyramid.config import Configurator - - def includeme(config): - config.add_route('projects', '/projects') - - - Subapplication's routes are registerd with the ``route_prefix`` - In this case, ``projects`` route is registered with ``/admin/projects`` pattern. - """ - function = self.maybe_dotted(function) - config = self.with_route_prefix(route_prefix) - function(config) + if self.route_prefix: + old_prefix = self.route_prefix.rstrip('/') + '/' + else: + old_prefix = '' + + if route_prefix: + route_prefix = old_prefix + route_prefix.lstrip('/') + + c = self.maybe_dotted(callable) + module = inspect.getmodule(c) + if module is c: + c = getattr(module, 'includeme') + spec = module.__name__ + ':' + c.__name__ + sourcefile = inspect.getsourcefile(c) + if _context.processSpec(spec): + context = GroupingContextDecorator(_context) + context.basepath = os.path.dirname(sourcefile) + context.includepath = _context.includepath + (spec,) + context.package = package_of(module) + context.route_prefix = route_prefix + config = self.__class__.with_context(context) + c(config) def add_directive(self, name, directive, action_wrap=True): """ @@ -689,7 +674,8 @@ class Configurator(object): :meth:`pyramid.config.Configurator.include` to obtain a configurator with 'the right' context. Returns a new Configurator instance.""" configurator = cls(registry=context.registry, package=context.package, - autocommit=context.autocommit) + autocommit=context.autocommit, + route_prefix=context.route_prefix) configurator._ctx = context return configurator @@ -1972,7 +1958,7 @@ class Configurator(object): if pattern is None: raise ConfigurationError('"pattern" argument may not be None') - if hasattr(self, "route_prefix"): + if self.route_prefix: pattern = self.route_prefix.rstrip('/') + '/' + pattern.lstrip('/') discriminator = ['route', name, xhr, request_method, path_info, diff --git a/pyramid/tests/test_config.py b/pyramid/tests/test_config.py index 3423b9784..9a92cd052 100644 --- a/pyramid/tests/test_config.py +++ b/pyramid/tests/test_config.py @@ -251,6 +251,7 @@ class ConfiguratorTests(unittest.TestCase): config._ctx = DummyContext() config._ctx.registry = None config._ctx.autocommit = True + config._ctx.route_prefix = None newconfig = config.with_package(pyramid.tests) self.assertEqual(newconfig.package, pyramid.tests) @@ -735,6 +736,18 @@ class ConfiguratorTests(unittest.TestCase): self.assertEqual(context_after.includepath, ()) self.assertTrue(context_after is context_before) + def test_include_with_route_prefix(self): + root_config = self._makeOne(autocommit=True) + def dummy_subapp(config): + self.assertEqual(config.route_prefix, 'root') + root_config.include(dummy_subapp, route_prefix='root') + + def test_include_with_nested_route_prefix(self): + root_config = self._makeOne(autocommit=True, route_prefix='root') + def dummy_subapp(config): + self.assertEqual(config.route_prefix, 'root/nested') + root_config.include(dummy_subapp, route_prefix='nested') + def test_with_context(self): config = self._makeOne() ctx = config._make_context() @@ -1997,7 +2010,6 @@ class ConfiguratorTests(unittest.TestCase): self.assertEqual(route.name, 'name') def test_add_route_with_route_prefix(self): - from pyramid.interfaces import IRoutesMapper config = self._makeOne(autocommit=True) config.route_prefix = 'root' route = config.add_route('name', 'path') @@ -2006,20 +2018,6 @@ class ConfiguratorTests(unittest.TestCase): self._assertRoute(config, 'name', 'root/path') - def test_with_route_prefix(self): - root_config = self._makeOne(autocommit=True) - config = root_config.with_route_prefix('root') - self.assertEqual(config.registry, root_config.registry) - self.assertEqual(config.package, root_config.package) - self.assertEqual(config.route_prefix, 'root') - - def test_mount_subapplication(self): - root_config = self._makeOne(autocommit=True) - def dummy_subapp(config): - self.assertEqual(config.route_prefix, 'root') - root_config.mount_subapplication(dummy_subapp, - route_prefix='root') - def test_add_route_with_factory(self): config = self._makeOne(autocommit=True) factory = object() -- cgit v1.2.3 From 4880e19588da868f6075fc73d1f6ee1eb1e6ba6e Mon Sep 17 00:00:00 2001 From: Michael Merickel Date: Tue, 5 Jul 2011 20:54:00 -0500 Subject: garden --- pyramid/config.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/pyramid/config.py b/pyramid/config.py index b39cb365e..bad12fc20 100644 --- a/pyramid/config.py +++ b/pyramid/config.py @@ -594,12 +594,12 @@ class Configurator(object): configuration conflict by registering something with the same configuration parameters. - If the ``route_prefix`` argument is supplied, any calls to + If the ``route_prefix`` is supplied, any calls to :meth:`pyramid.config.Configurator.add_route` within the ``callable`` - will have their pattern be prefixed by ``route_prefix``. This can + will have their pattern prefixed with ``route_prefix``. This can be used to help mount a set of routes at a different location than - the author intended while still keeping the same route names. This - parameter is new as of Pyramid 1.x.""" + the ``callable``-author intended while still maintaining the same + route names. This parameter is new as of Pyramid 1.x.""" _context = self._ctx if _context is None: -- cgit v1.2.3