make tests pass; remove toposort stuff

7 files changed, 59 insertions, 199 deletions

diff --git a/pyramid/config.py b/pyramid/config.py
index 5288d1d48..914bfbd53 100644
--- a/pyramid/config.py
+++ b/pyramid/config.py
@@ -38,7 +38,7 @@ from pyramid.interfaces import IRendererFactory
 from pyramid.interfaces import IRendererGlobalsFactory
 from pyramid.interfaces import IRequest
 from pyramid.interfaces import IRequestFactory
-from pyramid.interfaces import IRequestHandlerManager
+from pyramid.interfaces import IRequestHandlers
 from pyramid.interfaces import IResponse
 from pyramid.interfaces import IRootFactory
 from pyramid.interfaces import IRouteRequest
@@ -735,8 +735,8 @@ class Configurator(object):
         from webob.exc import WSGIHTTPException as WebobWSGIHTTPException
         registry.registerSelfAdapter((WebobResponse,), IResponse)
         # add a handler manager
-        handler_manager = RequestHandlerManager()
-        registry.registerUtility(handler_manager, IRequestHandlerManager)
+        handler_manager = RequestHandlers()
+        registry.registerUtility(handler_manager, IRequestHandlers)
         self._add_request_handler('pyramid.router.exc_view_handler_factory',
                                   explicit=False)
 
@@ -1016,7 +1016,7 @@ class Configurator(object):
                             str(id(handler_factory)))
         def register():
             registry = self.registry
-            handler_manager = registry.getUtility(IRequestHandlerManager)
+            handler_manager = registry.getUtility(IRequestHandlers)
             handler_manager.add(name, handler_factory, explicit)
         self.action(('request_handler', name), register)
         
@@ -3455,8 +3455,8 @@ def isexception(o):
 
 global_registries = WeakOrderedSet()
 
-class RequestHandlerManager(object):
-    implements(IRequestHandlerManager)
+class RequestHandlers(object):
+    implements(IRequestHandlers)
     def __init__(self):
         self.explicit = []
         self.implicit = []
@@ -3471,7 +3471,7 @@ class RequestHandlerManager(object):
         handler_factories = self.implicit
         if self.explicit:
             handler_factories = self.explicit
-        for name, factory in handler_factories[::-1]:
+        for name, factory in handler_factories:
             handler = factory(handler, registry)
         return handler
     
diff --git a/pyramid/interfaces.py b/pyramid/interfaces.py
index 0c4f4bc76..c4bacd46d 100644
--- a/pyramid/interfaces.py
+++ b/pyramid/interfaces.py
@@ -446,7 +446,7 @@ class IMultiDict(Interface): # docs-only interface
 class IRequest(Interface):
     """ Request type interface attached to all request objects """
 
-class IRequestHandlerManager(Interface):
+class IRequestHandlers(Interface):
     """ Marker interface for utility registration representing the ordered
     set of a configuration's request handler factories"""
 
diff --git a/pyramid/router.py b/pyramid/router.py
index b068458be..d8f5a08da 100644
--- a/pyramid/router.py
+++ b/pyramid/router.py
@@ -14,7 +14,7 @@ from pyramid.interfaces import IRoutesMapper
 from pyramid.interfaces import ITraverser
 from pyramid.interfaces import IView
 from pyramid.interfaces import IViewClassifier
-from pyramid.interfaces import IRequestHandlerManager
+from pyramid.interfaces import IRequestHandlers
 
 from pyramid.events import ContextFound
 from pyramid.events import NewRequest
@@ -39,7 +39,7 @@ class Router(object):
         self.root_factory = q(IRootFactory, default=DefaultRootFactory)
         self.routes_mapper = q(IRoutesMapper)
         self.request_factory = q(IRequestFactory, default=Request)
-        handler_manager = q(IRequestHandlerManager)
+        handler_manager = q(IRequestHandlers)
         if handler_manager is None:
             self.handle_request = exc_view_handler_factory(self.handle_request,
                                                            registry)
@@ -219,7 +219,7 @@ def exc_view_handler_factory(handler, registry):
             has_listeners and notify(NewResponse(request, response))
         finally:
             attrs['exc_info'] = None
