diff options
| author | Chris McDonough <chrism@plope.com> | 2010-12-18 03:33:35 -0500 |
|---|---|---|
| committer | Chris McDonough <chrism@plope.com> | 2010-12-18 03:33:35 -0500 |
| commit | 92c3e502494714884b7a051721c9b322027369a1 (patch) | |
| tree | 3cd5a871ff5b13cf48be0fec45b9f13c8d451341 | |
| parent | 515d0f977f21bf28602505b859f64f10dd2f5f59 (diff) | |
| download | pyramid-92c3e502494714884b7a051721c9b322027369a1.tar.gz pyramid-92c3e502494714884b7a051721c9b322027369a1.tar.bz2 pyramid-92c3e502494714884b7a051721c9b322027369a1.zip | |
resource -> asset
29 files changed, 383 insertions, 569 deletions
diff --git a/docs/api/config.rst b/docs/api/config.rst index 64dc4d0dd..4b23f3e8e 100644 --- a/docs/api/config.rst +++ b/docs/api/config.rst @@ -78,7 +78,7 @@ .. automethod:: testing_securitypolicy - .. automethod:: testing_models + .. automethod:: testing_resources .. automethod:: testing_add_subscriber diff --git a/docs/api/request.rst b/docs/api/request.rst index acd66ccf8..13b434a51 100644 --- a/docs/api/request.rst +++ b/docs/api/request.rst @@ -26,7 +26,7 @@ .. attribute:: root The :term:`root` object will be available as the ``root`` - attribute of the :term:`request` object. It will be the model + attribute of the :term:`request` object. It will be the resource object at which traversal started (the root). See :ref:`traversal_chapter` for information about root objects. diff --git a/docs/api/traversal.rst b/docs/api/traversal.rst index b89691847..cd4765e04 100644 --- a/docs/api/traversal.rst +++ b/docs/api/traversal.rst @@ -7,13 +7,13 @@ .. autofunction:: find_interface - .. autofunction:: find_model + .. autofunction:: find_resource .. autofunction:: find_root - .. autofunction:: model_path + .. autofunction:: resource_path - .. autofunction:: model_path_tuple + .. autofunction:: resource_path_tuple .. autofunction:: quote_path_segment diff --git a/docs/api/url.rst b/docs/api/url.rst index 8c702a3fb..1aa3082b7 100644 --- a/docs/api/url.rst +++ b/docs/api/url.rst @@ -5,7 +5,7 @@ .. automodule:: pyramid.url - .. autofunction:: pyramid.url.model_url(context, request, *elements, query=None, anchor=None) + .. autofunction:: pyramid.url.resource_url(context, request, *elements, query=None, anchor=None) .. autofunction:: route_url diff --git a/docs/narr/environment.rst b/docs/narr/environment.rst index 08fa7af44..8cad9a666 100644 --- a/docs/narr/environment.rst +++ b/docs/narr/environment.rst @@ -3,7 +3,7 @@ single: settings single: reload single: debug_authorization - single: reload_resources + single: reload_assets single: debug_notfound single: debug_all single: reload_all @@ -52,21 +52,25 @@ template rendering extensions. | | | +---------------------------------+-----------------------------+ -Reloading Resources -------------------- +Reloading Assets +---------------- -Don't cache any resource file data when this value is true. See -also :ref:`overriding_resources_section`. +Don't cache any asset file data when this value is true. See +also :ref:`overriding_assets_section`. +---------------------------------+-----------------------------+ | Environment Variable Name | Config File Setting Name | +=================================+=============================+ -| ``BFG_RELOAD_RESOURCES`` | ``reload_resources`` | +| ``BFG_RELOAD_ASSETS` ` | ``reload_assets`` | | | | | | | | | | +---------------------------------+-----------------------------+ +.. note:: For backwards compatibility purposes, the following aliases can be + used for configurating asset reloading: ``BFG_RELOAD_RESOURCES`` (envvar) + and ``reload_resources`` (config file). + Debugging Authorization ----------------------- @@ -174,7 +178,7 @@ Mako Directories ++++++++++++++++ The value(s) supplied here are passed in as the template directories. They -should be in :term:`resource specification` format, for example: +should be in :term:`asset specification` format, for example: ``my.package:templates``. +-----------------------------+ @@ -333,40 +337,38 @@ affect settings that do not start with ``reload_*`` such as .. index:: single: reload_templates - single: reload_resources - -Understanding the Distinction Between ``reload_templates`` and ``reload_resources`` ------------------------------------------------------------------------------------ - -The difference between ``reload_resources`` and ``reload_templates`` -is a bit subtle. Templates are themselves also treated by -:app:`Pyramid` as :term:`pkg_resources` resource files (along with -static files and other resources), so the distinction can be -confusing. It's helpful to read :ref:`overriding_resources_section` -for some context about resources in general. - -When ``reload_templates`` is true, :app:`Pyramid` takes advantage -of the underlying templating systems' ability to check for file -modifications to an individual template file. When -``reload_templates`` is true but ``reload_resources`` is *not* true, -the template filename returned by pkg_resources is cached by -:app:`Pyramid` on the first request. Subsequent requests for the -same template file will return a cached template filename. The -underlying templating system checks for modifications to this -particular file for every request. Setting ``reload_templates`` to -``True`` doesn't affect performance dramatically (although it should -still not be used in production because it has some effect). - -However, when ``reload_resources`` is true, :app:`Pyramid` will not -cache the template filename, meaning you can see the effect of -changing the content of an overridden resource directory for templates -without restarting the server after every change. Subsequent requests -for the same template file may return different filenames based on the -current state of overridden resource directories. Setting -``reload_resources`` to ``True`` affects performance *dramatically*, -slowing things down by an order of magnitude for each template -rendering. However, it's convenient to enable when moving files -around in overridden resource directories. ``reload_resources`` makes -the system *very slow* when templates are in use. Never set -``reload_resources`` to ``True`` on a production system. + single: reload_assets + +Understanding the Distinction Between ``reload_templates`` and ``reload_assets`` +-------------------------------------------------------------------------------- + +The difference between ``reload_assets`` and ``reload_templates`` is a bit +subtle. Templates are themselves also treated by :app:`Pyramid` as asset +files (along with other static files), so the distinction can be confusing. +It's helpful to read :ref:`overriding_assets_section` for some context +about assets in general. + +When ``reload_templates`` is true, :app:`Pyramid` takes advantage of the +underlying templating systems' ability to check for file modifications to an +individual template file. When ``reload_templates`` is true but +``reload_assets`` is *not* true, the template filename returned by the +``pkg_resources`` package (used under the hood by asset resolution) is cached +by :app:`Pyramid` on the first request. Subsequent requests for the same +template file will return a cached template filename. The underlying +templating system checks for modifications to this particular file for every +request. Setting ``reload_templates`` to ``True`` doesn't affect performance +dramatically (although it should still not be used in production because it +has some effect). + +However, when ``reload_assets`` is true, :app:`Pyramid` will not cache the +template filename, meaning you can see the effect of changing the content of +an overridden asset directory for templates without restarting the server +after every change. Subsequent requests for the same template file may +return different filenames based on the current state of overridden asset +directories. Setting ``reload_assets`` to ``True`` affects performance +*dramatically*, slowing things down by an order of magnitude for each +template rendering. However, it's convenient to enable when moving files +around in overridden asset directories. ``reload_assets`` makes the system +*very slow* when templates are in use. Never set ``reload_assets`` to +``True`` on a production system. diff --git a/docs/zcml/aclauthorizationpolicy.rst b/docs/zcml/aclauthorizationpolicy.rst index 2c66da0c8..f09531415 100644 --- a/docs/zcml/aclauthorizationpolicy.rst +++ b/docs/zcml/aclauthorizationpolicy.rst @@ -4,7 +4,7 @@ -------------------------- When this directive is used, authorization information is obtained -from :term:`ACL` objects attached to model instances. +from :term:`ACL` objects attached to :term:`resource` objects. Attributes ~~~~~~~~~~ diff --git a/docs/zcml/resource.rst b/docs/zcml/asset.rst index 3f7c58faa..af7a6db94 100644 --- a/docs/zcml/resource.rst +++ b/docs/zcml/asset.rst @@ -1,51 +1,51 @@ -.. _resource_directive: +.. _asset_directive: -``resource`` ------------- +``asset`` +--------- -The ``resource`` directive adds a resource override for a single -resource. +The ``asset`` directive adds an asset override for a single +static file/directory asset. Attributes ~~~~~~~~~~ ``to_override`` - A :term:`resource specification` specifying the resource to be + A :term:`asset specification` specifying the asset to be overridden. ``override_with`` - A :term:`resource specification` specifying the resource which + A :term:`asset specification` specifying the asset which is used as the override. Examples ~~~~~~~~ -.. topic:: Overriding a Single Resource File +.. topic:: Overriding a Single Asset File .. code-block:: xml :linenos: - <resource + <asset to_override="some.package:templates/mytemplate.pt" override_with="another.package:othertemplates/anothertemplate.pt" /> -.. topic:: Overriding all Resources in a Package +.. topic:: Overriding all Assets in a Package .. code-block:: xml :linenos: - <resource + <asset to_override="some.package" override_with="another.package" /> -.. topic:: Overriding all Resources in a Subdirectory of a Package +.. topic:: Overriding all Assets in a Subdirectory of a Package .. code-block:: xml :linenos: - <resource + <asset to_override="some.package:templates/" override_with="another.package:othertemplates/" /> @@ -53,10 +53,13 @@ Examples Alternatives ~~~~~~~~~~~~ -The :meth:`pyramid.config.Configurator.override_resource` +The :meth:`pyramid.config.Configurator.override_asset` method can be used instead of the ``resource`` ZCML directive. +This directive can also be invoked as the ``resource`` ZCML directive for +backwards compatibility purposes. + See Also ~~~~~~~~ -See also :ref:`resource_zcml_directive`. +See also :ref:`asset_zcml_directive`. diff --git a/docs/zcml/handler.rst b/docs/zcml/handler.rst index 301bf7895..01d442ab6 100644 --- a/docs/zcml/handler.rst +++ b/docs/zcml/handler.rst @@ -28,7 +28,7 @@ Attributes ``factory`` The :term:`dotted Python name` to a function that will generate a :app:`Pyramid` context object when the associated route matches. - e.g. ``mypackage.models.MyFactoryClass``. If this argument is not + e.g. ``mypackage.resources.MyResource``. If this argument is not specified, a default root factory will be used. ``xhr`` diff --git a/docs/zcml/route.rst b/docs/zcml/route.rst index 4f7cdb955..ac9261e27 100644 --- a/docs/zcml/route.rst +++ b/docs/zcml/route.rst @@ -25,7 +25,7 @@ Attributes ``factory`` The :term:`dotted Python name` to a function that will generate a :app:`Pyramid` context object when this route matches. - e.g. ``mypackage.models.MyFactoryClass``. If this argument is not + e.g. ``mypackage.resources.MyResource``. If this argument is not specified, a default root factory will be used. ``view`` diff --git a/docs/zcml/view.rst b/docs/zcml/view.rst index 74d497cb3..6887f88fb 100644 --- a/docs/zcml/view.rst +++ b/docs/zcml/view.rst @@ -157,7 +157,7 @@ Predicate Attributes representing the class that a graph traversal parent object of the :term:`context` must be an instance of (or :term:`interface` that a parent object must provide) in order for this view to be found and - called. Your models must be "location-aware" to use this feature. + called. Your resources must be "location-aware" to use this feature. See :ref:`location_aware` for more information about location-awareness. @@ -222,7 +222,7 @@ Examples :linenos: <view - context=".models.MyModel" + context=".resources.MyResource" view=".views.hello_world" /> @@ -232,7 +232,7 @@ Examples :linenos: <view - context=".models.MyModel" + context=".resources.MyResource" view=".views.hello_world_post" request_method="POST" /> diff --git a/pyramid/config.py b/pyramid/config.py index 2e64d49e9..c82e15ae6 100644 --- a/pyramid/config.py +++ b/pyramid/config.py @@ -73,8 +73,8 @@ from pyramid.path import package_of from pyramid.registry import Registry from pyramid.renderers import RendererHelper from pyramid.request import route_request_iface -from pyramid.resource import PackageOverrides -from pyramid.resource import resolve_resource_spec +from pyramid.asset import PackageOverrides +from pyramid.asset import resolve_asset_spec from pyramid.settings import Settings from pyramid.static import StaticURLInfo from pyramid.threadlocal import get_current_registry @@ -327,14 +327,14 @@ class Configurator(object): self.action(IAuthorizationPolicy, None) def _make_spec(self, path_or_spec): - package, filename = resolve_resource_spec(path_or_spec, - self.package_name) + package, filename = resolve_asset_spec(path_or_spec, + self.package_name) if package is None: return filename # absolute filename return '%s:%s' % (package, filename) def _split_spec(self, path_or_spec): - return resolve_resource_spec(path_or_spec, self.package_name) + return resolve_asset_spec(path_or_spec, self.package_name) def _derive_view(self, view, permission=None, predicates=(), attr=None, renderer=None, wrapper_viewname=None, @@ -570,19 +570,21 @@ class Configurator(object): this Configurator's constructor.""" return self.name_resolver.maybe_resolve(dotted) - def absolute_resource_spec(self, relative_spec): - """ Resolve the potentially relative :term:`resource + def absolute_asset_spec(self, relative_spec): + """ Resolve the potentially relative :term:`asset specification` string passed as ``relative_spec`` into an - absolute resource specification string and return the string. + absolute asset specification string and return the string. Use the ``package`` of this configurator as the package to - which the resource specification will be considered relative - when generating an absolute resource specification. If the + which the asset specification will be considered relative + when generating an absolute asset specification. If the provided ``relative_spec`` argument is already absolute, or if the ``relative_spec`` is not a string, it is simply returned.""" if not isinstance(relative_spec, basestring): return relative_spec return self._make_spec(relative_spec) + absolute_resource_spec = absolute_asset_spec # b/w compat forever + def setup_registry(self, settings=None, root_factory=None, authentication_policy=None, authorization_policy=None, renderers=DEFAULT_RENDERERS, debug_logger=None, @@ -2283,18 +2285,18 @@ class Configurator(object): self.registry.registerUtility(policy, IAuthorizationPolicy) self.registry.registerUtility(policy, IAuthenticationPolicy) - def testing_models(self, models): + def testing_resources(self, resources): """Unit/integration testing helper: registers a dictionary of - :term:`model` objects that can be resolved via the - :func:`pyramid.traversal.find_model` API. + :term:`resource` objects that can be resolved via the + :func:`pyramid.traversal.find_resource` API. - The :func:`pyramid.traversal.find_model` API is called with + The :func:`pyramid.traversal.find_resource` API is called with a path as one of its arguments. If the dictionary you register when calling this method contains that path as a string key (e.g. ``/foo/bar`` or ``foo/bar``), the - corresponding value will be returned to ``find_model`` (and + corresponding value will be returned to ``find_resource`` (and thus to your code) when - :func:`pyramid.traversal.find_model` is called with an + :func:`pyramid.traversal.find_resource` is called with an equivalent path string or tuple. """ class DummyTraverserFactory: @@ -2303,14 +2305,16 @@ class Configurator(object): def __call__(self, request): path = request['PATH_INFO'] - ob = models[path] + ob = resources[path] traversed = traversal_path(path) return {'context':ob, 'view_name':'','subpath':(), 'traversed':traversed, 'virtual_root':ob, 'virtual_root_path':(), 'root':ob} self.registry.registerAdapter(DummyTraverserFactory, (Interface,), ITraverser) - return models + return resources + + testing_models = testing_resources # b/w compat @action_method def testing_add_subscriber(self, event_iface=None): diff --git a/pyramid/includes/meta.zcml b/pyramid/includes/meta.zcml index 864cff564..9f3726cc9 100644 --- a/pyramid/includes/meta.zcml +++ b/pyramid/includes/meta.zcml @@ -49,7 +49,7 @@ <meta:directive name="resource" schema="pyramid.zcml.IAssetDirective" - handler="pyramid.zcml.resource" + handler="pyramid.zcml.asset" /> <meta:directive diff --git a/pyramid/mako_templating.py b/pyramid/mako_templating.py index a5f9b0f68..9d14ca8fe 100644 --- a/pyramid/mako_templating.py +++ b/pyramid/mako_templating.py @@ -4,10 +4,10 @@ import threading from zope.interface import implements from zope.interface import Interface -from pyramid.interfaces import ITemplateRenderer +from pyramid.asset import resolve_asset_spec +from pyramid.asset import abspath_from_asset_spec from pyramid.exceptions import ConfigurationError -from pyramid.resource import resolve_resource_spec -from pyramid.resource import abspath_from_resource_spec +from pyramid.interfaces import ITemplateRenderer from pyramid.settings import asbool from pyramid.util import DottedNameResolver @@ -18,12 +18,11 @@ class IMakoLookup(Interface): pass class PkgResourceTemplateLookup(TemplateLookup): - """TemplateLookup subclass that handles resource specification - uri's""" + """TemplateLookup subclass that handles asset specification URIs""" def adjust_uri(self, uri, relativeto): """Called from within a Mako template, avoids adjusting the - uri if it looks like a resource specification""" - # Don't adjust pkg resource spec names + uri if it looks like an asset specification""" + # Don't adjust asset spec names if ':' in uri: return uri return TemplateLookup.adjust_uri(self, uri, relativeto) @@ -33,7 +32,7 @@ class PkgResourceTemplateLookup(TemplateLookup): for it In addition to the basic filesystem lookup, this subclass will - use pkg_resource to load a file using the resource + use pkg_resource to load a file using the asset specification syntax. """ @@ -45,8 +44,8 @@ class PkgResourceTemplateLookup(TemplateLookup): else: return self._collection[uri] except KeyError: - pname, path = resolve_resource_spec(uri) - srcfile = abspath_from_resource_spec(path, pname) + pname, path = resolve_asset_spec(uri) + srcfile = abspath_from_asset_spec(path, pname) if os.path.isfile(srcfile): return self._load(srcfile, uri) raise exceptions.TopLevelLookupException( @@ -75,9 +74,9 @@ def renderer_factory(info): 'Mako template used without a ``mako.directories`` setting') if not hasattr(directories, '__iter__'): directories = filter(None, directories.splitlines()) - directories = [ abspath_from_resource_spec(d) for d in directories ] + directories = [ abspath_from_asset_spec(d) for d in directories ] if module_directory is not None: - module_directory = abspath_from_resource_spec(module_directory) + module_directory = abspath_from_asset_spec(module_directory) if error_handler is not None: dotted = DottedNameResolver(info.package) error_handler = dotted.maybe_resolve(error_handler) diff --git a/pyramid/renderers.py b/pyramid/renderers.py index 69c5f7275..c7fe86452 100644 --- a/pyramid/renderers.py +++ b/pyramid/renderers.py @@ -12,13 +12,13 @@ from pyramid.interfaces import IResponseFactory from pyramid.interfaces import ITemplateRenderer from pyramid.interfaces import IRendererInfo +from pyramid.asset import asset_spec_from_abspath from pyramid.compat import json from pyramid.decorator import reify from pyramid.events import BeforeRender from pyramid.path import caller_package from pyramid.path import package_path from pyramid.response import Response -from pyramid.resource import resource_spec_from_abspath from pyramid.threadlocal import get_current_registry # API @@ -31,14 +31,14 @@ def render(renderer_name, value, request=None, package=None): If the renderer name refers to a file on disk (such as when the renderer is a template), it's usually best to supply the name as a - :term:`resource specification` + :term:`asset specification` (e.g. ``packagename:path/to/template.pt``). - You may supply a relative resource spec as ``renderer_name``. If + You may supply a relative asset spec as ``renderer_name``. If the ``package`` argument is supplied, a relative renderer path - will be converted to an absolute resource specification by + will be converted to an absolute asset specification by combining the package supplied as ``package`` with the relative - resource specification supplied as ``renderer_name``. If you do + asset specification supplied as ``renderer_name``. If you do not supply a ``package`` (or ``package`` is ``None``) the package name of the *caller* of this function will be used as the package. @@ -75,13 +75,13 @@ def render_to_response(renderer_name, value, request=None, package=None): If the renderer name refers to a file on disk (such as when the renderer is a template), it's usually best to supply the name as a - :term:`resource specification`. + :term:`asset specification`. - You may supply a relative resource spec as ``renderer_name``. If + You may supply a relative asset spec as ``renderer_name``. If the ``package`` argument is supplied, a relative renderer name - will be converted to an absolute resource specification by + will be converted to an absolute asset specification by combining the package supplied as ``package`` with the relative - resource specification supplied as ``renderer_name``. If you do + asset specification supplied as ``renderer_name``. If you do not supply a ``package`` (or ``package`` is ``None``) the package name of the *caller* of this function will be used as the package. @@ -114,11 +114,11 @@ def get_renderer(renderer_name, package=None): """ Return the renderer object for the renderer named as ``renderer_name``. - You may supply a relative resource spec as ``renderer_name``. If + You may supply a relative asset spec as ``renderer_name``. If the ``package`` argument is supplied, a relative renderer name - will be converted to an absolute resource specification by + will be converted to an absolute asset specification by combining the package supplied as ``package`` with the relative - resource specification supplied as ``renderer_name``. If you do + asset specification supplied as ``renderer_name``. If you do not supply a ``package`` (or ``package`` is ``None``) the package name of the *caller* of this function will be used as the package. """ @@ -164,11 +164,11 @@ class ChameleonRendererLookup(object): isabs = os.path.isabs(name) if (not isabs) and (not ':' in name) and package: - # relative resource spec + # relative asset spec if not isabs: pp = package_path(package) spec = os.path.join(pp, spec) - spec = resource_spec_from_abspath(spec, package) + spec = asset_spec_from_abspath(spec, package) return spec @property # wait until completely necessary to look up translator @@ -204,7 +204,7 @@ class ChameleonRendererLookup(object): finally: self.lock.release() else: - # spec is a package:relpath resource spec + # spec is a package:relpath asset spec renderer = registry.queryUtility(ITemplateRenderer, name=spec) if renderer is None: try: @@ -218,10 +218,10 @@ class ChameleonRendererLookup(object): filename) if not pkg_resources.resource_exists(package_name, filename): raise ValueError( - 'Missing template resource: %s (%s)' % (spec, abspath)) + 'Missing template asset: %s (%s)' % (spec, abspath)) renderer = self.impl(abspath, self) settings = info.settings or {} - if not settings.get('reload_resources'): + if not settings.get('reload_assets'): # cache the template self.lock.acquire() try: diff --git a/pyramid/request.py b/pyramid/request.py index 302685d7e..4339f9ae3 100644 --- a/pyramid/request.py +++ b/pyramid/request.py @@ -219,6 +219,9 @@ class Request(WebobRequest): from pyramid.url import model_url resource_url(resource, request) + + .. note:: For backwards compatibility purposes, this method can also + be called as :meth:`pyramid.request.Request.model_url`. """ return resource_url(resource, self, *elements, **kw) diff --git a/pyramid/resource.py b/pyramid/resource.py index e1d25d0d4..6c847ac1a 100644 --- a/pyramid/resource.py +++ b/pyramid/resource.py @@ -1,207 +1,5 @@ -import os -import pkg_resources - -from zope.interface import implements - -from pyramid.interfaces import IPackageOverrides - -from pyramid.path import package_path -from pyramid.path import package_name -from pyramid.threadlocal import get_current_registry - -class OverrideProvider(pkg_resources.DefaultProvider): - def __init__(self, module): - pkg_resources.DefaultProvider.__init__(self, module) - self.module_name = module.__name__ - - def _get_overrides(self): - reg = get_current_registry() - overrides = reg.queryUtility(IPackageOverrides, self.module_name) - return overrides - - def get_resource_filename(self, manager, resource_name): - """ Return a true filesystem path for resource_name, - co-ordinating the extraction with manager, if the resource - must be unpacked to the filesystem. - """ - overrides = self._get_overrides() - if overrides is not None: - filename = overrides.get_filename(resource_name) - if filename is not None: - return filename - return pkg_resources.DefaultProvider.get_resource_filename( - self, manager, resource_name) - - def get_resource_stream(self, manager, resource_name): - """ Return a readable file-like object for resource_name.""" - overrides = self._get_overrides() - if overrides is not None: - stream = overrides.get_stream(resource_name) - if stream is not None: - return stream - return pkg_resources.DefaultProvider.get_resource_stream( - self, manager, resource_name) - - def get_resource_string(self, manager, resource_name): - """ Return a string containing the contents of resource_name.""" - overrides = self._get_overrides() - if overrides is not None: - string = overrides.get_string(resource_name) - if string is not None: - return string - return pkg_resources.DefaultProvider.get_resource_string( - self, manager, resource_name) - - def has_resource(self, resource_name): - overrides = self._get_overrides() - if overrides is not None: - result = overrides.has_resource(resource_name) - if result is not None: - return result - return pkg_resources.DefaultProvider.has_resource( - self, resource_name) - - def resource_isdir(self, resource_name): - overrides = self._get_overrides() - if overrides is not None: - result = overrides.isdir(resource_name) - if result is not None: - return result - return pkg_resources.DefaultProvider.resource_isdir( - self, resource_name) - - def resource_listdir(self, resource_name): - overrides = self._get_overrides() - if overrides is not None: - result = overrides.listdir(resource_name) - if result is not None: - return result - return pkg_resources.DefaultProvider.resource_listdir( - self, resource_name) - -class PackageOverrides: - implements(IPackageOverrides) - # pkg_resources arg in kw args below for testing - def __init__(self, package, pkg_resources=pkg_resources): - if hasattr(package, '__loader__') and not isinstance(package.__loader__, - self.__class__): - raise TypeError('Package %s already has a non-%s __loader__ ' - '(probably a module in a zipped egg)' % - (package, self.__class__)) - # We register ourselves as a __loader__ *only* to support the - # setuptools _find_adapter adapter lookup; this class doesn't - # actually support the PEP 302 loader "API". This is - # excusable due to the following statement in the spec: - # ... Loader objects are not - # required to offer any useful functionality (any such functionality, - # such as the zipimport get_data() method mentioned above, is - # optional)... - # A __loader__ attribute is basically metadata, and setuptools - # uses it as such. - package.__loader__ = self - # we call register_loader_type for every instantiation of this - # class; that's OK, it's idempotent to do it more than once. - pkg_resources.register_loader_type(self.__class__, OverrideProvider) - self.overrides = [] - self.overridden_package_name = package.__name__ - - def insert(self, path, package, prefix): - if not path or path.endswith('/'): - override = DirectoryOverride(path, package, prefix) - else: - override = FileOverride(path, package, prefix) - self.overrides.insert(0, override) - return override - - def search_path(self, resource_name): - for override in self.overrides: - o = override(resource_name) - if o is not None: - package, name = o - yield package, name - - def get_filename(self, resource_name): - for package, rname in self.search_path(resource_name): - if pkg_resources.resource_exists(package, rname): - return pkg_resources.resource_filename(package, rname) - - def get_stream(self, resource_name): - for package, rname in self.search_path(resource_name): - if pkg_resources.resource_exists(package, rname): - return pkg_resources.resource_stream(package, rname) - - def get_string(self, resource_name): - for package, rname in self.search_path(resource_name): - if pkg_resources.resource_exists(package, rname): - return pkg_resources.resource_string(package, rname) - - def has_resource(self, resource_name): - for package, rname in self.search_path(resource_name): - if pkg_resources.resource_exists(package, rname): - return True - - def isdir(self, resource_name): - for package, rname in self.search_path(resource_name): - if pkg_resources.resource_exists(package, rname): - return pkg_resources.resource_isdir(package, rname) - - def listdir(self, resource_name): - for package, rname in self.search_path(resource_name): - if pkg_resources.resource_exists(package, rname): - return pkg_resources.resource_listdir(package, rname) - - -class DirectoryOverride: - def __init__(self, path, package, prefix): - self.path = path - self.package = package - self.prefix = prefix - self.pathlen = len(self.path) - - def __call__(self, resource_name): - if resource_name.startswith(self.path): - name = '%s%s' % (self.prefix, resource_name[self.pathlen:]) - return self.package, name - -class FileOverride: - def __init__(self, path, package, prefix): - self.path = path - self.package = package - self.prefix = prefix - - def __call__(self, resource_name): - if resource_name == self.path: - return self.package, self.prefix - -def resolve_resource_spec(spec, pname='__main__'): - if pname and not isinstance(pname, basestring): - pname = pname.__name__ # as package - if os.path.isabs(spec): - return None, spec - filename = spec - if ':' in spec: - pname, filename = spec.split(':', 1) - elif pname is None: - pname, filename = None, spec - return pname, filename - -def resource_spec_from_abspath(abspath, package): - """ Try to convert an absolute path to a resource in a package to - a resource specification if possible; otherwise return the - absolute path. """ - if getattr(package, '__name__', None) == '__main__': - return abspath - pp = package_path(package) + os.path.sep - if abspath.startswith(pp): - relpath = abspath[len(pp):] - return '%s:%s' % (package_name(package), - relpath.replace(os.path.sep, '/')) - return abspath - -def abspath_from_resource_spec(spec, pname='__main__'): - if pname is None: - return spec - pname, filename = resolve_resource_spec(spec, pname) - if pname is None: - return filename - return pkg_resources.resource_filename(pname, filename) +""" Backwards compatibility shim module. """ +from asset import * # b/w compat +resolve_resource_spec = resolve_asset_spec +resource_spec_from_abspath = asset_spec_from_abspath +abspath_from_resource_spec = abspath_from_asset_spec diff --git a/pyramid/settings.py b/pyramid/settings.py index 1e49f7dd8..d3354979a 100644 --- a/pyramid/settings.py +++ b/pyramid/settings.py @@ -38,9 +38,14 @@ class Settings(dict): config_reload_templates = self.get('reload_templates', '') eff_reload_templates = asbool(eget('BFG_RELOAD_TEMPLATES', config_reload_templates)) + config_reload_assets = self.get('reload_assets', '') config_reload_resources = self.get('reload_resources', '') - eff_reload_resources = asbool(eget('BFG_RELOAD_RESOURCES', - config_reload_resources)) + reload_assets = asbool(eget('BFG_RELOAD_ASSETS', + config_reload_assets)) + reload_resources = asbool(eget('BFG_RELOAD_RESOURCES', + config_reload_resources)) + # reload_resources is an older alias for reload_resources + eff_reload_assets = reload_assets or reload_resources configure_zcml = self.get('configure_zcml', '') eff_configure_zcml = eget('BFG_CONFIGURE_ZCML', configure_zcml) locale_name = self.get('default_locale_name', 'en') @@ -52,7 +57,8 @@ class Settings(dict): 'debug_routematch': eff_debug_all or eff_debug_routematch, 'debug_templates': eff_debug_all or eff_debug_templates, 'reload_templates': eff_reload_all or eff_reload_templates, - 'reload_resources':eff_reload_all or eff_reload_resources, + 'reload_resources':eff_reload_all or eff_reload_assets, + 'reload_assets':eff_reload_all or eff_reload_assets, 'configure_zcml':eff_configure_zcml, 'default_locale_name':eff_locale_name, } diff --git a/pyramid/static.py b/pyramid/static.py index 645e78da1..e2f400ef6 100644 --- a/pyramid/static.py +++ b/pyramid/static.py @@ -10,9 +10,9 @@ from paste.urlparser import StaticURLParser from zope.interface import implements +from pyramid.asset import resolve_asset_spec from pyramid.interfaces import IStaticURLInfo from pyramid.path import caller_package -from pyramid.resource import resolve_resource_spec from pyramid.url import route_url class PackageURLParser(StaticURLParser): @@ -193,7 +193,7 @@ class static_view(object): # (e.g. ``anotherpackage:foo/static``). caller_package_name = caller_package().__name__ package_name = package_name or caller_package_name - package_name, root_dir = resolve_resource_spec(root_dir, package_name) + package_name, root_dir = resolve_asset_spec(root_dir, package_name) if package_name is None: app = StaticURLParser(root_dir, cache_max_age=cache_max_age) else: diff --git a/pyramid/tests/test_resource.py b/pyramid/tests/test_asset.py index 79d511dbd..ec45eb638 100644 --- a/pyramid/tests/test_resource.py +++ b/pyramid/tests/test_asset.py @@ -9,7 +9,7 @@ class TestOverrideProvider(unittest.TestCase): cleanUp() def _getTargetClass(self): - from pyramid.resource import OverrideProvider + from pyramid.asset import OverrideProvider return OverrideProvider def _makeOne(self, module): @@ -24,7 +24,7 @@ class TestOverrideProvider(unittest.TestCase): def test_get_resource_filename_no_overrides(self): import os - resource_name = 'test_resource.py' + resource_name = 'test_asset.py' import pyramid.tests provider = self._makeOne(pyramid.tests) here = os.path.dirname(os.path.abspath(__file__)) @@ -34,7 +34,7 @@ class TestOverrideProvider(unittest.TestCase): def test_get_resource_stream_no_overrides(self): import os - resource_name = 'test_resource.py' + resource_name = 'test_asset.py' import pyramid.tests provider = self._makeOne(pyramid.tests) here = os.path.dirname(os.path.abspath(__file__)) @@ -44,7 +44,7 @@ class TestOverrideProvider(unittest.TestCase): def test_get_resource_string_no_overrides(self): import os - resource_name = 'test_resource.py' + resource_name = 'test_asset.py' import pyramid.tests provider = self._makeOne(pyramid.tests) here = os.path.dirname(os.path.abspath(__file__)) @@ -53,14 +53,14 @@ class TestOverrideProvider(unittest.TestCase): self.assertEqual(result, expected) def test_has_resource_no_overrides(self): - resource_name = 'test_resource.py' + resource_name = 'test_asset.py' import pyramid.tests provider = self._makeOne(pyramid.tests) result = provider.has_resource(resource_name) self.assertEqual(result, True) def test_resource_isdir_no_overrides(self): - file_resource_name = 'test_resource.py' + file_resource_name = 'test_asset.py' directory_resource_name = 'fixtures' import pyramid.tests provider = self._makeOne(pyramid.tests) @@ -80,7 +80,7 @@ class TestOverrideProvider(unittest.TestCase): overrides = DummyOverrides(None) self._registerOverrides(overrides) import os - resource_name = 'test_resource.py' + resource_name = 'test_asset.py' import pyramid.tests provider = self._makeOne(pyramid.tests) here = os.path.dirname(os.path.abspath(__file__)) @@ -92,7 +92,7 @@ class TestOverrideProvider(unittest.TestCase): overrides = DummyOverrides(None) self._registerOverrides(overrides) import os - resource_name = 'test_resource.py' + resource_name = 'test_asset.py' import pyramid.tests provider = self._makeOne(pyramid.tests) here = os.path.dirname(os.path.abspath(__file__)) @@ -104,7 +104,7 @@ class TestOverrideProvider(unittest.TestCase): overrides = DummyOverrides(None) self._registerOverrides(overrides) import os - resource_name = 'test_resource.py' + resource_name = 'test_asset.py' import pyramid.tests provider = self._makeOne(pyramid.tests) here = os.path.dirname(os.path.abspath(__file__)) @@ -115,7 +115,7 @@ class TestOverrideProvider(unittest.TestCase): def test_has_resource_override_returns_None(self): overrides = DummyOverrides(None) self._registerOverrides(overrides) - resource_name = 'test_resource.py' + resource_name = 'test_asset.py' import pyramid.tests provider = self._makeOne(pyramid.tests) result = provider.has_resource(resource_name) @@ -144,7 +144,7 @@ class TestOverrideProvider(unittest.TestCase): import pyramid.tests self._registerOverrides(overrides) provider = self._makeOne(pyramid.tests) - result = provider.get_resource_filename(None, 'test_resource.py') + result = provider.get_resource_filename(None, 'test_asset.py') self.assertEqual(result, 'value') def test_get_resource_stream_override_returns_value(self): @@ -152,7 +152,7 @@ class TestOverrideProvider(unittest.TestCase): import pyramid.tests self._registerOverrides(overrides) provider = self._makeOne(pyramid.tests) - result = provider.get_resource_stream(None, 'test_resource.py') + result = provider.get_resource_stream(None, 'test_asset.py') self.assertEqual(result, 'value') def test_get_resource_string_override_returns_value(self): @@ -160,7 +160,7 @@ class TestOverrideProvider(unittest.TestCase): import pyramid.tests self._registerOverrides(overrides) provider = self._makeOne(pyramid.tests) - result = provider.get_resource_string(None, 'test_resource.py') + result = provider.get_resource_string(None, 'test_asset.py') self.assertEqual(result, 'value') def test_has_resource_override_returns_True(self): @@ -168,7 +168,7 @@ class TestOverrideProvider(unittest.TestCase): import pyramid.tests self._registerOverrides(overrides) provider = self._makeOne(pyramid.tests) - result = provider.has_resource('test_resource.py') + result = provider.has_resource('test_asset.py') self.assertEqual(result, True) def test_resource_isdir_override_returns_False(self): @@ -189,7 +189,7 @@ class TestOverrideProvider(unittest.TestCase): class TestPackageOverrides(unittest.TestCase): def _getTargetClass(self): - from pyramid.resource import PackageOverrides + from pyramid.asset import PackageOverrides return PackageOverrides def _makeOne(self, package, pkg_resources=None): @@ -259,39 +259,39 @@ class TestPackageOverrides(unittest.TestCase): def test_get_filename(self): import os overrides = [ DummyOverride(None), DummyOverride( - ('pyramid.tests', 'test_resource.py'))] + ('pyramid.tests', 'test_asset.py'))] package = DummyPackage('package') po = self._makeOne(package) po.overrides= overrides here = os.path.dirname(os.path.abspath(__file__)) - expected = os.path.join(here, 'test_resource.py') + expected = os.path.join(here, 'test_asset.py') self.assertEqual(po.get_filename('whatever'), expected) def test_get_stream(self): import os overrides = [ DummyOverride(None), DummyOverride( - ('pyramid.tests', 'test_resource.py'))] + ('pyramid.tests', 'test_asset.py'))] package = DummyPackage('package') po = self._makeOne(package) po.overrides= overrides here = os.path.dirname(os.path.abspath(__file__)) - expected = open(os.path.join(here, 'test_resource.py')).read() + expected = open(os.path.join(here, 'test_asset.py')).read() self.assertEqual(po.get_stream('whatever').read(), expected) def test_get_string(self): import os overrides = [ DummyOverride(None), DummyOverride( - ('pyramid.tests', 'test_resource.py'))] + ('pyramid.tests', 'test_asset.py'))] package = DummyPackage('package') po = self._makeOne(package) po.overrides= overrides here = os.path.dirname(os.path.abspath(__file__)) - expected = open(os.path.join(here, 'test_resource.py')).read() + expected = open(os.path.join(here, 'test_asset.py')).read() self.assertEqual(po.get_string('whatever'), expected) def test_has_resource(self): overrides = [ DummyOverride(None), DummyOverride( - ('pyramid.tests', 'test_resource.py'))] + ('pyramid.tests', 'test_asset.py'))] package = DummyPackage('package') po = self._makeOne(package) po.overrides= overrides @@ -299,7 +299,7 @@ class TestPackageOverrides(unittest.TestCase): def test_isdir_false(self): overrides = [ DummyOverride( - ('pyramid.tests', 'test_resource.py'))] + ('pyramid.tests', 'test_asset.py'))] package = DummyPackage('package') po = self._makeOne(package) po.overrides= overrides @@ -323,7 +323,7 @@ class TestPackageOverrides(unittest.TestCase): class TestDirectoryOverride(unittest.TestCase): def _getTargetClass(self): - from pyramid.resource import DirectoryOverride + from pyramid.asset import DirectoryOverride return DirectoryOverride def _makeOne(self, path, package, prefix): @@ -340,10 +340,10 @@ class TestDirectoryOverride(unittest.TestCase): result = o('baz/notfound.pt') self.assertEqual(result, None) -class Test_resolve_resource_spec(unittest.TestCase): +class Test_resolve_asset_spec(unittest.TestCase): def _callFUT(self, spec, package_name='__main__'): - from pyramid.resource import resolve_resource_spec - return resolve_resource_spec(spec, package_name) + from pyramid.resource import resolve_asset_spec + return resolve_asset_spec(spec, package_name) def test_abspath(self): import os @@ -355,37 +355,37 @@ class Test_resolve_resource_spec(unittest.TestCase): def test_rel_spec(self): pkg = 'pyramid.tests' - path = 'test_resource.py' + path = 'test_asset.py' package_name, filename = self._callFUT(path, pkg) self.assertEqual(package_name, 'pyramid.tests') - self.assertEqual(filename, 'test_resource.py') + self.assertEqual(filename, 'test_asset.py') def test_abs_spec(self): pkg = 'pyramid.tests' - path = 'pyramid.nottests:test_resource.py' + path = 'pyramid.nottests:test_asset.py' package_name, filename = self._callFUT(path, pkg) self.assertEqual(package_name, 'pyramid.nottests') - self.assertEqual(filename, 'test_resource.py') + self.assertEqual(filename, 'test_asset.py') def test_package_name_is_None(self): pkg = None - path = 'test_resource.py' + path = 'test_asset.py' package_name, filename = self._callFUT(path, pkg) self.assertEqual(package_name, None) - self.assertEqual(filename, 'test_resource.py') + self.assertEqual(filename, 'test_asset.py') def test_package_name_is_package_object(self): import pyramid.tests pkg = pyramid.tests - path = 'test_resource.py' + path = 'test_asset.py' package_name, filename = self._callFUT(path, pkg) self.assertEqual(package_name, 'pyramid.tests') - self.assertEqual(filename, 'test_resource.py') + self.assertEqual(filename, 'test_asset.py') class TestFileOverride(unittest.TestCase): def _getTargetClass(self): - from pyramid.resource import FileOverride + from pyramid.asset import FileOverride return FileOverride def _makeOne(self, path, package, prefix): @@ -402,16 +402,16 @@ class TestFileOverride(unittest.TestCase): result = o('notfound.pt') self.assertEqual(result, None) -class Test_abspath_from_resource_spec(unittest.TestCase): +class Test_abspath_from_asset_spec(unittest.TestCase): def _callFUT(self, spec, pname='__main__'): - from pyramid.resource import abspath_from_resource_spec - return abspath_from_resource_spec(spec, pname) + from pyramid.resource import abspath_from_asset_spec + return abspath_from_asset_spec(spec, pname) - def test_pname_is_None_before_resolve_resource_spec(self): + def test_pname_is_None_before_resolve_asset_spec(self): result = self._callFUT('abc', None) self.assertEqual(result, 'abc') - def test_pname_is_None_after_resolve_resource_spec(self): + def test_pname_is_None_after_resolve_asset_spec(self): result = self._callFUT('/abc', '__main__') self.assertEqual(result, '/abc') diff --git a/pyramid/tests/test_config.py b/pyramid/tests/test_config.py index 025eb595b..cbeae4897 100644 --- a/pyramid/tests/test_config.py +++ b/pyramid/tests/test_config.py @@ -226,22 +226,22 @@ class ConfiguratorTests(unittest.TestCase): result = config.maybe_dotted(pyramid.tests) self.assertEqual(result, pyramid.tests) - def test_absolute_resource_spec_already_absolute(self): + def test_absolute_asset_spec_already_absolute(self): import pyramid.tests config = self._makeOne(package=pyramid.tests) - result = config.absolute_resource_spec('already:absolute') + result = config.absolute_asset_spec('already:absolute') self.assertEqual(result, 'already:absolute') - def test_absolute_resource_spec_notastring(self): + def test_absolute_asset_spec_notastring(self): import pyramid.tests config = self._makeOne(package=pyramid.tests) - result = config.absolute_resource_spec(None) + result = config.absolute_asset_spec(None) self.assertEqual(result, None) - def test_absolute_resource_spec_relative(self): + def test_absolute_asset_spec_relative(self): import pyramid.tests config = self._makeOne(package=pyramid.tests) - result = config.absolute_resource_spec('templates') + result = config.absolute_asset_spec('templates') self.assertEqual(result, 'pyramid.tests:templates') def test_setup_registry_fixed(self): @@ -2541,7 +2541,7 @@ class ConfiguratorTests(unittest.TestCase): config.add_translation_dirs, '/wont/exist/on/my/system') - def test_add_translation_dirs_resource_spec(self): + def test_add_translation_dirs_asset_spec(self): import os from pyramid.interfaces import ITranslationDirectories config = self._makeOne(autocommit=True) @@ -2972,27 +2972,27 @@ class ConfiguratorTests(unittest.TestCase): inner_view, viewname='inner', wrapper_viewname='owrap') self.assertRaises(ValueError, wrapped, None, request) - def test_override_resource_samename(self): + def test_override_asset_samename(self): from pyramid.exceptions import ConfigurationError config = self._makeOne() - self.assertRaises(ConfigurationError, config.override_resource,'a', 'a') + self.assertRaises(ConfigurationError, config.override_asset,'a', 'a') - def test_override_resource_directory_with_file(self): + def test_override_asset_directory_with_file(self): from pyramid.exceptions import ConfigurationError config = self._makeOne() - self.assertRaises(ConfigurationError, config.override_resource, + self.assertRaises(ConfigurationError, config.override_asset, 'a:foo/', 'a:foo.pt') - def test_override_resource_file_with_directory(self): + def test_override_asset_file_with_directory(self): from pyramid.exceptions import ConfigurationError config = self._makeOne() - self.assertRaises(ConfigurationError, config.override_resource, + self.assertRaises(ConfigurationError, config.override_asset, 'a:foo.pt', 'a:foo/') - def test_override_resource_success(self): + def test_override_asset_success(self): config = self._makeOne(autocommit=True) override = DummyUnderOverride() - config.override_resource( + config.override_asset( 'pyramid.tests.fixtureapp:templates/foo.pt', 'pyramid.tests.fixtureapp.subpackage:templates/bar.pt', _override=override) diff --git a/pyramid/tests/test_mako_templating.py b/pyramid/tests/test_mako_templating.py index 30ccef0a5..bec29fc10 100644 --- a/pyramid/tests/test_mako_templating.py +++ b/pyramid/tests/test_mako_templating.py @@ -77,7 +77,7 @@ class Test_renderer_factory(Base, unittest.TestCase): os.path.join(module_path, 'a'), os.path.join(module_path, 'b')]) - def test_with_module_directory_resource_spec(self): + def test_with_module_directory_asset_spec(self): import os from pyramid.mako_templating import IMakoLookup module_directory = 'pyramid.tests:fixtures' @@ -94,7 +94,7 @@ class Test_renderer_factory(Base, unittest.TestCase): fixtures = os.path.join(os.path.dirname(__file__), 'fixtures') self.assertEqual(lookup.module_directory, fixtures) - def test_with_module_directory_resource_abspath(self): + def test_with_module_directory_asset_abspath(self): import os from pyramid.mako_templating import IMakoLookup fixtures = os.path.join(os.path.dirname(__file__), 'fixtures') @@ -364,28 +364,28 @@ class TestPkgResourceTemplateLookup(unittest.TestCase): import pyramid.tests return os.path.join(os.path.dirname(pyramid.tests.__file__), 'fixtures') - def test_adjust_uri_not_resource_spec(self): + def test_adjust_uri_not_asset_spec(self): inst = self._makeOne() result = inst.adjust_uri('a', None) self.assertEqual(result, '/a') - def test_adjust_uri_resource_spec(self): + def test_adjust_uri_asset_spec(self): inst = self._makeOne() result = inst.adjust_uri('a:b', None) self.assertEqual(result, 'a:b') - def test_get_template_not_resource_spec(self): + def test_get_template_not_asset_spec(self): fixturedir = self.get_fixturedir() inst = self._makeOne(directories=[fixturedir]) result = inst.get_template('helloworld.mak') self.failIf(result is None) - def test_get_template_resource_spec_with_filesystem_checks(self): + def test_get_template_asset_spec_with_filesystem_checks(self): inst = self._makeOne(filesystem_checks=True) result = inst.get_template('pyramid.tests:fixtures/helloworld.mak') self.failIf(result is None) - def test_get_template_resource_spec_missing(self): + def test_get_template_asset_spec_missing(self): from mako.exceptions import TopLevelLookupException fixturedir = self.get_fixturedir() inst = self._makeOne(filesystem_checks=True, directories=[fixturedir]) diff --git a/pyramid/tests/test_renderers.py b/pyramid/tests/test_renderers.py index bd6a0825d..9ff9e1274 100644 --- a/pyramid/tests/test_renderers.py +++ b/pyramid/tests/test_renderers.py @@ -143,11 +143,11 @@ class TestTemplateRendererFactory(unittest.TestCase): self.failUnless(factory.path.startswith(path)) self.assertEqual(factory.kw, {}) - def test_reload_resources_true(self): + def test_reload_assets_true(self): import pyramid.tests from pyramid.interfaces import ISettings from pyramid.interfaces import ITemplateRenderer - settings = {'reload_resources':True} + settings = {'reload_assets':True} testing.registerUtility(settings, ISettings) renderer = {} factory = DummyFactory(renderer) @@ -166,10 +166,10 @@ class TestTemplateRendererFactory(unittest.TestCase): self.assertEqual(reg.queryUtility(ITemplateRenderer, name=spec), None) - def test_reload_resources_false(self): + def test_reload_assets_false(self): import pyramid.tests from pyramid.interfaces import ITemplateRenderer - settings = {'reload_resources':False} + settings = {'reload_assets':False} renderer = {} factory = DummyFactory(renderer) spec = 'test_renderers.py' diff --git a/pyramid/tests/test_request.py b/pyramid/tests/test_request.py index 7c6b9f2da..40940cfc9 100644 --- a/pyramid/tests/test_request.py +++ b/pyramid/tests/test_request.py @@ -241,11 +241,11 @@ class TestRequest(unittest.TestCase): self.assertEqual(inst.called2, True) self.assertEqual(inst.finished_callbacks, []) - def test_model_url(self): + def test_resource_url(self): self._registerContextURL() inst = self._makeOne({}) root = DummyContext() - result = inst.model_url(root) + result = inst.resource_url(root) self.assertEqual(result, 'http://example.com/context/') def test_route_url(self): diff --git a/pyramid/tests/test_traversal.py b/pyramid/tests/test_traversal.py index 3245d6302..df9e1e554 100644 --- a/pyramid/tests/test_traversal.py +++ b/pyramid/tests/test_traversal.py @@ -62,7 +62,7 @@ class TraversalPathTests(unittest.TestCase): path = unicode('/La Pe\xc3\xb1a', 'utf-8') self.assertRaises(UnicodeEncodeError, self._callFUT, path) -class ModelGraphTraverserTests(unittest.TestCase): +class ResourceTreeTraverserTests(unittest.TestCase): def setUp(self): cleanUp() @@ -70,8 +70,8 @@ class ModelGraphTraverserTests(unittest.TestCase): cleanUp() def _getTargetClass(self): - from pyramid.traversal import ModelGraphTraverser - return ModelGraphTraverser + from pyramid.traversal import ResourceTreeTraverser + return ResourceTreeTraverser def _makeOne(self, *arg, **kw): klass = self._getTargetClass() @@ -272,68 +272,68 @@ class ModelGraphTraverserTests(unittest.TestCase): self.assertRaises(URLDecodeError, policy, environ) def test_withroute_nothingfancy(self): - model = DummyContext() - traverser = self._makeOne(model) + resource = DummyContext() + traverser = self._makeOne(resource) environ = {'bfg.routes.matchdict': {}} result = traverser(environ) - self.assertEqual(result['context'], model) + self.assertEqual(result['context'], resource) self.assertEqual(result['view_name'], '') self.assertEqual(result['subpath'], ()) self.assertEqual(result['traversed'], ()) - self.assertEqual(result['root'], model) - self.assertEqual(result['virtual_root'], model) + self.assertEqual(result['root'], resource) + self.assertEqual(result['virtual_root'], resource) self.assertEqual(result['virtual_root_path'], ()) def test_withroute_with_subpath_string(self): - model = DummyContext() - traverser = self._makeOne(model) + resource = DummyContext() + traverser = self._makeOne(resource) environ = {'bfg.routes.matchdict': {'subpath':'/a/b/c'}} result = traverser(environ) - self.assertEqual(result['context'], model) + self.assertEqual(result['context'], resource) self.assertEqual(result['view_name'], '') self.assertEqual(result['subpath'], ('a', 'b','c')) self.assertEqual(result['traversed'], ()) - self.assertEqual(result['root'], model) - self.assertEqual(result['virtual_root'], model) + self.assertEqual(result['root'], resource) + self.assertEqual(result['virtual_root'], resource) self.assertEqual(result['virtual_root_path'], ()) def test_withroute_with_subpath_tuple(self): - model = DummyContext() - traverser = self._makeOne(model) + resource = DummyContext() + traverser = self._makeOne(resource) environ = {'bfg.routes.matchdict': {'subpath':('a', 'b', 'c')}} result = traverser(environ) - self.assertEqual(result['context'], model) + self.assertEqual(result['context'], resource) self.assertEqual(result['view_name'], '') self.assertEqual(result['subpath'], ('a', 'b','c')) self.assertEqual(result['traversed'], ()) - self.assertEqual(result['root'], model) - self.assertEqual(result['virtual_root'], model) + self.assertEqual(result['root'], resource) + self.assertEqual(result['virtual_root'], resource) self.assertEqual(result['virtual_root_path'], ()) def test_withroute_and_traverse_string(self): - model = DummyContext() - traverser = self._makeOne(model) + resource = DummyContext() + traverser = self._makeOne(resource) environ = {'bfg.routes.matchdict': {'traverse':'foo/bar'}} result = traverser(environ) - self.assertEqual(result['context'], model) + self.assertEqual(result['context'], resource) self.assertEqual(result['view_name'], 'foo') self.assertEqual(result['subpath'], ('bar',)) self.assertEqual(result['traversed'], ()) - self.assertEqual(result['root'], model) - self.assertEqual(result['virtual_root'], model) + self.assertEqual(result['root'], resource) + self.assertEqual(result['virtual_root'], resource) self.assertEqual(result['virtual_root_path'], ()) def test_withroute_and_traverse_tuple(self): - model = DummyContext() - traverser = self._makeOne(model) + resource = DummyContext() + traverser = self._makeOne(resource) environ = {'bfg.routes.matchdict': {'traverse':('foo', 'bar')}} result = traverser(environ) - self.assertEqual(result['context'], model) + self.assertEqual(result['context'], resource) self.assertEqual(result['view_name'], 'foo') self.assertEqual(result['subpath'], ('bar',)) self.assertEqual(result['traversed'], ()) - self.assertEqual(result['root'], model) - self.assertEqual(result['virtual_root'], model) + self.assertEqual(result['root'], resource) + self.assertEqual(result['virtual_root'], resource) self.assertEqual(result['virtual_root_path'], ()) class FindInterfaceTests(unittest.TestCase): @@ -396,10 +396,10 @@ class FindRootTests(unittest.TestCase): result = self._callFUT(baz) self.assertEqual(result, dummy) -class FindModelTests(unittest.TestCase): +class FindResourceTests(unittest.TestCase): def _callFUT(self, context, name): - from pyramid.traversal import find_model - return find_model(context, name) + from pyramid.traversal import find_resource + return find_resource(context, name) def _registerTraverser(self, traverser): from pyramid.threadlocal import get_current_registry @@ -409,124 +409,124 @@ class FindModelTests(unittest.TestCase): reg.registerAdapter(traverser, (Interface,), ITraverser) def test_list(self): - model = DummyContext() - traverser = make_traverser({'context':model, 'view_name':''}) + resource = DummyContext() + traverser = make_traverser({'context':resource, 'view_name':''}) self._registerTraverser(traverser) - result = self._callFUT(model, ['']) - self.assertEqual(result, model) - self.assertEqual(model.request.environ['PATH_INFO'], '/') + result = self._callFUT(resource, ['']) + self.assertEqual(result, resource) + self.assertEqual(resource.request.environ['PATH_INFO'], '/') def test_generator(self): - model = DummyContext() - traverser = make_traverser({'context':model, 'view_name':''}) + resource = DummyContext() + traverser = make_traverser({'context':resource, 'view_name':''}) self._registerTraverser(traverser) def foo(): yield '' - result = self._callFUT(model, foo()) - self.assertEqual(result, model) - self.assertEqual(model.request.environ['PATH_INFO'], '/') + result = self._callFUT(resource, foo()) + self.assertEqual(result, resource) + self.assertEqual(resource.request.environ['PATH_INFO'], '/') def test_self_string_found(self): - model = DummyContext() - traverser = make_traverser({'context':model, 'view_name':''}) + resource = DummyContext() + traverser = make_traverser({'context':resource, 'view_name':''}) self._registerTraverser(traverser) - result = self._callFUT(model, '') - self.assertEqual(result, model) - self.assertEqual(model.request.environ['PATH_INFO'], '') + result = self._callFUT(resource, '') + self.assertEqual(result, resource) + self.assertEqual(resource.request.environ['PATH_INFO'], '') def test_self_tuple_found(self): - model = DummyContext() - traverser = make_traverser({'context':model, 'view_name':''}) + resource = DummyContext() + traverser = make_traverser({'context':resource, 'view_name':''}) self._registerTraverser(traverser) - result = self._callFUT(model, ()) - self.assertEqual(result, model) - self.assertEqual(model.request.environ['PATH_INFO'], '') + result = self._callFUT(resource, ()) + self.assertEqual(result, resource) + self.assertEqual(resource.request.environ['PATH_INFO'], '') def test_relative_string_found(self): - model = DummyContext() + resource = DummyContext() baz = DummyContext() traverser = make_traverser({'context':baz, 'view_name':''}) self._registerTraverser(traverser) - result = self._callFUT(model, 'baz') + result = self._callFUT(resource, 'baz') self.assertEqual(result, baz) - self.assertEqual(model.request.environ['PATH_INFO'], 'baz') + self.assertEqual(resource.request.environ['PATH_INFO'], 'baz') def test_relative_tuple_found(self): - model = DummyContext() + resource = DummyContext() baz = DummyContext() traverser = make_traverser({'context':baz, 'view_name':''}) self._registerTraverser(traverser) - result = self._callFUT(model, ('baz',)) + result = self._callFUT(resource, ('baz',)) self.assertEqual(result, baz) - self.assertEqual(model.request.environ['PATH_INFO'], 'baz') + self.assertEqual(resource.request.environ['PATH_INFO'], 'baz') def test_relative_string_notfound(self): - model = DummyContext() + resource = DummyContext() baz = DummyContext() traverser = make_traverser({'context':baz, 'view_name':'bar'}) self._registerTraverser(traverser) - self.assertRaises(KeyError, self._callFUT, model, 'baz') - self.assertEqual(model.request.environ['PATH_INFO'], 'baz') + self.assertRaises(KeyError, self._callFUT, resource, 'baz') + self.assertEqual(resource.request.environ['PATH_INFO'], 'baz') def test_relative_tuple_notfound(self): - model = DummyContext() + resource = DummyContext() baz = DummyContext() traverser = make_traverser({'context':baz, 'view_name':'bar'}) self._registerTraverser(traverser) - self.assertRaises(KeyError, self._callFUT, model, ('baz',)) - self.assertEqual(model.request.environ['PATH_INFO'], 'baz') + self.assertRaises(KeyError, self._callFUT, resource, ('baz',)) + self.assertEqual(resource.request.environ['PATH_INFO'], 'baz') def test_absolute_string_found(self): root = DummyContext() - model = DummyContext() - model.__parent__ = root - model.__name__ = 'baz' + resource = DummyContext() + resource.__parent__ = root + resource.__name__ = 'baz' traverser = make_traverser({'context':root, 'view_name':''}) self._registerTraverser(traverser) - result = self._callFUT(model, '/') + result = self._callFUT(resource, '/') self.assertEqual(result, root) self.assertEqual(root.wascontext, True) self.assertEqual(root.request.environ['PATH_INFO'], '/') def test_absolute_tuple_found(self): root = DummyContext() - model = DummyContext() - model.__parent__ = root - model.__name__ = 'baz' + resource = DummyContext() + resource.__parent__ = root + resource.__name__ = 'baz' traverser = make_traverser({'context':root, 'view_name':''}) self._registerTraverser(traverser) - result = self._callFUT(model, ('',)) + result = self._callFUT(resource, ('',)) self.assertEqual(result, root) self.assertEqual(root.wascontext, True) self.assertEqual(root.request.environ['PATH_INFO'], '/') def test_absolute_string_notfound(self): root = DummyContext() - model = DummyContext() - model.__parent__ = root - model.__name__ = 'baz' + resource = DummyContext() + resource.__parent__ = root + resource.__name__ = 'baz' traverser = make_traverser({'context':root, 'view_name':'fuz'}) self._registerTraverser(traverser) - self.assertRaises(KeyError, self._callFUT, model, '/') + self.assertRaises(KeyError, self._callFUT, resource, '/') self.assertEqual(root.wascontext, True) self.assertEqual(root.request.environ['PATH_INFO'], '/') def test_absolute_tuple_notfound(self): root = DummyContext() - model = DummyContext() - model.__parent__ = root - model.__name__ = 'baz' + resource = DummyContext() + resource.__parent__ = root + resource.__name__ = 'baz' traverser = make_traverser({'context':root, 'view_name':'fuz'}) self._registerTraverser(traverser) - self.assertRaises(KeyError, self._callFUT, model, ('',)) + self.assertRaises(KeyError, self._callFUT, resource, ('',)) self.assertEqual(root.wascontext, True) self.assertEqual(root.request.environ['PATH_INFO'], '/') def test_absolute_unicode_found(self): # test for bug wiggy found in wild, traceback stack: # root = u'/%E6%B5%81%E8%A1%8C%E8%B6%8B%E5%8A%BF' - # wiggy's code: section=find_model(page, root) - # find_model L76: D = traverse(model, path) + # wiggy's code: section=find_resource(page, root) + # find_resource L76: D = traverse(resource, path) # traverse L291: return traverser(request) # __call__ line 568: vpath_tuple = traversal_path(vpath) # lru_cached line 91: f(*arg) @@ -536,7 +536,7 @@ class FindModelTests(unittest.TestCase): # # solution: encode string to ascii in pyramid.traversal.traverse # before passing it along to webob as path_info - from pyramid.traversal import ModelGraphTraverser + from pyramid.traversal import ResourceTreeTraverser unprintable = DummyContext() root = DummyContext(unprintable) unprintable.__parent__ = root @@ -544,15 +544,15 @@ class FindModelTests(unittest.TestCase): '/\xe6\xb5\x81\xe8\xa1\x8c\xe8\xb6\x8b\xe5\x8a\xbf', 'utf-8') root.__parent__ = None root.__name__ = None - traverser = ModelGraphTraverser + traverser = ResourceTreeTraverser self._registerTraverser(traverser) result = self._callFUT(root, u'/%E6%B5%81%E8%A1%8C%E8%B6%8B%E5%8A%BF') self.assertEqual(result, unprintable) -class ModelPathTests(unittest.TestCase): - def _callFUT(self, model, *elements): - from pyramid.traversal import model_path - return model_path(model, *elements) +class ResourcePathTests(unittest.TestCase): + def _callFUT(self, resource, *elements): + from pyramid.traversal import resource_path + return resource_path(resource, *elements) def test_it(self): baz = DummyContext() @@ -624,10 +624,10 @@ class ModelPathTests(unittest.TestCase): result = self._callFUT(other2) self.assertEqual(result, '//other2') -class ModelPathTupleTests(unittest.TestCase): - def _callFUT(self, model, *elements): - from pyramid.traversal import model_path_tuple - return model_path_tuple(model, *elements) +class ResourcePathTupleTests(unittest.TestCase): + def _callFUT(self, resource, *elements): + from pyramid.traversal import resource_path_tuple + return resource_path_tuple(resource, *elements) def test_it(self): baz = DummyContext() @@ -745,7 +745,7 @@ class TraversalContextURLTests(unittest.TestCase): result = context_url() self.assertEqual(result, 'http://example.com:5432/') - def test_call_unicode_mixed_with_bytes_in_model_names(self): + def test_call_unicode_mixed_with_bytes_in_resource_names(self): root = DummyContext() root.__parent__ = None root.__name__ = None @@ -836,9 +836,9 @@ class TestVirtualRoot(unittest.TestCase): def tearDown(self): cleanUp() - def _callFUT(self, model, request): + def _callFUT(self, resource, request): from pyramid.traversal import virtual_root - return virtual_root(model, request) + return virtual_root(resource, request) def test_registered(self): from pyramid.interfaces import IContextURL @@ -885,96 +885,96 @@ class TraverseTests(unittest.TestCase): def test_request_has_registry(self): from pyramid.threadlocal import get_current_registry - model = DummyContext() - traverser = make_traverser({'context':model, 'view_name':''}) + resource = DummyContext() + traverser = make_traverser({'context':resource, 'view_name':''}) self._registerTraverser(traverser) - self._callFUT(model, ['']) - self.assertEqual(model.request.registry, get_current_registry()) + self._callFUT(resource, ['']) + self.assertEqual(resource.request.registry, get_current_registry()) def test_list(self): - model = DummyContext() - traverser = make_traverser({'context':model, 'view_name':''}) + resource = DummyContext() + traverser = make_traverser({'context':resource, 'view_name':''}) self._registerTraverser(traverser) - self._callFUT(model, ['']) - self.assertEqual(model.request.environ['PATH_INFO'], '/') + self._callFUT(resource, ['']) + self.assertEqual(resource.request.environ['PATH_INFO'], '/') def test_generator(self): - model = DummyContext() - traverser = make_traverser({'context':model, 'view_name':''}) + resource = DummyContext() + traverser = make_traverser({'context':resource, 'view_name':''}) self._registerTraverser(traverser) def foo(): yield '' - self._callFUT(model, foo()) - self.assertEqual(model.request.environ['PATH_INFO'], '/') + self._callFUT(resource, foo()) + self.assertEqual(resource.request.environ['PATH_INFO'], '/') def test_self_string_found(self): - model = DummyContext() - traverser = make_traverser({'context':model, 'view_name':''}) + resource = DummyContext() + traverser = make_traverser({'context':resource, 'view_name':''}) self._registerTraverser(traverser) - self._callFUT(model, '') - self.assertEqual(model.request.environ['PATH_INFO'], '') + self._callFUT(resource, '') + self.assertEqual(resource.request.environ['PATH_INFO'], '') def test_self_tuple_found(self): - model = DummyContext() - traverser = make_traverser({'context':model, 'view_name':''}) + resource = DummyContext() + traverser = make_traverser({'context':resource, 'view_name':''}) self._registerTraverser(traverser) - self._callFUT(model, ()) - self.assertEqual(model.request.environ['PATH_INFO'], '') + self._callFUT(resource, ()) + self.assertEqual(resource.request.environ['PATH_INFO'], '') def test_relative_string_found(self): - model = DummyContext() + resource = DummyContext() baz = DummyContext() traverser = make_traverser({'context':baz, 'view_name':''}) self._registerTraverser(traverser) - self._callFUT(model, 'baz') - self.assertEqual(model.request.environ['PATH_INFO'], 'baz') + self._callFUT(resource, 'baz') + self.assertEqual(resource.request.environ['PATH_INFO'], 'baz') def test_relative_tuple_found(self): - model = DummyContext() + resource = DummyContext() baz = DummyContext() traverser = make_traverser({'context':baz, 'view_name':''}) self._registerTraverser(traverser) - self._callFUT(model, ('baz',)) - self.assertEqual(model.request.environ['PATH_INFO'], 'baz') + self._callFUT(resource, ('baz',)) + self.assertEqual(resource.request.environ['PATH_INFO'], 'baz') def test_absolute_string_found(self): root = DummyContext() - model = DummyContext() - model.__parent__ = root - model.__name__ = 'baz' + resource = DummyContext() + resource.__parent__ = root + resource.__name__ = 'baz' traverser = make_traverser({'context':root, 'view_name':''}) self._registerTraverser(traverser) - self._callFUT(model, '/') + self._callFUT(resource, '/') self.assertEqual(root.wascontext, True) self.assertEqual(root.request.environ['PATH_INFO'], '/') def test_absolute_tuple_found(self): root = DummyContext() - model = DummyContext() - model.__parent__ = root - model.__name__ = 'baz' + resource = DummyContext() + resource.__parent__ = root + resource.__name__ = 'baz' traverser = make_traverser({'context':root, 'view_name':''}) self._registerTraverser(traverser) - self._callFUT(model, ('',)) + self._callFUT(resource, ('',)) self.assertEqual(root.wascontext, True) self.assertEqual(root.request.environ['PATH_INFO'], '/') def test_empty_sequence(self): root = DummyContext() - model = DummyContext() - model.__parent__ = root - model.__name__ = 'baz' + resource = DummyContext() + resource.__parent__ = root + resource.__name__ = 'baz' traverser = make_traverser({'context':root, 'view_name':''}) self._registerTraverser(traverser) - self._callFUT(model, []) - self.assertEqual(model.wascontext, True) - self.assertEqual(model.request.environ['PATH_INFO'], '') + self._callFUT(resource, []) + self.assertEqual(resource.wascontext, True) + self.assertEqual(resource.request.environ['PATH_INFO'], '') def test_default_traverser(self): - model = DummyContext() - result = self._callFUT(model, '') + resource = DummyContext() + result = self._callFUT(resource, '') self.assertEqual(result['view_name'], '') - self.assertEqual(result['context'], model) + self.assertEqual(result['context'], resource) def test_requestfactory_overridden(self): from pyramid.interfaces import IRequestFactory @@ -984,11 +984,11 @@ class TraverseTests(unittest.TestCase): class MyRequest(Request): pass reg.registerUtility(MyRequest, IRequestFactory) - model = DummyContext() - traverser = make_traverser({'context':model, 'view_name':''}) + resource = DummyContext() + traverser = make_traverser({'context':resource, 'view_name':''}) self._registerTraverser(traverser) - self._callFUT(model, ['']) - self.assertEqual(model.request.__class__, MyRequest) + self._callFUT(resource, ['']) + self.assertEqual(resource.request.__class__, MyRequest) class TestDefaultRootFactory(unittest.TestCase): def _getTargetClass(self): diff --git a/pyramid/tests/test_url.py b/pyramid/tests/test_url.py index aad969ca7..f11d36aca 100644 --- a/pyramid/tests/test_url.py +++ b/pyramid/tests/test_url.py @@ -2,16 +2,16 @@ import unittest from pyramid.testing import cleanUp -class ModelURLTests(unittest.TestCase): +class ResourceURLTests(unittest.TestCase): def setUp(self): cleanUp() def tearDown(self): cleanUp() - def _callFUT(self, model, request, *elements, **kw): - from pyramid.url import model_url - return model_url(model, request, *elements, **kw) + def _callFUT(self, resource, request, *elements, **kw): + from pyramid.url import resource_url + return resource_url(resource, request, *elements, **kw) def _registerContextURL(self, reg): from pyramid.interfaces import IContextURL diff --git a/pyramid/tests/test_zcml.py b/pyramid/tests/test_zcml.py index 8bc7c3eac..4c32e4d52 100644 --- a/pyramid/tests/test_zcml.py +++ b/pyramid/tests/test_zcml.py @@ -815,7 +815,7 @@ class TestStaticDirective(unittest.TestCase): request = DummyRequest() self.assertRaises(Forbidden, view, None, request) -class TestResourceDirective(unittest.TestCase): +class TestAssetDirective(unittest.TestCase): def setUp(self): self.config = testing.setUp(autocommit=False) self.config._ctx = self.config._make_context() @@ -824,8 +824,8 @@ class TestResourceDirective(unittest.TestCase): testing.tearDown() def _callFUT(self, *arg, **kw): - from pyramid.zcml import resource - return resource(*arg, **kw) + from pyramid.zcml import asset + return asset(*arg, **kw) def test_it(self): import pyramid.tests @@ -1302,7 +1302,7 @@ class Test_path_spec(unittest.TestCase): result = self._callFUT(context, '/foo.pt') self.assertEqual(result, '/foo.pt') - def test_path_is_already_resource_spec(self): + def test_path_is_already_asset_spec(self): context = DummyContext() result = self._callFUT(context, 'pyramid.tests:foo.pt') self.assertEqual(result, 'pyramid.tests:foo.pt') diff --git a/pyramid/traversal.py b/pyramid/traversal.py index 404e82ecb..6a9e20ed5 100644 --- a/pyramid/traversal.py +++ b/pyramid/traversal.py @@ -72,6 +72,9 @@ def find_resource(resource, path): object representing a resource name). Resource path tuples generated by :func:`pyramid.traversal.resource_path_tuple` can always be resolved by ``find_resource``. + + .. note:: For backwards compatibility purposes, this function can also + be imported as ``find_model``. """ D = traverse(resource, path) view_name = D['view_name'] @@ -139,6 +142,9 @@ def resource_path(resource, *elements): resource has a non-null ``__name__`` attribute, its name will be prepended to the generated path rather than a single leading '/' character. + + .. note:: For backwards compatibility purposes, this function can also + be imported as ``model_path``. """ # joining strings is a bit expensive so we delegate to a function # which caches the joined result for us @@ -340,6 +346,10 @@ def resource_path_tuple(resource, *elements): the root resource has a non-null ``__name__`` attribute, its name will be the first element in the generated path tuple rather than the empty string. + + .. note:: For backwards compatibility purposes, this function can also + be imported as ``model_path_tuple``. + """ return tuple(_resource_path_list(resource, *elements)) diff --git a/pyramid/url.py b/pyramid/url.py index b0b686f0c..109ee7ecf 100644 --- a/pyramid/url.py +++ b/pyramid/url.py @@ -2,8 +2,6 @@ import os -from zope.deprecation import deprecated - from repoze.lru import lru_cache from pyramid.interfaces import IContextURL @@ -269,6 +267,9 @@ def resource_url(resource, request, *elements, **kw): :term:`traversal`, the URL path will not include the virtual root prefix (it will be stripped off the left hand side of the generated URL). + + .. note:: For backwards compatibility purposes, this function can also + be imported as ``model_url``. """ try: reg = request.registry @@ -299,12 +300,7 @@ def resource_url(resource, request, *elements, **kw): return resource_url + suffix + qs + anchor -model_url = resource_url - -deprecated( - 'model_url', - '(The ``pyramid.url.model_url`` API is deprecated as of Pyramid 1.0. Use' - 'the ``pyramid.url.resource_url`` instead.) ') +model_url = resource_url # b/w compat (forever) def static_url(path, request, **kw): """ diff --git a/pyramid/zcml.py b/pyramid/zcml.py index 8e050e063..f668e3b4b 100644 --- a/pyramid/zcml.py +++ b/pyramid/zcml.py @@ -21,7 +21,7 @@ from pyramid.authentication import RepozeWho1AuthenticationPolicy from pyramid.authorization import ACLAuthorizationPolicy from pyramid.config import Configurator from pyramid.exceptions import ConfigurationError -from pyramid.resource import resource_spec_from_abspath +from pyramid.asset import asset_spec_from_abspath from pyramid.threadlocal import get_current_registry ###################### directives ########################## @@ -420,13 +420,6 @@ def asset(_context, to_override, override_with, _override=None): config = Configurator.with_context(_context) config.override_asset(to_override, override_with, _override=_override) -resource = asset # b/w compat - -deprecated( - 'resource', - '(The ``resource`` ZCML directive is deprecated as of Pyramid 1.0. Use' - 'the ``asset`` directive instead.) ') - class IRepozeWho1AuthenticationPolicyDirective(Interface): identifier_name = TextLine(title=u'identitfier_name', required=False, default=u'auth_tkt') @@ -531,7 +524,7 @@ class IStaticDirective(Interface): required=True) path = TextLine( - title=u'Path to the directory which contains resources', + title=u'Path to the directory which contains assets', description=u'May be package-relative by using a colon to ' 'separate package name and path relative to the package directory.', required=True) @@ -814,14 +807,14 @@ def default_permission(_context, name): config.set_default_permission(name) def path_spec(context, path): - # we prefer registering resource specifications over absolute - # paths because these can be overridden by the resource directive. + # we prefer registering asset specifications over absolute + # paths because these can be overridden by the asset directive. if ':' in path and not os.path.isabs(path): - # it's already a resource specification + # it's already an asset specification return path abspath = context.path(path) if hasattr(context, 'package') and context.package: - return resource_spec_from_abspath(abspath, context.package) + return asset_spec_from_abspath(abspath, context.package) return abspath def zcml_configure(name, package): |