move action-related code into pyramid.config.actions

2 files changed, 531 insertions, 520 deletions

diff --git a/src/pyramid/config/__init__.py b/src/pyramid/config/__init__.py
index f5790352e..e4dcc6bb7 100644
--- a/src/pyramid/config/__init__.py
+++ b/src/pyramid/config/__init__.py
@@ -1,9 +1,6 @@
 import inspect
-import itertools
 import logging
-import operator
 import os
-import sys
 import threading
 import venusian
 
@@ -23,21 +20,17 @@ from pyramid.asset import resolve_asset_spec
 
 from pyramid.authorization import ACLAuthorizationPolicy
 
-from pyramid.compat import text_, reraise, string_types
+from pyramid.compat import text_, string_types
 
 from pyramid.events import ApplicationCreated
 
-from pyramid.exceptions import (
-    ConfigurationConflictError,
-    ConfigurationError,
-    ConfigurationExecutionError,
-)
+from pyramid.exceptions import ConfigurationError
 
 from pyramid.httpexceptions import default_exceptionresponse_view
 
 from pyramid.path import caller_package, package_of
 
-from pyramid.registry import Introspectable, Introspector, Registry, undefer
+from pyramid.registry import Introspectable, Introspector, Registry
 
 from pyramid.router import Router
 
@@ -47,8 +40,9 @@ from pyramid.threadlocal import manager
 
 from pyramid.util import WeakOrderedSet, object_description
 
-from pyramid.config.util import ActionInfo, PredicateList, action_method, not_
+from pyramid.config.util import PredicateList, action_method, not_
 
+from pyramid.config.actions import ActionConfiguratorMixin
 from pyramid.config.adapters import AdaptersConfiguratorMixin
 from pyramid.config.assets import AssetsConfiguratorMixin
 from pyramid.config.factories import FactoriesConfiguratorMixin