-            attrs['exception'] = None
+
         return request, response
 
     return exception_view_handler
diff --git a/pyramid/tests/test_config.py b/pyramid/tests/test_config.py
index fbdf9e0b5..ebc3f85cc 100644
--- a/pyramid/tests/test_config.py
+++ b/pyramid/tests/test_config.py
@@ -336,6 +336,7 @@ class ConfiguratorTests(unittest.TestCase):
         reg = DummyRegistry()
         config = self._makeOne(reg)
         config.add_view = lambda *arg, **kw: False
+        config._add_request_handler = lambda *arg, **kw: False
         config.setup_registry()
         self.assertEqual(reg.has_listeners, True)
 
@@ -347,6 +348,7 @@ class ConfiguratorTests(unittest.TestCase):
         config = self._makeOne(reg)
         views = []
         config.add_view = lambda *arg, **kw: views.append((arg, kw))
+        config._add_request_handler = lambda *arg, **kw: False
         config.setup_registry()
         self.assertEqual(views[0], ((default_exceptionresponse_view,),
                                     {'context':IExceptionResponse}))
@@ -5645,8 +5647,6 @@ class DummyRegistry(object):
         self.adapters.append((arg, kw))
     def queryAdapter(self, *arg, **kw):
         return self.adaptation
-    def getUtility(self, *arg, **kw):
-        return self.utilities[-1]
 
 def parse_httpdate(s):
     import datetime
diff --git a/pyramid/tests/test_router.py b/pyramid/tests/test_router.py
index 633fe63f5..6921de179 100644
--- a/pyramid/tests/test_router.py
+++ b/pyramid/tests/test_router.py
@@ -134,53 +134,52 @@ class TestRouter(unittest.TestCase):
         router = self._makeOne()
         self.assertEqual(router.request_factory, DummyRequestFactory)
 
-    ## def test_request_handler_factories(self):
-    ##     from pyramid.interfaces import IRequestHandlerFactory
-    ##     from pyramid.interfaces import IRequestHandlerFactories
-    ##     L = []
-    ##     def handler_factory1(handler, registry):
-    ##         L.append((handler, registry))
-    ##         def wrapper(request):
-    ##             request.environ['handled'].append('one')
-    ##             return handler(request)
-    ##         wrapper.name = 'one'
-    ##         wrapper.child = handler
-    ##         return wrapper
-    ##     def handler_factory2(handler, registry):
-    ##         L.append((handler, registry))
-    ##         def wrapper(request):
-    ##             request.environ['handled'] = ['two']
-    ##             return handler(request)
-    ##         wrapper.name = 'two'
-    ##         wrapper.child = handler
-    ##         return wrapper
-    ##     self.registry.registerUtility(['one', 'two'], IRequestHandlerFactories)
-    ##     self.registry.registerUtility(handler_factory1,
-    ##                                   IRequestHandlerFactory, name='one')
-    ##     self.registry.registerUtility(handler_factory2,
-    ##                                   IRequestHandlerFactory, name='two')
-    ##     router = self._makeOne()
-    ##     self.assertEqual(router.handle_request.name, 'two')
-    ##     self.assertEqual(router.handle_request.child.name, 'one')
-    ##     self.assertEqual(router.handle_request.child.child.__name__,
-    ##                      'handle_request')
-    ##     from pyramid.response import Response
-    ##     from pyramid.interfaces import IViewClassifier
-    ##     from pyramid.interfaces import IResponse
-    ##     context = DummyContext()
-    ##     self._registerTraverserFactory(context)
-    ##     environ = self._makeEnviron()
-    ##     view = DummyView('abc')
-    ##     self._registerView(self.config.derive_view(view), '',
-    ##                        IViewClassifier, None, None)
-    ##     start_response = DummyStartResponse()
-    ##     def make_response(s):
-    ##         return Response(s)
-    ##     router.registry.registerAdapter(make_response, (str,), IResponse)
-    ##     app_iter = router(environ, start_response)
-    ##     self.assertEqual(app_iter, ['abc'])
-    ##     self.assertEqual(start_response.status, '200 OK')
-    ##     self.assertEqual(environ['handled'], ['two', 'one'])
+    def test_request_handler_factories(self):
+        from pyramid.interfaces import IRequestHandlers
+        from pyramid.config import RequestHandlers
+        handler_manager = RequestHandlers()
+        self.registry.registerUtility(handler_manager, IRequestHandlers)
+        L = []
+        def handler_factory1(handler, registry):
+            L.append((handler, registry))
+            def wrapper(request):
+                request.environ['handled'].append('one')
+                return handler(request)
+            wrapper.name = 'one'
+            wrapper.child = handler
+            return wrapper
+        def handler_factory2(handler, registry):
+            L.append((handler, registry))
+            def wrapper(request):
+                request.environ['handled'] = ['two']
+                return handler(request)
+            wrapper.name = 'two'
+            wrapper.child = handler
+            return wrapper
+        handler_manager.add('one', handler_factory1)
+        handler_manager.add('two', handler_factory2)
+        router = self._makeOne()
+        self.assertEqual(router.handle_request.name, 'two')
+        self.assertEqual(router.handle_request.child.name, 'one')
+        self.assertEqual(router.handle_request.child.child.__name__,
+                         'handle_request')
+        from pyramid.response import Response
+        from pyramid.interfaces import IViewClassifier
+        from pyramid.interfaces import IResponse
+        context = DummyContext()
+        self._registerTraverserFactory(context)
+        environ = self._makeEnviron()
+        view = DummyView('abc')
+        self._registerView(self.config.derive_view(view), '',
+                           IViewClassifier, None, None)
+        start_response = DummyStartResponse()
+        def make_response(s):
+            return Response(s)
+        router.registry.registerAdapter(make_response, (str,), IResponse)
+        app_iter = router(environ, start_response)
+        self.assertEqual(app_iter, ['abc'])
+        self.assertEqual(start_response.status, '200 OK')
+        self.assertEqual(environ['handled'], ['two', 'one'])
 
     def test_call_traverser_default(self):
         from pyramid.httpexceptions import HTTPNotFound
