reverse meaning of under/over

4 files changed, 115 insertions, 91 deletions

diff --git a/pyramid/config.py b/pyramid/config.py
index d6a07e43c..f8f65356e 100644
--- a/pyramid/config.py
+++ b/pyramid/config.py
@@ -939,12 +939,12 @@ class Configurator(object):
             registry.registerUtility(tweens, ITweens)
             tweens.add_implicit(tween_factory_name(excview_tween_factory),
                                 excview_tween_factory, alias=EXCVIEW,
-                                under=MAIN)
+                                over=MAIN)
         if explicit:
             tweens.add_explicit(name, tween_factory)
         else:
-            tweens.add_implicit(name, tween_factory, alias=alias,
-                                under=under, over=over)
+            tweens.add_implicit(name, tween_factory, alias=alias, under=under,
+                                over=over)
         self.action(('tween', name, explicit))
         if not explicit and alias is not None:
             self.action(('tween', alias, explicit))
diff --git a/pyramid/tests/test_config.py b/pyramid/tests/test_config.py
index 8e9ce3c4b..6db59a2aa 100644
--- a/pyramid/tests/test_config.py
+++ b/pyramid/tests/test_config.py
@@ -639,11 +639,15 @@ pyramid.tests.test_config.dummy_include2""",
         config.add_tween(factory2)
         config.commit()
         tweens = config.registry.queryUtility(ITweens)
+        implicit = tweens.implicit()
         self.assertEqual(
-            tweens.implicit(),
-            [('pyramid.tweens.excview_tween_factory', excview_tween_factory),
-             ('pyramid.tests.test_config.factory1', factory1),
-             ('pyramid.tests.test_config.factory2', factory2)])
+            implicit,
+            [
+                ('pyramid.tests.test_config.factory2', factory2),
+                ('pyramid.tests.test_config.factory1', factory1),
+                ('pyramid.tweens.excview_tween_factory', excview_tween_factory),
+                ]
+            )
 
     def test_add_tween_dottedname(self):
         from pyramid.interfaces import ITweens
@@ -655,9 +659,9 @@ pyramid.tests.test_config.dummy_include2""",
         self.assertEqual(
             tweens.implicit(),
             [
-                ('pyramid.tweens.excview_tween_factory', excview_tween_factory),
                 ('pyramid.tests.test_config.dummy_tween_factory',
-                 dummy_tween_factory)
+                 dummy_tween_factory),
+                ('pyramid.tweens.excview_tween_factory', excview_tween_factory),
                 ])
 
     def test_add_tween_instance(self):
