"over" is closer to ingress and "under" is closer to mapped_view

4 files changed, 68 insertions, 62 deletions

diff --git a/pyramid/config/tweens.py b/pyramid/config/tweens.py
index cd14c9ff6..8e1800f33 100644
--- a/pyramid/config/tweens.py
+++ b/pyramid/config/tweens.py
@@ -18,6 +18,7 @@ from pyramid.tweens import (
 
 from pyramid.config.util import (
     action_method,
+    is_string_or_iterable,
     TopologicalSorter,
     )
 
@@ -122,12 +123,6 @@ class TweensConfiguratorMixin(object):
 
         tween_factory = self.maybe_dotted(tween_factory)
 
-        def is_string_or_iterable(v):
-            if isinstance(v, string_types):
-                return True
-            if hasattr(v, '__iter__'):
-                return True
-
         for t, p in [('over', over), ('under', under)]:
             if p is not None:
                 if not is_string_or_iterable(p):
diff --git a/pyramid/config/util.py b/pyramid/config/util.py
index 85ce826a4..626e8d5fe 100644
--- a/pyramid/config/util.py
+++ b/pyramid/config/util.py
@@ -5,6 +5,7 @@ from pyramid.compat import (
     bytes_,
     getargspec,
     is_nonstr_iter,
+    string_types,
     )
 
 from pyramid.compat import im_func
@@ -23,6 +24,12 @@ ActionInfo = ActionInfo # support bw compat imports
 MAX_ORDER = 1 << 30
 DEFAULT_PHASH = md5().hexdigest()
 
+def is_string_or_iterable(v):
+    if isinstance(v, string_types):
+        return True
+    if hasattr(v, '__iter__'):
+        return True
+
 def as_sorted_tuple(val):
     if not is_nonstr_iter(val):
         val = (val,)
diff --git a/pyramid/config/views.py b/pyramid/config/views.py
index e90b95420..db56fa761 100644
--- a/pyramid/config/views.py
+++ b/pyramid/config/views.py
@@ -89,6 +89,7 @@ from pyramid.config.derivations import (
 from pyramid.config.util import (
     DEFAULT_PHASH,
     MAX_ORDER,
+    is_string_or_iterable,
     )
 
 urljoin = urlparse.urljoin
@@ -690,7 +691,7 @@ class ViewsConfiguratorMixin(object):
 
         def combine(*decorators):
             def decorated(view_callable):
-                # reversed() is allows a more natural ordering in the api
+                # reversed() allows a more natural ordering in the api
                 for decorator in reversed(decorators):
                     view_callable = decorator(view_callable)
                 return view_callable
@@ -1029,16 +1030,15 @@ class ViewsConfiguratorMixin(object):
 
     def _apply_view_derivers(self, info):
         d = pyramid.config.derivations
-        # These inner derivations have fixed order
+        # These derivations have fixed order
+        outer_derivers = [('attr_wrapped_view', d.attr_wrapped_view),
+                          ('predicated_view', d.predicated_view)]
         inner_derivers = [('mapped_view', d.mapped_view)]
 
-        outer_derivers = [('predicated_view', d.predicated_view),
-                          ('attr_wrapped_view', d.attr_wrapped_view)]
-
         view = info.original_view
         derivers = self.registry.getUtility(IViewDerivers)
-        for name, deriver in (
-            inner_derivers + derivers.sorted() + outer_derivers
+        for name, deriver in reversed(
+            outer_derivers + derivers.sorted() + inner_derivers
         ):
             view = wraps_view(deriver)(view, info)
         return view
@@ -1110,11 +1110,11 @@ class ViewsConfiguratorMixin(object):
         of view derivers by providing hints about where in the view pipeline
         the deriver is used.
 
-        ``under`` means further away from user-defined :term:`view callable`,
-        and ``over`` means closer to the original :term:`view callable`.
+        ``under`` means closer to the user-defined :term:`view callable`,
+        and ``over`` means closer to view pipeline ingress.
 
         Specifying neither ``under`` nor ``over`` is equivalent to specifying
-        ``over='decorated_view'`` and ``under='rendered_view'``, placing the
+        ``over='rendered_view'`` and ``under='decorated_view'``, placing the
         deriver somewhere between the ``decorated_view`` and ``rendered_view``
         derivers.
 
@@ -1124,7 +1124,8 @@ class ViewsConfiguratorMixin(object):
         deriver = self.maybe_dotted(deriver)
 
         if under is None and over is None:
-            over = 'decorated_view'
+            under = 'decorated_view'
+            over = 'rendered_view'
 
         discriminator = ('view deriver', name)
         intr = self.introspectable(
@@ -1141,29 +1142,30 @@ class ViewsConfiguratorMixin(object):
             if derivers is None:
                 derivers = TopologicalSorter()
                 self.registry.registerUtility(derivers, IViewDerivers)
-            derivers.add(name, deriver, after=under, before=over)
+            derivers.add(name, deriver, before=over, after=under)
         self.action(discriminator, register, introspectables=(intr,),
                     order=PHASE1_CONFIG) # must be registered before add_view
 
     def add_default_view_derivers(self):
         d = pyramid.config.derivations
         derivers = [
-            ('decorated_view', d.decorated_view),
-            ('http_cached_view', d.http_cached_view),
-            ('owrapped_view', d.owrapped_view),
-            ('secured_view', d.secured_view),
             ('authdebug_view', d.authdebug_view),
+            ('secured_view', d.secured_view),
+            ('owrapped_view', d.owrapped_view),
+            ('http_cached_view', d.http_cached_view),
+            ('decorated_view', d.decorated_view),
         ]
-        after = pyramid.util.FIRST
+        last = pyramid.util.FIRST
         for name, deriver in derivers:
-            self.add_view_deriver(deriver, name=name, under=after)
-            after = name
+            self.add_view_deriver(deriver, name=name, under=last)
+            last = name
 
+        # ensure rendered_view is over LAST
         self.add_view_deriver(
             d.rendered_view,
-            name='rendered_view',
-            under=pyramid.util.FIRST,
-            over='decorated_view',
+            'rendered_view',
+            under=last,
+            over=pyramid.util.LAST,
         )
 
     def derive_view(self, view, attr=None, renderer=None):
diff --git a/pyramid/tests/test_config/test_derivations.py b/pyramid/tests/test_config/test_derivations.py
index 69d8797f4..d93b37f38 100644
--- a/pyramid/tests/test_config/test_derivations.py
+++ b/pyramid/tests/test_config/test_derivations.py
@@ -1110,15 +1110,15 @@ class TestDerivationOrder(unittest.TestCase):
         derivers_sorted = derivers.sorted()
         dlist = [d for (d, _) in derivers_sorted]
         self.assertEqual([
-            'rendered_view',
+            'authdebug_view',
+            'secured_view',
+            'owrapped_view',
+            'http_cached_view',
+            'decorated_view',
             'deriv2',
             'deriv3',
             'deriv1',
-            'decorated_view',
-            'http_cached_view',
-            'owrapped_view',
-            'secured_view',
-            'authdebug_view',
+            'rendered_view',
             ], dlist)
 
     def test_right_order_implicit(self):
@@ -1132,54 +1132,56 @@ class TestDerivationOrder(unittest.TestCase):
         derivers_sorted = derivers.sorted()
         dlist = [d for (d, _) in derivers_sorted]
         self.assertEqual([
-            'rendered_view',
-            'deriv1',
-            'deriv2',
-            'deriv3',
-            'decorated_view',
-            'http_cached_view',
-            'owrapped_view',
-            'secured_view',
             'authdebug_view',
+            'secured_view',
+            'owrapped_view',
+            'http_cached_view',
+            'decorated_view',
+            'deriv3',
+            'deriv2',
+            'deriv1',
+            'rendered_view',
             ], dlist)
 
-    def test_right_order_over_rendered_view(self):
+    def test_right_order_under_rendered_view(self):
         from pyramid.interfaces import IViewDerivers
 
-        self.config.add_view_deriver(None, 'deriv1', over='rendered_view')
+        self.config.add_view_deriver(None, 'deriv1', under='rendered_view')
 
         derivers = self.config.registry.getUtility(IViewDerivers)
         derivers_sorted = derivers.sorted()
         dlist = [d for (d, _) in derivers_sorted]
-        self.assertEqual(['deriv1',
-            'rendered_view',
-            'decorated_view',
-            'http_cached_view',
-            'owrapped_view',
-            'secured_view',
+        self.assertEqual([
             'authdebug_view',
+            'secured_view',
+            'owrapped_view',
+            'http_cached_view',
+            'decorated_view',
+            'rendered_view',
+            'deriv1',
             ], dlist)
 
 
-    def test_right_order_over_rendered_view_others(self):
+    def test_right_order_under_rendered_view_others(self):
         from pyramid.interfaces import IViewDerivers
 
-        self.config.add_view_deriver(None, 'deriv1', over='rendered_view')
+        self.config.add_view_deriver(None, 'deriv1', under='rendered_view')
         self.config.add_view_deriver(None, 'deriv2')
         self.config.add_view_deriver(None, 'deriv3')
 
         derivers = self.config.registry.getUtility(IViewDerivers)
         derivers_sorted = derivers.sorted()
         dlist = [d for (d, _) in derivers_sorted]
-        self.assertEqual(['deriv1',
-            'rendered_view',
-            'deriv2',
-            'deriv3',
-            'decorated_view',
-            'http_cached_view',
-            'owrapped_view',
-            'secured_view',
+        self.assertEqual([
             'authdebug_view',
+            'secured_view',
+            'owrapped_view',
+            'http_cached_view',
+            'decorated_view',
+            'deriv3',
+            'deriv2',
+            'rendered_view',
+            'deriv1',
             ], dlist)
 
 
@@ -1255,8 +1257,8 @@ class TestAddDeriver(unittest.TestCase):
             return view
 
         self.config.add_view_deriver(deriv1, 'deriv1')
-        self.config.add_view_deriver(deriv2, 'deriv2', over='deriv1')
-        self.config.add_view_deriver(deriv3, 'deriv3', under='deriv2')
+        self.config.add_view_deriver(deriv2, 'deriv2', under='deriv1')
+        self.config.add_view_deriver(deriv3, 'deriv3', over='deriv2')
         result = self.config._derive_view(view)
         self.assertEqual(response.deriv, ['deriv2', 'deriv3', 'deriv1'])