diff --git a/pyramid/tests/test_util.py b/pyramid/tests/test_util.py
index 62477ed9f..247b61dad 100644
--- a/pyramid/tests/test_util.py
+++ b/pyramid/tests/test_util.py
@@ -246,68 +246,5 @@ class Test_WeakOrderedSet(unittest.TestCase):
         self.assertEqual(list(wos), [])
         self.assertEqual(wos.last, None)
 
-class Test_topological_sort(unittest.TestCase):
-    def _callFUT(self, items, partial_order, ignore_missing_partials=True):
-        from pyramid.util import topological_sort
-        return topological_sort(items, partial_order, ignore_missing_partials)
-
-    def test_no_items_no_order(self):
-        result = self._callFUT([], [])
-        self.assertEqual(result, [])
-
-    def test_no_order(self):
-        result = self._callFUT(['a', 'b'], [])
-        self.assertEqual(result, ['a', 'b'])
-
-    def test_partial_order(self):
-        result = self._callFUT(['a', 'b', 'c'], [('b', 'c')])
-        self.assertEqual(result, ['a', 'b', 'c'])
-
-    def test_partial_order2(self):
-        result = self._callFUT(['a', 'b', 'c'], [('a', 'b'), ('b', 'c')])
-        self.assertEqual(result, ['a', 'b', 'c'])
-
-    def test_partial_order3(self):
-        result = self._callFUT(['a', 'b', 'c'], [('a', 'c'), ('b', 'a')])
-        self.assertEqual(result, ['b', 'a', 'c'])
-
-    def test_partial_order4(self):
-        result = self._callFUT(['a', 'b', 'c', 'd'], [('d', 'c')])
-        self.assertEqual(result, ['a', 'b', 'd', 'c'])
-
-    def test_partial_order_missing_partial_a(self):
-        result = self._callFUT(['a', 'b', 'c', 'd'], [('d', 'c'), ('f', 'c')])
-        self.assertEqual(result, ['a', 'b', 'd', 'c'])
-
-    def test_partial_order_missing_partial_b(self):
-        result = self._callFUT(['a', 'b', 'c', 'd'], [('d', 'c'), ('c', 'f')])
-        self.assertEqual(result, ['a', 'b', 'd', 'c'])
-
-    def test_cycle_direct(self):
-        from pyramid.util import CyclicDependencyError
-        self.assertRaises(
-            CyclicDependencyError,
-            self._callFUT,
-            ['a', 'b', 'c', 'd'], [('c', 'd'), ('d', 'c')])
-
-    def test_cycle_indirect(self):
-        from pyramid.util import CyclicDependencyError
-        self.assertRaises(
-            CyclicDependencyError,
-            self._callFUT,
-            ['a', 'b', 'c', 'd', 'e'],
-            [('c', 'd'), ('d', 'e'), ('e', 'c')])
-
-class TestCyclicDependencyError(unittest.TestCase):
-    def _makeOne(self, cycles):
-        from pyramid.util import CyclicDependencyError
-        return CyclicDependencyError(cycles)
-
-    def test___str__(self):
-        exc = self._makeOne({'a':['c', 'd'], 'c':['a']})
-        result = str(exc)
-        self.assertEqual(result,
-                         "'a' depends on ['c', 'd']; 'c' depends on ['a']")
-
 class Dummy(object):
     pass
