change interface of get_category

3 files changed, 28 insertions, 14 deletions

diff --git a/pyramid/interfaces.py b/pyramid/interfaces.py
index a8a9cc55a..559d3c110 100644
--- a/pyramid/interfaces.py
+++ b/pyramid/interfaces.py
@@ -865,16 +865,20 @@ class IIntrospector(Interface):
         discriminator (or discriminator hash) ``discriminator``.  If it does
         not exist in the introspector, return the value of ``default`` """
 
-    def get_category(category_name, sort_key=None):
+    def get_category(category_name, default=None, sort_key=None):
         """ Get a sequence of dictionaries in the form
         ``[{'introspectable':IIntrospectable, 'related':[sequence of related
         IIntrospectables]}, ...]`` where each introspectable is part of the
-        category associated with ``category_name`` .  If ``sort_key`` is
-        ``None``, the sequence will be returned in the order the
-        introspectables were added to the introspector.  Otherwise, sort_key
-        should be a function that accepts an IIntrospectable and returns a
-        value from it (ala the ``key`` function of Python's ``sorted``
-        callable)."""
+        category associated with ``category_name`` .
+
+        If the category named ``category_name`` does not exist in the
+        introspector the value passed as ``default`` will be returned.
+
+        If ``sort_key`` is ``None``, the sequence will be returned in the
+        order the introspectables were added to the introspector.  Otherwise,
+        sort_key should be a function that accepts an IIntrospectable and
+        returns a value from it (ala the ``key`` function of Python's
+        ``sorted`` callable)."""
 
     def categories():
         """ Return a sorted sequence of category names known by
diff --git a/pyramid/registry.py b/pyramid/registry.py
index a6d70bfa8..295d6c6b9 100644
--- a/pyramid/registry.py
+++ b/pyramid/registry.py
@@ -103,19 +103,25 @@ class Introspector(object):
         intr = category.get(discriminator, default)
         return intr
 
-    def get_category(self, category_name, sort_key=None):
+    def get_category(self, category_name, default=None, sort_key=None):
         if sort_key is None:
             sort_key = operator.attrgetter('order')
-        category = self._categories[category_name]
+        category = self._categories.get(category_name)
+        if category is None:
+            return default
         values = category.values()
         values = sorted(set(values), key=sort_key)
-        return [{'introspectable':intr, 'related':self.related(intr)} for
-                intr in values]
+        return [
+            {'introspectable':intr,
+             'related':self.related(intr)}
+             for intr in values
+             ]
 
     def categorized(self, sort_key=None):
         L = []
         for category_name in self.categories():
-            L.append((category_name, self.get_category(category_name,sort_key)))
+            L.append((category_name, self.get_category(category_name,
+                                                       sort_key=sort_key)))
         return L
 
     def categories(self):
diff --git a/pyramid/tests/test_registry.py b/pyramid/tests/test_registry.py
index 3d68688d1..11019b852 100644
--- a/pyramid/tests/test_registry.py
+++ b/pyramid/tests/test_registry.py
@@ -97,6 +97,10 @@ class TestIntrospector(unittest.TestCase):
             ]
         self.assertEqual(inst.get_category('category'), expected)
 
+    def test_get_category_returns_default_on_miss(self):
+        inst = self._makeOne()
+        self.assertEqual(inst.get_category('category', '123'), '123')
+
     def test_get_category_with_sortkey(self):
         import operator
         inst = self._makeOne()
@@ -113,7 +117,7 @@ class TestIntrospector(unittest.TestCase):
             {'introspectable':intr,  'related':[]},
             ]
         self.assertEqual(
-            inst.get_category('category', operator.attrgetter('foo')),
+            inst.get_category('category', sort_key=operator.attrgetter('foo')),
                               expected)
 
     def test_categorized(self):
@@ -132,7 +136,7 @@ class TestIntrospector(unittest.TestCase):
             {'introspectable':intr,  'related':[]},
             ])]
         self.assertEqual(
-            inst.categorized(operator.attrgetter('foo')), expected)
+            inst.categorized(sort_key=operator.attrgetter('foo')), expected)
 
     def test_categories(self):
         inst = self._makeOne()