@@ -76,6 +70,7 @@ PHASE3_CONFIG = PHASE3_CONFIG  # api
 
 
 class Configurator(
+    ActionConfiguratorMixin,
     TestingConfiguratorMixin,
     TweensConfiguratorMixin,
     SecurityConfiguratorMixin,
@@ -575,143 +570,6 @@ class Configurator(
             order=PHASE1_CONFIG,
         )  # must be registered early
 
-    @property
-    def action_info(self):
-        info = self.info  # usually a ZCML action (ParserInfo) if self.info
-        if not info:
-            # Try to provide more accurate info for conflict reports
-            if self._ainfo:
-                info = self._ainfo[0]
-            else:
-                info = ActionInfo(None, 0, '', '')
-        return info
-
-    def action(
-        self,
-        discriminator,
-        callable=None,
-        args=(),
-        kw=None,
-        order=0,
-        introspectables=(),
-        **extra
-    ):
-        """ Register an action which will be executed when
-        :meth:`pyramid.config.Configurator.commit` is called (or executed
-        immediately if ``autocommit`` is ``True``).
-
-        .. warning:: This method is typically only used by :app:`Pyramid`
-           framework extension authors, not by :app:`Pyramid` application
-           developers.
-
-        The ``discriminator`` uniquely identifies the action.  It must be
-        given, but it can be ``None``, to indicate that the action never
-        conflicts.  It must be a hashable value.
-
-        The ``callable`` is a callable object which performs the task
-        associated with the action when the action is executed.  It is
-        optional.
-
-        ``args`` and ``kw`` are tuple and dict objects respectively, which
-        are passed to ``callable`` when this action is executed.  Both are
-        optional.
-
-        ``order`` is a grouping mechanism; an action with a lower order will
-        be executed before an action with a higher order (has no effect when
-        autocommit is ``True``).
-
-        ``introspectables`` is a sequence of :term:`introspectable` objects
-        (or the empty sequence if no introspectable objects are associated
-        with this action).  If this configurator's ``introspection``
-        attribute is ``False``, these introspectables will be ignored.
-
-        ``extra`` provides a facility for inserting extra keys and values
-        into an action dictionary.
-        """
-        # catch nonhashable discriminators here; most unit tests use
-        # autocommit=False, which won't catch unhashable discriminators
-        assert hash(discriminator)
-
-        if kw is None:
-            kw = {}
-
-        autocommit = self.autocommit
-        action_info = self.action_info
-
-        if not self.introspection:
-            # if we're not introspecting, ignore any introspectables passed
-            # to us
-            introspectables = ()
-
-        if autocommit:
-            # callables can depend on the side effects of resolving a
-            # deferred discriminator
-            self.begin()
-            try:
-                undefer(discriminator)
-                if callable is not None:
-                    callable(*args, **kw)
-                for introspectable in introspectables:
-                    introspectable.register(self.introspector, action_info)
-            finally:
-                self.end()
-
-        else:
-            action = extra
-            action.update(
-                dict(
-                    discriminator=discriminator,
-                    callable=callable,
-                    args=args,
-                    kw=kw,
-                    order=order,
-                    info=action_info,
-                    includepath=self.includepath,
-                    introspectables=introspectables,
-                )
-            )
-            self.action_state.action(**action)
-
-    def _get_action_state(self):
-        registry = self.registry
-        try:
-            state = registry.action_state
-        except AttributeError:
-            state = ActionState()
-            registry.action_state = state
-        return state
-
-    def _set_action_state(self, state):
-        self.registry.action_state = state
-
-    action_state = property(_get_action_state, _set_action_state)
-
-    _ctx = action_state  # bw compat
-
-    def commit(self):
-        """
-        Commit any pending configuration actions. If a configuration
-        conflict is detected in the pending configuration actions, this method
-        will raise a :exc:`ConfigurationConflictError`; within the traceback
-        of this error will be information about the source of the conflict,
-        usually including file names and line numbers of the cause of the
-        configuration conflicts.
-
-        .. warning::
-           You should think very carefully before manually invoking
-           ``commit()``. Especially not as part of any reusable configuration
-           methods. Normally it should only be done by an application author at
-           the end of configuration in order to override certain aspects of an
-           addon.
-
-        """
-        self.begin()
-        try:
-            self.action_state.execute_actions(introspector=self.introspector)
-        finally:
-            self.end()
-        self.action_state = ActionState()  # old actions have been processed
-
     def include(self, callable, route_prefix=None):
         """Include a configuration callable, to support imperative
         application extensibility.
@@ -1084,376 +942,4 @@ class Configurator(
         return app
 
 
-# this class is licensed under the ZPL (stolen from Zope)
-class ActionState(object):
-    def __init__(self):
-        # NB "actions" is an API, dep'd upon by pyramid_zcml's load_zcml func
-        self.actions = []
-        self._seen_files = set()
-
-    def processSpec(self, spec):
-        """Check whether a callable needs to be processed.  The ``spec``
-        refers to a unique identifier for the callable.
-
-        Return True if processing is needed and False otherwise. If
-        the callable needs to be processed, it will be marked as
-        processed, assuming that the caller will procces the callable if
-        it needs to be processed.
-        """
-        if spec in self._seen_files:
-            return False
-        self._seen_files.add(spec)
-        return True
-
-    def action(
-        self,
-        discriminator,
-        callable=None,
-        args=(),
-        kw=None,
-        order=0,
-        includepath=(),
-        info=None,
-        introspectables=(),
-        **extra
-    ):
-        """Add an action with the given discriminator, callable and arguments
-        """
-        if kw is None:
-            kw = {}
-        action = extra
-        action.update(
-            dict(
-                discriminator=discriminator,
-                callable=callable,
-                args=args,
-                kw=kw,
-                includepath=includepath,
-                info=info,
-                order=order,
-                introspectables=introspectables,
-            )
-        )
-        self.actions.append(action)
-
-    def execute_actions(self, clear=True, introspector=None):
-        """Execute the configuration actions
-
-        This calls the action callables after resolving conflicts
-
-        For example:
-
-        >>> output = []
-        >>> def f(*a, **k):
-        ...    output.append(('f', a, k))
-        >>> context = ActionState()
-        >>> context.actions = [
-        ...   (1, f, (1,)),
-        ...   (1, f, (11,), {}, ('x', )),
-        ...   (2, f, (2,)),
-        ...   ]
-        >>> context.execute_actions()
-        >>> output
-        [('f', (1,), {}), ('f', (2,), {})]
-
-        If the action raises an error, we convert it to a
-        ConfigurationExecutionError.
-
-        >>> output = []
-        >>> def bad():
-        ...    bad.xxx
-        >>> context.actions = [
-        ...   (1, f, (1,)),
-        ...   (1, f, (11,), {}, ('x', )),
-        ...   (2, f, (2,)),
-        ...   (3, bad, (), {}, (), 'oops')
-        ...   ]
-        >>> try:
-        ...    v = context.execute_actions()
-        ... except ConfigurationExecutionError, v:
-        ...    pass
-        >>> print(v)
-        exceptions.AttributeError: 'function' object has no attribute 'xxx'
-          in:
-          oops
-
-        Note that actions executed before the error still have an effect:
-
-        >>> output
-        [('f', (1,), {}), ('f', (2,), {})]
-
-        The execution is re-entrant such that actions may be added by other
-        actions with the one caveat that the order of any added actions must
-        be equal to or larger than the current action.
-
-        >>> output = []
-        >>> def f(*a, **k):
-        ...   output.append(('f', a, k))
-        ...   context.actions.append((3, g, (8,), {}))
-        >>> def g(*a, **k):
-        ...    output.append(('g', a, k))
-        >>> context.actions = [
-        ...   (1, f, (1,)),
-        ...   ]
-        >>> context.execute_actions()
-        >>> output
-        [('f', (1,), {}), ('g', (8,), {})]
-
-        """
-        try:
-            all_actions = []
-            executed_actions = []
-            action_iter = iter([])
-            conflict_state = ConflictResolverState()
-
-            while True:
-                # We clear the actions list prior to execution so if there
-                # are some new actions then we add them to the mix and resolve
-                # conflicts again. This orders the new actions as well as
-                # ensures that the previously executed actions have no new
-                # conflicts.
-                if self.actions:
-                    all_actions.extend(self.actions)
-                    action_iter = resolveConflicts(
-                        self.actions, state=conflict_state
-                    )
-                    self.actions = []
-
-                action = next(action_iter, None)
-                if action is None:
-                    # we are done!
-                    break
-
-                callable = action['callable']
-                args = action['args']
-                kw = action['kw']
-                info = action['info']
-                # we use "get" below in case an action was added via a ZCML
-                # directive that did not know about introspectables
-                introspectables = action.get('introspectables', ())
-
-                try:
-                    if callable is not None:
-                        callable(*args, **kw)
-                except Exception:
-                    t, v, tb = sys.exc_info()
-                    try:
-                        reraise(
-                            ConfigurationExecutionError,
-                            ConfigurationExecutionError(t, v, info),
-                            tb,
-                        )
-                    finally:
-                        del t, v, tb
-
-                if introspector is not None:
-                    for introspectable in introspectables:
-                        introspectable.register(introspector, info)
-
-                executed_actions.append(action)
-
-            self.actions = all_actions
-            return executed_actions
-
-        finally:
-            if clear:
-                self.actions = []
-
-
-class ConflictResolverState(object):
-    def __init__(self):
-        # keep a set of resolved discriminators to test against to ensure
-        # that a new action does not conflict with something already executed
-        self.resolved_ainfos = {}
-
-        # actions left over from a previous iteration
-        self.remaining_actions = []
-
-        # after executing an action we memoize its order to avoid any new
-        # actions sending us backward
-        self.min_order = None
-
-        # unique tracks the index of the action so we need it to increase
-        # monotonically across invocations to resolveConflicts
-        self.start = 0
-
-
-# this function is licensed under the ZPL (stolen from Zope)
-def resolveConflicts(actions, state=None):
-    """Resolve conflicting actions
-
-    Given an actions list, identify and try to resolve conflicting actions.
-    Actions conflict if they have the same non-None discriminator.
-
-    Conflicting actions can be resolved if the include path of one of
-    the actions is a prefix of the includepaths of the other
-    conflicting actions and is unequal to the include paths in the
-    other conflicting actions.
-
-    Actions are resolved on a per-order basis because some discriminators
-    cannot be computed until earlier actions have executed. An action in an
-    earlier order may execute successfully only to find out later that it was
-    overridden by another action with a smaller include path. This will result
-    in a conflict as there is no way to revert the original action.
-
-    ``state`` may be an instance of ``ConflictResolverState`` that
-    can be used to resume execution and resolve the new actions against the
-    list of executed actions from a previous call.
-
-    """
-    if state is None:
-        state = ConflictResolverState()
-
-    # pick up where we left off last time, but track the new actions as well
-    state.remaining_actions.extend(normalize_actions(actions))
-    actions = state.remaining_actions
-
-    def orderandpos(v):
-        n, v = v
-        return (v['order'] or 0, n)
-
-    def orderonly(v):
-        n, v = v
-        return v['order'] or 0
-
-    sactions = sorted(enumerate(actions, start=state.start), key=orderandpos)
-    for order, actiongroup in itertools.groupby(sactions, orderonly):
-        # "order" is an integer grouping. Actions in a lower order will be
-        # executed before actions in a higher order.  All of the actions in
-        # one grouping will be executed (its callable, if any will be called)
-        # before any of the actions in the next.
-        output = []
-        unique = {}
-
-        # error out if we went backward in order
-        if state.min_order is not None and order < state.min_order:
-            r = [
-                'Actions were added to order={0} after execution had moved '
-                'on to order={1}. Conflicting actions: '.format(
-                    order, state.min_order
-                )
-            ]
-            for i, action in actiongroup:
-                for line in str(action['info']).rstrip().split('\n'):
-                    r.append("  " + line)
-            raise ConfigurationError('\n'.join(r))
-
-        for i, action in actiongroup:
-            # Within an order, actions are executed sequentially based on
-            # original action ordering ("i").
-
-            # "ainfo" is a tuple of (i, action) where "i" is an integer
-            # expressing the relative position of this action in the action
-            # list being resolved, and "action" is an action dictionary.  The
-            # purpose of an ainfo is to associate an "i" with a particular
-            # action; "i" exists for sorting after conflict resolution.
-            ainfo = (i, action)
-
-            # wait to defer discriminators until we are on their order because
-            # the discriminator may depend on state from a previous order
-            discriminator = undefer(action['discriminator'])
-            action['discriminator'] = discriminator
-
-            if discriminator is None:
-                # The discriminator is None, so this action can never conflict.
-                # We can add it directly to the result.
-                output.append(ainfo)
-                continue
-
-            L = unique.setdefault(discriminator, [])
-            L.append(ainfo)
-
-        # Check for conflicts
-        conflicts = {}
-        for discriminator, ainfos in unique.items():
-            # We use (includepath, i) as a sort key because we need to
-            # sort the actions by the paths so that the shortest path with a
-            # given prefix comes first.  The "first" action is the one with the
-            # shortest include path.  We break sorting ties using "i".
-            def bypath(ainfo):
-                path, i = ainfo[1]['includepath'], ainfo[0]
-                return path, order, i
-
-            ainfos.sort(key=bypath)
-            ainfo, rest = ainfos[0], ainfos[1:]
-            _, action = ainfo
-
-            # ensure this new action does not conflict with a previously
-            # resolved action from an earlier order / invocation
-            prev_ainfo = state.resolved_ainfos.get(discriminator)
-            if prev_ainfo is not None:
-                _, paction = prev_ainfo
-                basepath, baseinfo = paction['includepath'], paction['info']
-                includepath = action['includepath']
-                # if the new action conflicts with the resolved action then
-                # note the conflict, otherwise drop the action as it's
-                # effectively overriden by the previous action
-                if (
-                    includepath[: len(basepath)] != basepath
-                    or includepath == basepath
-                ):
-                    L = conflicts.setdefault(discriminator, [baseinfo])
-                    L.append(action['info'])
-
-            else:
-                output.append(ainfo)
-
-            basepath, baseinfo = action['includepath'], action['info']
-            for _, action in rest:
-                includepath = action['includepath']
-                # Test whether path is a prefix of opath
-                if (
-                    includepath[: len(basepath)] != basepath
-                    or includepath == basepath  # not a prefix
-                ):
-                    L = conflicts.setdefault(discriminator, [baseinfo])
-                    L.append(action['info'])
-
-        if conflicts:
-            raise ConfigurationConflictError(conflicts)
-
-        # sort resolved actions by "i" and yield them one by one
-        for i, action in sorted(output, key=operator.itemgetter(0)):
-            # do not memoize the order until we resolve an action inside it
-            state.min_order = action['order']
-            state.start = i + 1
-            state.remaining_actions.remove(action)
-            state.resolved_ainfos[action['discriminator']] = (i, action)
-            yield action
-
-
-def normalize_actions(actions):
-    """Convert old-style tuple actions to new-style dicts."""
-    result = []
-    for v in actions:
-        if not isinstance(v, dict):
-            v = expand_action_tuple(*v)
-        result.append(v)
-    return result
-
-
-def expand_action_tuple(
-    discriminator,
-    callable=None,
-    args=(),
-    kw=None,
-    includepath=(),
-    info=None,
-    order=0,
-    introspectables=(),
-):
-    if kw is None:
-        kw = {}
-    return dict(
-        discriminator=discriminator,
-        callable=callable,
-        args=args,
-        kw=kw,
-        includepath=includepath,
-        info=info,
-        order=order,
-        introspectables=introspectables,
-    )
-
-
 global_registries = WeakOrderedSet()
diff --git a/src/pyramid/config/actions.py b/src/pyramid/config/actions.py
new file mode 100644
index 000000000..353ed5edf
--- /dev/null
+++ b/src/pyramid/config/actions.py
@@ -0,0 +1,525 @@
+import itertools
+import operator
+import sys
+
+from pyramid.compat import reraise
+
+from pyramid.config.util import ActionInfo
+
+from pyramid.exceptions import (
+    ConfigurationConflictError,
+    ConfigurationError,
+    ConfigurationExecutionError,
+)
+
+from pyramid.registry import undefer
+
+
+class ActionConfiguratorMixin(object):
+    @property
+    def action_info(self):
+        info = self.info  # usually a ZCML action (ParserInfo) if self.info
+        if not info:
+            # Try to provide more accurate info for conflict reports
+            if self._ainfo:
+                info = self._ainfo[0]
+            else:
+                info = ActionInfo(None, 0, '', '')
+        return info
+
+    def action(
+        self,
+        discriminator,
+        callable=None,
+        args=(),
+        kw=None,
+        order=0,
+        introspectables=(),
+        **extra
+    ):
+        """ Register an action which will be executed when
+        :meth:`pyramid.config.Configurator.commit` is called (or executed
+        immediately if ``autocommit`` is ``True``).
+
+        .. warning:: This method is typically only used by :app:`Pyramid`
+           framework extension authors, not by :app:`Pyramid` application
+           developers.
+
+        The ``discriminator`` uniquely identifies the action.  It must be
+        given, but it can be ``None``, to indicate that the action never
+        conflicts.  It must be a hashable value.
+
+        The ``callable`` is a callable object which performs the task
+        associated with the action when the action is executed.  It is
+        optional.
+
+        ``args`` and ``kw`` are tuple and dict objects respectively, which
+        are passed to ``callable`` when this action is executed.  Both are
+        optional.
+
+        ``order`` is a grouping mechanism; an action with a lower order will
+        be executed before an action with a higher order (has no effect when
+        autocommit is ``True``).
+
+        ``introspectables`` is a sequence of :term:`introspectable` objects
+        (or the empty sequence if no introspectable objects are associated
+        with this action).  If this configurator's ``introspection``
+        attribute is ``False``, these introspectables will be ignored.
+
+        ``extra`` provides a facility for inserting extra keys and values
+        into an action dictionary.
+        """
+        # catch nonhashable discriminators here; most unit tests use
+        # autocommit=False, which won't catch unhashable discriminators
+        assert hash(discriminator)
+
+        if kw is None:
+            kw = {}
+
+        autocommit = self.autocommit
+        action_info = self.action_info
+
+        if not self.introspection:
+            # if we're not introspecting, ignore any introspectables passed
+            # to us
+            introspectables = ()
+
+        if autocommit:
+            # callables can depend on the side effects of resolving a
+            # deferred discriminator
+            self.begin()
+            try:
+                undefer(discriminator)
+                if callable is not None:
+                    callable(*args, **kw)
+                for introspectable in introspectables:
+                    introspectable.register(self.introspector, action_info)
+            finally:
+                self.end()
+
+        else:
+            action = extra
+            action.update(
+                dict(
+                    discriminator=discriminator,
+                    callable=callable,
+                    args=args,
+                    kw=kw,
+                    order=order,
+                    info=action_info,
+                    includepath=self.includepath,
+                    introspectables=introspectables,
+                )
+            )
+            self.action_state.action(**action)
+
+    def _get_action_state(self):
+        registry = self.registry
+        try:
+            state = registry.action_state
+        except AttributeError:
+            state = ActionState()
+            registry.action_state = state
+        return state
+
+    def _set_action_state(self, state):
+        self.registry.action_state = state
+
+    action_state = property(_get_action_state, _set_action_state)
+
+    _ctx = action_state  # bw compat
+
+    def commit(self):
+        """
+        Commit any pending configuration actions. If a configuration
+        conflict is detected in the pending configuration actions, this method
+        will raise a :exc:`ConfigurationConflictError`; within the traceback
+        of this error will be information about the source of the conflict,
+        usually including file names and line numbers of the cause of the
+        configuration conflicts.
+
+        .. warning::
+           You should think very carefully before manually invoking
+           ``commit()``. Especially not as part of any reusable configuration
+           methods. Normally it should only be done by an application author at
+           the end of configuration in order to override certain aspects of an
+           addon.
+
+        """
+        self.begin()
+        try:
+            self.action_state.execute_actions(introspector=self.introspector)
+        finally:
+            self.end()
+        self.action_state = ActionState()  # old actions have been processed
+
+# this class is licensed under the ZPL (stolen from Zope)
+class ActionState(object):
+    def __init__(self):
+        # NB "actions" is an API, dep'd upon by pyramid_zcml's load_zcml func
+        self.actions = []
+        self._seen_files = set()
+
+    def processSpec(self, spec):
+        """Check whether a callable needs to be processed.  The ``spec``
+        refers to a unique identifier for the callable.
+
+        Return True if processing is needed and False otherwise. If
+        the callable needs to be processed, it will be marked as
+        processed, assuming that the caller will procces the callable if
+        it needs to be processed.
+        """
+        if spec in self._seen_files:
+            return False
+        self._seen_files.add(spec)
+        return True
+
+    def action(
+        self,
+        discriminator,
+        callable=None,
+        args=(),
+        kw=None,
+        order=0,
+        includepath=(),
+        info=None,
+        introspectables=(),
+        **extra
+    ):
+        """Add an action with the given discriminator, callable and arguments
+        """
+        if kw is None:
+            kw = {}
+        action = extra
+        action.update(
+            dict(
+                discriminator=discriminator,
+                callable=callable,
+                args=args,
+                kw=kw,
+                includepath=includepath,
+                info=info,
+                order=order,
+                introspectables=introspectables,
+            )
+        )
+        self.actions.append(action)
+
+    def execute_actions(self, clear=True, introspector=None):
+        """Execute the configuration actions
+
+        This calls the action callables after resolving conflicts
+
+        For example:
+
+        >>> output = []
+        >>> def f(*a, **k):
+        ...    output.append(('f', a, k))
+        >>> context = ActionState()
+        >>> context.actions = [
+        ...   (1, f, (1,)),
+        ...   (1, f, (11,), {}, ('x', )),
+        ...   (2, f, (2,)),
+        ...   ]
+        >>> context.execute_actions()
+        >>> output
+        [('f', (1,), {}), ('f', (2,), {})]
+
+        If the action raises an error, we convert it to a
+        ConfigurationExecutionError.
+
+        >>> output = []
+        >>> def bad():
+        ...    bad.xxx
+        >>> context.actions = [
+        ...   (1, f, (1,)),
+        ...   (1, f, (11,), {}, ('x', )),
+        ...   (2, f, (2,)),
+        ...   (3, bad, (), {}, (), 'oops')
+        ...   ]
+        >>> try:
+        ...    v = context.execute_actions()
+        ... except ConfigurationExecutionError, v:
+        ...    pass
+        >>> print(v)
+        exceptions.AttributeError: 'function' object has no attribute 'xxx'
+          in:
+          oops
+
+        Note that actions executed before the error still have an effect:
+
+        >>> output
+        [('f', (1,), {}), ('f', (2,), {})]
+
+        The execution is re-entrant such that actions may be added by other
+        actions with the one caveat that the order of any added actions must
+        be equal to or larger than the current action.
+
+        >>> output = []
+        >>> def f(*a, **k):
+        ...   output.append(('f', a, k))
+        ...   context.actions.append((3, g, (8,), {}))
+        >>> def g(*a, **k):
+        ...    output.append(('g', a, k))
+        >>> context.actions = [
+        ...   (1, f, (1,)),
+        ...   ]
+        >>> context.execute_actions()
+        >>> output
+        [('f', (1,), {}), ('g', (8,), {})]
+
+        """
+        try:
+            all_actions = []
+            executed_actions = []
+            action_iter = iter([])
+            conflict_state = ConflictResolverState()
+
+            while True:
+                # We clear the actions list prior to execution so if there
+                # are some new actions then we add them to the mix and resolve
+                # conflicts again. This orders the new actions as well as
+                # ensures that the previously executed actions have no new
+                # conflicts.
+                if self.actions:
+                    all_actions.extend(self.actions)
+                    action_iter = resolveConflicts(
+                        self.actions, state=conflict_state
+                    )
+                    self.actions = []
+
+                action = next(action_iter, None)
+                if action is None:
+                    # we are done!
+                    break
+
+                callable = action['callable']
+                args = action['args']
+                kw = action['kw']
+                info = action['info']
+                # we use "get" below in case an action was added via a ZCML
+                # directive that did not know about introspectables
+                introspectables = action.get('introspectables', ())
+
+                try:
+                    if callable is not None:
+                        callable(*args, **kw)
+                except Exception:
+                    t, v, tb = sys.exc_info()
+                    try:
+                        reraise(
+                            ConfigurationExecutionError,
+                            ConfigurationExecutionError(t, v, info),
+                            tb,
+                        )
+                    finally:
+                        del t, v, tb
+
+                if introspector is not None:
+                    for introspectable in introspectables:
+                        introspectable.register(introspector, info)
+
+                executed_actions.append(action)
+
+            self.actions = all_actions
+            return executed_actions
+
+        finally:
+            if clear:
+                self.actions = []
+
+
+class ConflictResolverState(object):
+    def __init__(self):
+        # keep a set of resolved discriminators to test against to ensure
+        # that a new action does not conflict with something already executed
+        self.resolved_ainfos = {}
+
+        # actions left over from a previous iteration
+        self.remaining_actions = []
+
+        # after executing an action we memoize its order to avoid any new
+        # actions sending us backward
+        self.min_order = None
+
+        # unique tracks the index of the action so we need it to increase
+        # monotonically across invocations to resolveConflicts
+        self.start = 0
+
+
+# this function is licensed under the ZPL (stolen from Zope)
+def resolveConflicts(actions, state=None):
+    """Resolve conflicting actions
+
+    Given an actions list, identify and try to resolve conflicting actions.
+    Actions conflict if they have the same non-None discriminator.
+
+    Conflicting actions can be resolved if the include path of one of
+    the actions is a prefix of the includepaths of the other
+    conflicting actions and is unequal to the include paths in the
+    other conflicting actions.
+
+    Actions are resolved on a per-order basis because some discriminators
+    cannot be computed until earlier actions have executed. An action in an
+    earlier order may execute successfully only to find out later that it was
+    overridden by another action with a smaller include path. This will result
+    in a conflict as there is no way to revert the original action.
+
+    ``state`` may be an instance of ``ConflictResolverState`` that
+    can be used to resume execution and resolve the new actions against the
+    list of executed actions from a previous call.
+
+    """
+    if state is None:
+        state = ConflictResolverState()
+
+    # pick up where we left off last time, but track the new actions as well
+    state.remaining_actions.extend(normalize_actions(actions))
+    actions = state.remaining_actions
+
+    def orderandpos(v):
+        n, v = v
+        return (v['order'] or 0, n)
+
+    def orderonly(v):
+        n, v = v
+        return v['order'] or 0
+
+    sactions = sorted(enumerate(actions, start=state.start), key=orderandpos)
+    for order, actiongroup in itertools.groupby(sactions, orderonly):
+        # "order" is an integer grouping. Actions in a lower order will be
+        # executed before actions in a higher order.  All of the actions in
+        # one grouping will be executed (its callable, if any will be called)
+        # before any of the actions in the next.
+        output = []
+        unique = {}
+
+        # error out if we went backward in order
+        if state.min_order is not None and order < state.min_order:
+            r = [
+                'Actions were added to order={0} after execution had moved '
+                'on to order={1}. Conflicting actions: '.format(
+                    order, state.min_order
+                )
+            ]
+            for i, action in actiongroup:
+                for line in str(action['info']).rstrip().split('\n'):
+                    r.append("  " + line)
+            raise ConfigurationError('\n'.join(r))
+
+        for i, action in actiongroup:
+            # Within an order, actions are executed sequentially based on
+            # original action ordering ("i").
+
+            # "ainfo" is a tuple of (i, action) where "i" is an integer
+            # expressing the relative position of this action in the action
+            # list being resolved, and "action" is an action dictionary.  The
+            # purpose of an ainfo is to associate an "i" with a particular
+            # action; "i" exists for sorting after conflict resolution.
+            ainfo = (i, action)
+
+            # wait to defer discriminators until we are on their order because
+            # the discriminator may depend on state from a previous order
+            discriminator = undefer(action['discriminator'])
+            action['discriminator'] = discriminator
+
+            if discriminator is None:
+                # The discriminator is None, so this action can never conflict.
+                # We can add it directly to the result.
+                output.append(ainfo)
+                continue
+
+            L = unique.setdefault(discriminator, [])
+            L.append(ainfo)
+
+        # Check for conflicts
+        conflicts = {}
+        for discriminator, ainfos in unique.items():
+            # We use (includepath, i) as a sort key because we need to
+            # sort the actions by the paths so that the shortest path with a
+            # given prefix comes first.  The "first" action is the one with the
+            # shortest include path.  We break sorting ties using "i".
+            def bypath(ainfo):
+                path, i = ainfo[1]['includepath'], ainfo[0]
+                return path, order, i
+
+            ainfos.sort(key=bypath)
+            ainfo, rest = ainfos[0], ainfos[1:]
+            _, action = ainfo
+
+            # ensure this new action does not conflict with a previously
+            # resolved action from an earlier order / invocation
+            prev_ainfo = state.resolved_ainfos.get(discriminator)
+            if prev_ainfo is not None:
+                _, paction = prev_ainfo
+                basepath, baseinfo = paction['includepath'], paction['info']
+                includepath = action['includepath']
+                # if the new action conflicts with the resolved action then
+                # note the conflict, otherwise drop the action as it's
+                # effectively overriden by the previous action
+                if (
+                    includepath[: len(basepath)] != basepath
+                    or includepath == basepath
+                ):
+                    L = conflicts.setdefault(discriminator, [baseinfo])
+                    L.append(action['info'])
+
+            else:
+                output.append(ainfo)
+
+            basepath, baseinfo = action['includepath'], action['info']
+            for _, action in rest:
+                includepath = action['includepath']
+                # Test whether path is a prefix of opath
+                if (
+                    includepath[: len(basepath)] != basepath
+                    or includepath == basepath  # not a prefix
+                ):
+                    L = conflicts.setdefault(discriminator, [baseinfo])
+                    L.append(action['info'])
+
+        if conflicts:
+            raise ConfigurationConflictError(conflicts)
+
+        # sort resolved actions by "i" and yield them one by one
+        for i, action in sorted(output, key=operator.itemgetter(0)):
+            # do not memoize the order until we resolve an action inside it
+            state.min_order = action['order']
+            state.start = i + 1
+            state.remaining_actions.remove(action)
+            state.resolved_ainfos[action['discriminator']] = (i, action)
+            yield action
+
+
+def normalize_actions(actions):
+    """Convert old-style tuple actions to new-style dicts."""
+    result = []
+    for v in actions:
+        if not isinstance(v, dict):
+            v = expand_action_tuple(*v)
+        result.append(v)
+    return result
+
+
+def expand_action_tuple(
+    discriminator,
+    callable=None,
+    args=(),
+    kw=None,
+    includepath=(),
+    info=None,
+    order=0,
+    introspectables=(),
+):
+    if kw is None:
+        kw = {}
+    return dict(
+        discriminator=discriminator,
+        callable=callable,
+        args=args,
+        kw=kw,
+        includepath=includepath,
+        info=info,
+        order=order,
+        introspectables=introspectables,
+    )