@@ -671,13 +675,13 @@ pyramid.tests.test_config.dummy_include2""",
         tweens = config.registry.queryUtility(ITweens)
         implicit = tweens.implicit()
         self.assertEqual(len(implicit), 2)
-        self.assertEqual(
-            implicit[0],
-            ('pyramid.tweens.excview_tween_factory', excview_tween_factory))
         self.assertTrue(
-          implicit[1][0].startswith(
+          implicit[0][0].startswith(
                 'pyramid.tests.test_config.ATween.'))
-        self.assertEqual(implicit[1][1], atween)
+        self.assertEqual(implicit[0][1], atween)
+        self.assertEqual(
+            implicit[1],
+            ('pyramid.tweens.excview_tween_factory', excview_tween_factory))
 
     def test_add_tween_unsuitable(self):
         from pyramid.exceptions import ConfigurationError
diff --git a/pyramid/tests/test_tweens.py b/pyramid/tests/test_tweens.py
index 7fe800f00..a626afa11 100644
--- a/pyramid/tests/test_tweens.py
+++ b/pyramid/tests/test_tweens.py
@@ -24,7 +24,7 @@ class TestTweens(unittest.TestCase):
                          {'name':'factory'})
         self.assertEqual(tweens.alias_to_name, D)
         self.assertEqual(tweens.name_to_alias, D)
-        self.assertEqual(tweens.order, [('name', INGRESS)])
+        self.assertEqual(tweens.order, [(INGRESS, 'name')])
         self.assertEqual(tweens.ingress_alias_names, ['name'])
         tweens.add_implicit('name2', 'factory2')
         self.assertEqual(tweens.names, ['name',  'name2'])
@@ -33,9 +33,9 @@ class TestTweens(unittest.TestCase):
         self.assertEqual(tweens.alias_to_name, D)
         self.assertEqual(tweens.name_to_alias, D)
         self.assertEqual(tweens.order,
-                         [('name', INGRESS), ('name2', INGRESS)])
+                         [(INGRESS, 'name'), (INGRESS, 'name2')])
         self.assertEqual(tweens.ingress_alias_names, ['name', 'name2'])
-        tweens.add_implicit('name3', 'factory3', under='name2')
+        tweens.add_implicit('name3', 'factory3', over='name2')
         self.assertEqual(tweens.names,
                          ['name',  'name2', 'name3'])
         self.assertEqual(tweens.factories,
@@ -44,8 +44,8 @@ class TestTweens(unittest.TestCase):
         self.assertEqual(tweens.alias_to_name, D)
         self.assertEqual(tweens.name_to_alias, D)
         self.assertEqual(tweens.order,
-                         [('name', INGRESS), ('name2', INGRESS),
-                          ('name2', 'name3')])
+                         [(INGRESS, 'name'), (INGRESS, 'name2'),
+                          ('name3', 'name2')])
         self.assertEqual(tweens.ingress_alias_names, ['name', 'name2'])
 
     def test_add_implicit_withaliases(self):
@@ -57,7 +57,7 @@ class TestTweens(unittest.TestCase):
                          {'name1':'factory'})
         self.assertEqual(tweens.alias_to_name['n1'], 'name1')
         self.assertEqual(tweens.name_to_alias['name1'], 'n1')
-        self.assertEqual(tweens.order, [('n1', INGRESS)])
+        self.assertEqual(tweens.order, [(INGRESS, 'n1')])
         self.assertEqual(tweens.ingress_alias_names, ['n1'])
         tweens.add_implicit('name2', 'factory2', alias='n2')
         self.assertEqual(tweens.names, ['name1',  'name2'])
@@ -66,9 +66,9 @@ class TestTweens(unittest.TestCase):
         self.assertEqual(tweens.alias_to_name['n2'], 'name2')
         self.assertEqual(tweens.name_to_alias['name2'], 'n2')
         self.assertEqual(tweens.order,
-                         [('n1', INGRESS), ('n2', INGRESS)])
+                         [(INGRESS, 'n1'), (INGRESS, 'n2')])
         self.assertEqual(tweens.ingress_alias_names, ['n1', 'n2'])
-        tweens.add_implicit('name3', 'factory3', alias='n3', under='name2')
+        tweens.add_implicit('name3', 'factory3', alias='n3', over='name2')
         self.assertEqual(tweens.names,
                          ['name1',  'name2', 'name3'])
         self.assertEqual(tweens.factories,
@@ -77,8 +77,8 @@ class TestTweens(unittest.TestCase):
         self.assertEqual(tweens.alias_to_name['n3'], 'name3')
         self.assertEqual(tweens.name_to_alias['name3'], 'n3')
         self.assertEqual(tweens.order,
-                         [('n1', INGRESS), ('n2', INGRESS),
-                          ('name2', 'n3')])
+                         [(INGRESS, 'n1'), (INGRESS, 'n2'),
+                          ('n3', 'name2')])
         self.assertEqual(tweens.ingress_alias_names, ['n1', 'n2'])
 
     def test___call___explicit(self):
@@ -118,123 +118,143 @@ class TestTweens(unittest.TestCase):
         tweens = self._makeOne()
         tweens.add_implicit('name1', 'factory1')
         tweens.add_implicit('name2', 'factory2')
-        self.assertEqual(tweens.implicit(), [('name1', 'factory1'),
-                                             ('name2', 'factory2')])
+        self.assertEqual(tweens.implicit(),
+                         [
+                             ('name2', 'factory2'),
+                             ('name1', 'factory1'),
+                             ])
 
     def test_implicit_ordering_2(self):
         from pyramid.tweens import MAIN
         tweens = self._makeOne()
         tweens.add_implicit('name1', 'factory1')
-        tweens.add_implicit('name2', 'factory2', under=MAIN)
+        tweens.add_implicit('name2', 'factory2', over=MAIN)
         self.assertEqual(tweens.implicit(),
-                         [('name2', 'factory2'), ('name1', 'factory1')])
+                         [
+                             ('name1', 'factory1'),
+                             ('name2', 'factory2'),
+                             ])
 
     def test_implicit_ordering_3(self):
         from pyramid.tweens import MAIN
         tweens = self._makeOne()
         add = tweens.add_implicit
-        add('auth', 'auth_factory', over='browserid')
+        add('auth', 'auth_factory', under='browserid')
         add('dbt', 'dbt_factory') 
-        add('retry', 'retry_factory', under='txnmgr', over='exceptionview')
+        add('retry', 'retry_factory', over='txnmgr', under='exceptionview')
         add('browserid', 'browserid_factory')
-        add('txnmgr', 'txnmgr_factory', over='exceptionview')
-        add('exceptionview', 'excview_factory', under=MAIN)
+        add('txnmgr', 'txnmgr_factory', under='exceptionview')
+        add('exceptionview', 'excview_factory', over=MAIN)
         self.assertEqual(tweens.implicit(),
-                         [('txnmgr', 'txnmgr_factory'),
-                          ('retry', 'retry_factory'),
-                          ('exceptionview', 'excview_factory'),
-                          ('auth', 'auth_factory'),
-                          ('browserid', 'browserid_factory'),
-                          ('dbt', 'dbt_factory')])
+                         [
+                             ('browserid', 'browserid_factory'),
+                             ('auth', 'auth_factory'),
+                             ('dbt', 'dbt_factory'),
+                             ('exceptionview', 'excview_factory'),
+                             ('retry', 'retry_factory'),
+                             ('txnmgr', 'txnmgr_factory'),
+                             ])
 
     def test_implicit_ordering_4(self):
         from pyramid.tweens import MAIN
         tweens = self._makeOne()
         add = tweens.add_implicit
-        add('exceptionview', 'excview_factory', under=MAIN)
-        add('auth', 'auth_factory', over='browserid')
-        add('retry', 'retry_factory', under='txnmgr', over='exceptionview')
+        add('exceptionview', 'excview_factory', over=MAIN)
+        add('auth', 'auth_factory', under='browserid')
+        add('retry', 'retry_factory', over='txnmgr', under='exceptionview')
         add('browserid', 'browserid_factory')
-        add('txnmgr', 'txnmgr_factory', over='exceptionview')
+        add('txnmgr', 'txnmgr_factory', under='exceptionview')
         add('dbt', 'dbt_factory') 
         self.assertEqual(tweens.implicit(),
-                         [('txnmgr', 'txnmgr_factory'),
-                          ('retry', 'retry_factory'),
-                          ('exceptionview', 'excview_factory'),
-                          ('auth', 'auth_factory'),
-                          ('browserid', 'browserid_factory'),
-                          ('dbt', 'dbt_factory')])
+                         [
+                             ('dbt', 'dbt_factory'),
+                             ('browserid', 'browserid_factory'),
+                             ('auth', 'auth_factory'),
+                             ('exceptionview', 'excview_factory'),
+                             ('retry', 'retry_factory'),
+                             ('txnmgr', 'txnmgr_factory'),
+                             ])
 
     def test_implicit_ordering_withaliases(self):
         from pyramid.tweens import MAIN
         tweens = self._makeOne()
         add = tweens.add_implicit
-        add('exceptionview', 'excview_factory', alias='e', under=MAIN)
-        add('auth', 'auth_factory', over='b')
-        add('retry', 'retry_factory', under='t', over='exceptionview')
+        add('exceptionview', 'excview_factory', alias='e', over=MAIN)
+        add('auth', 'auth_factory', under='b')
+        add('retry', 'retry_factory', over='t', under='exceptionview')
         add('browserid', 'browserid_factory', alias='b')
-        add('txnmgr', 'txnmgr_factory', alias='t', over='exceptionview')
+        add('txnmgr', 'txnmgr_factory', alias='t', under='exceptionview')
         add('dbt', 'dbt_factory') 
         self.assertEqual(tweens.implicit(),
-                         [('txnmgr', 'txnmgr_factory'),
-                          ('retry', 'retry_factory'),
-                          ('exceptionview', 'excview_factory'),
-                          ('auth', 'auth_factory'),
-                          ('browserid', 'browserid_factory'),
-                          ('dbt', 'dbt_factory')])
+                         [
+                             ('dbt', 'dbt_factory'),
+                             ('browserid', 'browserid_factory'),
+                             ('auth', 'auth_factory'),
+                             ('exceptionview', 'excview_factory'),
+                             ('retry', 'retry_factory'),
+                             ('txnmgr', 'txnmgr_factory'),
+                          ])
 
     def test_implicit_ordering_missing_partial(self):
         from pyramid.tweens import MAIN
         tweens = self._makeOne()
         add = tweens.add_implicit
-        add('exceptionview', 'excview_factory', under=MAIN)
-        add('auth', 'auth_factory', over='browserid')
-        add('retry', 'retry_factory', under='txnmgr', over='exceptionview')
+        add('exceptionview', 'excview_factory', over=MAIN)
+        add('auth', 'auth_factory', under='browserid')
+        add('retry', 'retry_factory', over='txnmgr', under='exceptionview')
         add('browserid', 'browserid_factory')
         add('dbt', 'dbt_factory') 
         self.assertEqual(tweens.implicit(),
-                         [('retry', 'retry_factory'),
-                          ('exceptionview', 'excview_factory'),
-                          ('auth', 'auth_factory'),
-                          ('browserid', 'browserid_factory'),
-                          ('dbt', 'dbt_factory')])
+                         [
+                             ('dbt', 'dbt_factory'),
+                             ('browserid', 'browserid_factory'),
+                             ('auth', 'auth_factory'),
+                             ('exceptionview', 'excview_factory'),
+                             ('retry', 'retry_factory'),
+                             ])
 
     def test_implicit_ordering_missing_partial2(self):
         tweens = self._makeOne()
         add = tweens.add_implicit
         add('dbt', 'dbt_factory')
-        add('auth', 'auth_factory', over='browserid')
-        add('retry', 'retry_factory', under='txnmgr', over='exceptionview')
+        add('auth', 'auth_factory', under='browserid')
+        add('retry', 'retry_factory', over='txnmgr', under='exceptionview')
         add('browserid', 'browserid_factory')
         self.assertEqual(tweens.implicit(),
-                         [('dbt', 'dbt_factory'),
-                          ('auth', 'auth_factory'),
-                          ('browserid', 'browserid_factory'),
-                          ('retry', 'retry_factory')])
+                         [
+                             ('retry', 'retry_factory'),
+                             ('browserid', 'browserid_factory'),
+                             ('auth', 'auth_factory'),
+                             ('dbt', 'dbt_factory'),
+                             ])
 
     def test_implicit_ordering_missing_partial3(self):
         from pyramid.tweens import MAIN
         tweens = self._makeOne()
         add = tweens.add_implicit
-        add('exceptionview', 'excview_factory', under=MAIN)
-        add('retry', 'retry_factory', under='txnmgr', over='exceptionview')
+        add('exceptionview', 'excview_factory', over=MAIN)
+        add('retry', 'retry_factory', over='txnmgr', under='exceptionview')
         add('browserid', 'browserid_factory')
         self.assertEqual(tweens.implicit(),
-                         [('retry', 'retry_factory'),
-                          ('exceptionview', 'excview_factory'),
-                          ('browserid', 'browserid_factory')])
+                         [
+                             ('browserid', 'browserid_factory'),
+                             ('exceptionview', 'excview_factory'),
+                             ('retry', 'retry_factory'),
+                             ])
 
     def test_implicit_ordering_missing_partial_with_aliases(self):
         from pyramid.tweens import MAIN
         tweens = self._makeOne()
         add = tweens.add_implicit
-        add('exceptionview', 'excview_factory', alias='e', under=MAIN)
-        add('retry', 'retry_factory', under='txnmgr', over='e')
+        add('exceptionview', 'excview_factory', alias='e', over=MAIN)
+        add('retry', 'retry_factory', over='txnmgr', under='e')
         add('browserid', 'browserid_factory')
         self.assertEqual(tweens.implicit(),
-                         [('retry', 'retry_factory'),
-                          ('exceptionview', 'excview_factory'),
-                          ('browserid', 'browserid_factory')])
+                         [
+                             ('browserid', 'browserid_factory'),
+                             ('exceptionview', 'excview_factory'),
+                             ('retry', 'retry_factory'),
+                             ])
 
     def test_implicit_ordering_conflict_direct(self):
         from pyramid.tweens import CyclicDependencyError
diff --git a/pyramid/tweens.py b/pyramid/tweens.py
index 1cb62999d..9a7d432dc 100644
--- a/pyramid/tweens.py
+++ b/pyramid/tweens.py
@@ -80,7 +80,7 @@ class Tweens(object):
         self.names.append(name)
         self.factories[name] = factory
         if under is None and over is None:
-            over = INGRESS
+            under = INGRESS
             self.ingress_alias_names.append(alias)
         if under is not None:
             self.order.append((under, alias))
@@ -92,7 +92,7 @@ class Tweens(object):
         roots = []
         graph = {}
         has_order = {}
-        aliases = [MAIN, INGRESS]
+        aliases = [INGRESS, MAIN]
         ingress_alias_names = self.ingress_alias_names[:]
 
         for name in self.names:
@@ -129,7 +129,7 @@ class Tweens(object):
             # nodes with orders should get an ordering relative to INGRESS,
             # as if it were added with no under or over in add_implicit
             if (not v in has_order) and (v not in (INGRESS, MAIN)):
-                order.append((v, INGRESS))
+                order.append((INGRESS, v))
                 ingress_alias_names.append(v)
             add_node(graph, v)
 
@@ -139,14 +139,14 @@ class Tweens(object):
 
         def sortroots(alias):
             # sort roots so that roots (and their children) that depend only
-            # on the ingress sort nearer the end (nearer the ingress)
+            # on the ingress sort nearer the  (nearer the ingress)
             if alias in ingress_alias_names:
-                return 1
+                return -1
             children = graph[alias][1:]
             for child in children:
-                if sortroots(child) == 1:
-                    return 1
-            return -1
+                if sortroots(child) == -1:
+                    return -1
+            return 1
 
         roots.sort(key=sortroots)
 
@@ -185,7 +185,7 @@ class Tweens(object):
             use = self.explicit
         else:
             use = self.implicit()
-        for name, factory in use:
+        for name, factory in use[::-1]:
             handler = factory(handler, registry)
         return handler