diff --git a/pyramid/util.py b/pyramid/util.py
index 5de8aa37a..c0e7640c4 100644
--- a/pyramid/util.py
+++ b/pyramid/util.py
@@ -207,79 +207,3 @@ class WeakOrderedSet(object):
             oid = self._order[-1]
             return self._items[oid]()
 
-def topological_sort(items, partial_order, ignore_missing_partials=True):
-    """
-    Stolen from http://www.bitinformation.com/art/python_topsort.html
-    (modified to sort initial roots in items order, and to ignore missing
-    partials).
-
-    Given the example list of items ['item2', 'item3', 'item1',
-    'item4'] and a 'partial order' list in the form [(item1, item2),
-    (item2, item3)], where the example tuples indicate that 'item1'
-    should precede 'item2' and 'item2' should precede 'item3', return
-    the sorted list of items ['item1', 'item2', 'item3', 'item4'].
-    Note that since 'item4' is not mentioned in the partial ordering
-    list, it will be at an arbitrary position in the returned list.
-    """
-    def add_node(graph, node, roots):
-        if not graph.has_key(node):
-            roots.append(node)
-            graph[node] = [0] # 0 = number of arcs coming into this node
-
-    def add_arc(graph, fromnode, tonode, roots):
-        graph[fromnode].append(tonode)
-        graph[tonode][0] = graph[tonode][0] + 1
-        if tonode in roots:
-            roots.remove(tonode)
-
-    graph = {}
-    roots = []
-
-    for v in items:
-        add_node(graph, v, roots)
-
-    for a, b in partial_order:
-        if ignore_missing_partials:
-            # don't fail if a value is present in the partial_order
-            # list but missing in items.  In this mode, we fake up a
-            # value instead of raising a KeyError when trying to use
-            # add_arc.  The result will contain the faked item.
-            if not graph.has_key(a):
-                add_node(graph, a, roots)
-            elif not graph.has_key(b):
-                add_node(graph, b, roots)
-        add_arc(graph, a, b, roots)
-
-    sorted = []
-
-    while roots:
-        root = roots.pop(0)
-        sorted.append(root)
-        for child in graph[root][1:]:
-            graph[child][0] = graph[child][0] - 1
-            if graph[child][0] == 0:
-                roots.insert(0, child)
-        del graph[root]
-
-    if graph:
-        # loop in input
-        cycledeps = {}
-        for k, v in graph.items():
-            cycledeps[k] = v[1:]
-        raise CyclicDependencyError(cycledeps)
-
-    return [ x for x in sorted if x in items ]
-
-class CyclicDependencyError(ConfigurationError):
-    def __init__(self, cycles):
-        self.cycles = cycles
-
-    def __str__(self):
-        L = []
-        cycles = self.cycles
-        for cycle in cycles:
-            dependent = cycle
-            dependees = cycles[cycle]
-            L.append('%r depends on %r' % (dependent, dependees))
-        msg = '; '.join(L)
-        return msg