def register_view_impl(cfg, factory, name, context, template, route_name,
layout, permission):
chain = []
# permission
if permission != NO_PERMISSION_REQUIRED and permission is not None:
chain.append(PermissionRenderer(permission, factory))
# view
if template is None:
render = ViewRenderer(viewMapper(factory, 'render'))
else:
render = TemplateRenderer(viewMapper(factory, 'update'), template)
factory.__view_renderer__ = render
chain.append(render)
# layout
if layout is unset:
layout = None
try:
if issubclass(factory, View):
layout = ''
except:
pass
if layout is not None:
chain.append(LayoutRenderer(layout))
# register view
if isexception(context):
view_classifier = IExceptionViewClassifier
else:
view_classifier = IViewClassifier
sm = cfg.registry
request_iface = IRequest
if route_name is not None:
request_iface = sm.getUtility(IRouteRequest, name=route_name)
pview = PyramidView(chain)
factory.__renderer__ = pview
pview.__config_action__ = cfg.action
sm.registerAdapter(
pview,
(view_classifier, request_iface, context or interface.Interface),
IView, name)
def register_view_impl(config, factory, name, context, template, route_name,
layout, permission):
if layout is unset:
layout = None
try:
if issubclass(factory, View):
layout = ''
except:
pass
if template is not None:
renderer = Renderer(template, layout=layout).bind(
viewMapper(factory, 'update'))
else:
renderer = SimpleRenderer(layout=layout).bind(
viewMapper(factory, 'render'))
factory.__renderer__ = renderer
# add 'subpath' support
if inspect.isclass(factory):
subpath_traverse = getattr(factory, '__subpath_traverse__', None)
if subpath_traverse is not None:
renderer = subpathWrapper(
viewInstanceMapper(factory), renderer, subpath_traverse)
# build pyramid view
if permission == '__no_permission_required__':
permission = None
sm = config.registry
if callable(permission):
def pyramidview(context, request):
if permission(context, request):
return renderer(context, request)
msg = getattr(request, 'authdebug_message',
'Unauthorized: %s failed permission check'%factory)
raise HTTPForbidden(msg)
elif permission:
def pyramidview(context, request):
if checkPermission(permission, context, request):
return renderer(context, request)
msg = getattr(request, 'authdebug_message',
'Unauthorized: %s failed permission check'%factory)
raise HTTPForbidden(msg)
else:
pyramidview = renderer
# register view
if context is None:
context = interface.Interface
if isexception(context):
view_classifier = IExceptionViewClassifier
else:
view_classifier = IViewClassifier
sm = config.registry
request_iface = IRequest
if route_name is not None:
request_iface = sm.getUtility(IRouteRequest, name=route_name)
sm.registerAdapter(
pyramidview, (view_classifier, request_iface, context), IView, name)
def register(permission=permission, renderer=renderer):
# the discrim_func above is guaranteed to have been called already
order = view_intr['order']
preds = view_intr['predicates']
phash = view_intr['phash']
request_iface = IRequest
if route_name is not None:
request_iface = self.registry.queryUtility(IRouteRequest,
name=route_name)
if request_iface is None:
# route configuration should have already happened in
# phase 2
raise ConfigurationError(
'No route named %s found for view registration' %
route_name)
if renderer is None:
# use default renderer if one exists (reg'd in phase 1)
if self.registry.queryUtility(IRendererFactory) is not None:
renderer = renderers.RendererHelper(
name=None,
package=self.package,
registry=self.registry
)
if permission is None:
# intent: will be None if no default permission is registered
# (reg'd in phase 1)
permission = self.registry.queryUtility(IDefaultPermission)
# added by discrim_func above during conflict resolving
preds = view_intr['predicates']
order = view_intr['order']
phash = view_intr['phash']
# __no_permission_required__ handled by _secure_view
deriver = ViewDeriver(
registry=self.registry,
permission=permission,
predicates=preds,
attr=attr,
renderer=renderer,
wrapper_viewname=wrapper,
viewname=name,
accept=accept,
order=order,
phash=phash,
package=self.package,
mapper=mapper,
decorator=decorator,
http_cache=http_cache,
)
derived_view = deriver(view)
derived_view.__discriminator__ = lambda *arg: discriminator
# __discriminator__ is used by superdynamic systems
# that require it for introspection after manual view lookup;
# see also MultiView.__discriminator__
view_intr['derived_callable'] = derived_view
registered = self.registry.adapters.registered
# A multiviews is a set of views which are registered for
# exactly the same context type/request type/name triad. Each
# consituent view in a multiview differs only by the
# predicates which it possesses.
# To find a previously registered view for a context
# type/request type/name triad, we need to use the
# ``registered`` method of the adapter registry rather than
# ``lookup``. ``registered`` ignores interface inheritance
# for the required and provided arguments, returning only a
# view registered previously with the *exact* triad we pass
# in.
# We need to do this three times, because we use three
# different interfaces as the ``provided`` interface while
# doing registrations, and ``registered`` performs exact
# matches on all the arguments it receives.
old_view = None
for view_type in (IView, ISecuredView, IMultiView):
old_view = registered((IViewClassifier, request_iface,
r_context), view_type, name)
if old_view is not None:
break
isexc = isexception(context)
def regclosure():
if hasattr(derived_view, '__call_permissive__'):
view_iface = ISecuredView
else:
view_iface = IView
self.registry.registerAdapter(
derived_view,
(IViewClassifier, request_iface, context), view_iface, name
)
if isexc:
self.registry.registerAdapter(
derived_view,
(IExceptionViewClassifier, request_iface, context),
view_iface, name)
is_multiview = IMultiView.providedBy(old_view)
old_phash = getattr(old_view, '__phash__', DEFAULT_PHASH)
if old_view is None:
# - No component was yet registered for any of our I*View
# interfaces exactly; this is the first view for this
# triad.
regclosure()
elif (not is_multiview) and (old_phash == phash):
# - A single view component was previously registered with
# the same predicate hash as this view; this registration
# is therefore an override.
regclosure()
else:
# - A view or multiview was already registered for this
# triad, and the new view is not an override.
# XXX we could try to be more efficient here and register
# a non-secured view for a multiview if none of the
# multiview's consituent views have a permission
# associated with them, but this code is getting pretty
# rough already
if is_multiview:
multiview = old_view
else:
multiview = MultiView(name)
old_accept = getattr(old_view, '__accept__', None)
old_order = getattr(old_view, '__order__', MAX_ORDER)
multiview.add(old_view, old_order, old_accept, old_phash)
multiview.add(derived_view, order, accept, phash)
for view_type in (IView, ISecuredView):
# unregister any existing views
self.registry.adapters.unregister(
(IViewClassifier, request_iface, r_context),
view_type, name=name)
if isexc:
self.registry.adapters.unregister(
(IExceptionViewClassifier, request_iface,
r_context), view_type, name=name)
self.registry.registerAdapter(
multiview,
(IViewClassifier, request_iface, context),
IMultiView, name=name)
if isexc:
self.registry.registerAdapter(
multiview,
(IExceptionViewClassifier, request_iface, context),
IMultiView, name=name)
renderer_type = getattr(renderer, 'type', None) # gard against None
intrspc = self.introspector
if (
renderer_type is not None and
tmpl_intr is not None and
intrspc is not None and
intrspc.get('renderer factories', renderer_type) is not None
):
# allow failure of registered template factories to be deferred
# until view execution, like other bad renderer factories; if
# we tried to relate this to an existing renderer factory
# without checking if it the factory actually existed, we'd end
# up with a KeyError at startup time, which is inconsistent
# with how other bad renderer registrations behave (they throw
# a ValueError at view execution time)
tmpl_intr.relate('renderer factories', renderer.type)
def register(permission=permission, renderer=renderer):
# the discrim_func above is guaranteed to have been called already
order = view_intr['order']
preds = view_intr['predicates']
phash = view_intr['phash']
request_iface = IRequest
if route_name is not None:
request_iface = self.registry.queryUtility(IRouteRequest,
name=route_name)
if request_iface is None:
# route configuration should have already happened in
# phase 2
raise ConfigurationError(
'No route named %s found for view registration' %
route_name)
if renderer is None:
# use default renderer if one exists (reg'd in phase 1)
if self.registry.queryUtility(IRendererFactory) is not None:
renderer = renderers.RendererHelper(name=None,
package=self.package,
registry=self.registry)
if permission is None:
# intent: will be None if no default permission is registered
# (reg'd in phase 1)
permission = self.registry.queryUtility(IDefaultPermission)
# added by discrim_func above during conflict resolving
preds = view_intr['predicates']
order = view_intr['order']
phash = view_intr['phash']
# __no_permission_required__ handled by _secure_view
deriver = ViewDeriver(
registry=self.registry,
permission=permission,
predicates=preds,
attr=attr,
renderer=renderer,
wrapper_viewname=wrapper,
viewname=name,
accept=accept,
order=order,
phash=phash,
package=self.package,
mapper=mapper,
decorator=decorator,
http_cache=http_cache,
)
derived_view = deriver(view)
derived_view.__discriminator__ = lambda *arg: discriminator
# __discriminator__ is used by superdynamic systems
# that require it for introspection after manual view lookup;
# see also MultiView.__discriminator__
view_intr['derived_callable'] = derived_view
registered = self.registry.adapters.registered
# A multiviews is a set of views which are registered for
# exactly the same context type/request type/name triad. Each
# consituent view in a multiview differs only by the
# predicates which it possesses.
# To find a previously registered view for a context
# type/request type/name triad, we need to use the
# ``registered`` method of the adapter registry rather than
# ``lookup``. ``registered`` ignores interface inheritance
# for the required and provided arguments, returning only a
# view registered previously with the *exact* triad we pass
# in.
# We need to do this three times, because we use three
# different interfaces as the ``provided`` interface while
# doing registrations, and ``registered`` performs exact
# matches on all the arguments it receives.
old_view = None
for view_type in (IView, ISecuredView, IMultiView):
old_view = registered((IViewClassifier, request_iface, r_context),
view_type, name)
if old_view is not None:
break
isexc = isexception(context)
def regclosure():
if hasattr(derived_view, '__call_permissive__'):
view_iface = ISecuredView
else:
view_iface = IView
self.registry.registerAdapter(
derived_view, (IViewClassifier, request_iface, context),
view_iface, name)
if isexc:
self.registry.registerAdapter(
derived_view,
(IExceptionViewClassifier, request_iface, context),
view_iface, name)
is_multiview = IMultiView.providedBy(old_view)
old_phash = getattr(old_view, '__phash__', DEFAULT_PHASH)
if old_view is None:
# - No component was yet registered for any of our I*View
# interfaces exactly; this is the first view for this
# triad.
regclosure()
elif (not is_multiview) and (old_phash == phash):
# - A single view component was previously registered with
# the same predicate hash as this view; this registration
# is therefore an override.
regclosure()
else:
# - A view or multiview was already registered for this
# triad, and the new view is not an override.
# XXX we could try to be more efficient here and register
# a non-secured view for a multiview if none of the
# multiview's consituent views have a permission
# associated with them, but this code is getting pretty
# rough already
if is_multiview:
multiview = old_view
else:
multiview = MultiView(name)
old_accept = getattr(old_view, '__accept__', None)
old_order = getattr(old_view, '__order__', MAX_ORDER)
multiview.add(old_view, old_order, old_accept, old_phash)
multiview.add(derived_view, order, accept, phash)
for view_type in (IView, ISecuredView):
# unregister any existing views
self.registry.adapters.unregister(
(IViewClassifier, request_iface, r_context),
view_type,
name=name)
if isexc:
self.registry.adapters.unregister(
(IExceptionViewClassifier, request_iface, r_context),
view_type,
name=name)
self.registry.registerAdapter(
multiview, (IViewClassifier, request_iface, context),
IMultiView,
name=name)
if isexc:
self.registry.registerAdapter(
multiview,
(IExceptionViewClassifier, request_iface, context),
IMultiView,
name=name)
renderer_type = getattr(renderer, 'type', None) # gard against None
intrspc = self.introspector
if (renderer_type is not None and tmpl_intr is not None
and intrspc is not None and intrspc.get(
'renderer factories', renderer_type) is not None):
# allow failure of registered template factories to be deferred
# until view execution, like other bad renderer factories; if
# we tried to relate this to an existing renderer factory
# without checking if it the factory actually existed, we'd end
# up with a KeyError at startup time, which is inconsistent
# with how other bad renderer registrations behave (they throw
# a ValueError at view execution time)
tmpl_intr.relate('renderer factories', renderer.type)