Support for custom type dispatcher

cornice_swagger/converters/__init__.py

@@ -7,11 +7,8 @@
 from cornice_swagger.converters.parameters import ParameterConversionDispatcher
 
 
-def convert_schema(schema_node):
-
-    dispatcher = TypeConversionDispatcher()
+def convert_schema(schema_node, dispatcher=TypeConversionDispatcher()):
     converted = dispatcher(schema_node)
-
     return converted
 
 

cornice_swagger/converters/schema.py

@@ -237,24 +237,28 @@ def convert_type(self, schema_node):
 
 class TypeConversionDispatcher(object):
 
-    converters = {
-        colander.Boolean: BooleanTypeConverter,
-        colander.Date: DateTypeConverter,
-        colander.DateTime: DateTimeTypeConverter,
-        colander.Float: NumberTypeConverter,
-        colander.Integer: IntegerTypeConverter,
-        colander.Mapping: ObjectTypeConverter,
-        colander.Sequence: ArrayTypeConverter,
-        colander.String: StringTypeConverter,
-        colander.Time: TimeTypeConverter,
-    }
+    def __init__(self, custom_converters=None, default_converter=None):
+        self.converters = {
+            colander.Boolean: BooleanTypeConverter,
+            colander.Date: DateTypeConverter,
+            colander.DateTime: DateTimeTypeConverter,
+            colander.Float: NumberTypeConverter,
+            colander.Integer: IntegerTypeConverter,
+            colander.Mapping: ObjectTypeConverter,
+            colander.Sequence: ArrayTypeConverter,
+            colander.String: StringTypeConverter,
+            colander.Time: TimeTypeConverter,
+        }
+        if custom_converters:
+            self.converters.update(custom_converters)
+        self.default_converter = default_converter
 
     def __call__(self, schema_node):
 
         schema_type = schema_node.typ
         schema_type = type(schema_type)
 
-        converter_class = self.converters.get(schema_type)
+        converter_class = self.converters.get(schema_type, self.default_converter)
         if converter_class is None:
             raise NoSuchConverter
 

cornice_swagger/swagger.py

@@ -6,6 +6,7 @@
 import six
 
 from cornice_swagger.util import body_schema_transformer, merge_dicts, trim
+from cornice_swagger.converters import TypeConversionDispatcher
 from cornice_swagger.converters import convert_schema, convert_parameter
 
 
@@ -16,7 +17,8 @@ class CorniceSwaggerException(Exception):
 class CorniceSwagger(object):
     """Handles the creation of a swagger document from a cornice application."""
 
-    def __init__(self, services, def_ref_depth=0, param_ref=False, resp_ref=False):
+    def __init__(self, services, def_ref_depth=0, param_ref=False, resp_ref=False,
+                 custom_type_converters=None, default_type_converter=None):
         """
         :param services:
             List of cornice services to document. You may use
@@ -33,11 +35,18 @@ def __init__(self, services, def_ref_depth=0, param_ref=False, resp_ref=False):
             Defines if swagger responses should be put inline on the operation
             or on the responses section and referenced by JSON pointers.
             Default is inline.
+        :param custom_type_converters:
+            A dictionary mapping user defined cornice types to callables
+            implementing cornice_swagger.converters.schema.TypeConverter iface
+        :param default_type_converter:
+            Default TypeConverter to use when there is no type registered for a
+            cornice type. If it's not given and the type is not registered,
+            cornice_swagger.converters.exceptions.NoSuchConverter is raised
         """
 
         self.services = services
-
-        self.definitions = DefinitionHandler(ref=def_ref_depth)
+        typ_dispatcher = TypeConversionDispatcher(custom_type_converters, default_type_converter)
+        self.definitions = DefinitionHandler(ref=def_ref_depth, typ_dispatcher=typ_dispatcher)
         self.parameters = ParameterHandler(self.definitions,
                                            ref=param_ref)
         self.responses = ResponseHandler(self.definitions,
@@ -309,14 +318,18 @@ class DefinitionHandler(object):
 
     json_pointer = '#/definitions/'
 
-    def __init__(self, ref=0):
+    def __init__(self, ref=0, typ_dispatcher=TypeConversionDispatcher()):
         """
         :param ref:
             The depth that should be used by self.ref when calling self.from_schema.
         """
 
         self.definition_registry = {}
         self.ref = ref
+        self.typ_dispatcher = typ_dispatcher
+
+    def convert_schema(self, schema_node):
+        return convert_schema(schema_node, self.typ_dispatcher)
 
     def from_schema(self, schema_node, base_name=None):
         """
@@ -330,7 +343,7 @@ def from_schema(self, schema_node, base_name=None):
         :rtype: dict
             Swagger schema.
         """
-        return self._ref_recursive(convert_schema(schema_node), self.ref, base_name)
+        return self._ref_recursive(self.convert_schema(schema_node), self.ref, base_name)
 
     def _ref_recursive(self, schema, depth, base_name=None):
         """
@@ -515,7 +528,7 @@ def from_schema_mapping(self, schema_mapping):
                     response['schema'] = self.definitions.from_schema(field_schema)
 
                 elif location in ('header', 'headers'):
-                    header_schema = convert_schema(field_schema)
+                    header_schema = self.definitions.convert_schema(field_schema)
                     headers = header_schema.get('properties')
                     if headers:
                         # Response headers doesn't accept titles

tests/support.py

@@ -55,3 +55,11 @@ class AnotherDeclarativeSchema(colander.MappingSchema):
     @colander.instantiate(description='my another body')
     class body(colander.MappingSchema):
         timestamp = colander.SchemaNode(colander.Int())
+
+
+class MyType(colander.String):
+    pass
+
+
+class CustomTypeQuerySchema(colander.MappingSchema):
+    foo = colander.SchemaNode(MyType(), missing=colander.drop)

tests/test_parameter_handler.py

@@ -4,11 +4,13 @@
 
 from cornice.validators import colander_body_validator
 
+from cornice_swagger.converters import TypeConversionDispatcher
+from cornice_swagger.converters.schema import StringTypeConverter
 from cornice_swagger.swagger import ParameterHandler, DefinitionHandler
 from cornice_swagger.converters import convert_schema
 from cornice_swagger.util import body_schema_transformer
-from .support import (BodySchema, PathSchema, QuerySchema, HeaderSchema,
-                      DeclarativeSchema, AnotherDeclarativeSchema)
+from .support import (BodySchema, PathSchema, QuerySchema, HeaderSchema, MyType,
+                      DeclarativeSchema, AnotherDeclarativeSchema, CustomTypeQuerySchema)
 
 
 class SchemaParamConversionTest(unittest.TestCase):
@@ -57,6 +59,45 @@ class RequestSchema(colander.MappingSchema):
         }
         self.assertDictEqual(params[0], expected)
 
+    def test_covert_query_with_custom_colander_type(self):
+        converters = {MyType: StringTypeConverter}
+        typ_dispatcher = TypeConversionDispatcher(custom_converters=converters)
+        definition_handler = DefinitionHandler(typ_dispatcher=typ_dispatcher)
+
+        class RequestSchema(colander.MappingSchema):
+            querystring = CustomTypeQuerySchema()
+
+        node = RequestSchema()
+        params = ParameterHandler(definition_handler).from_schema(node)
+        self.assertEquals(len(params), 1)
+
+        expected = {
+            'name': 'foo',
+            'in': 'query',
+            'type': 'string',
+            'required': False
+        }
+        self.assertDictEqual(params[0], expected)
+
+    def test_covert_query_with_default_colander_type(self):
+        typ_dispatcher = TypeConversionDispatcher(default_converter=StringTypeConverter)
+        definition_handler = DefinitionHandler(typ_dispatcher=typ_dispatcher)
+
+        class RequestSchema(colander.MappingSchema):
+            querystring = CustomTypeQuerySchema()
+
+        node = RequestSchema()
+        params = ParameterHandler(definition_handler).from_schema(node)
+        self.assertEquals(len(params), 1)
+
+        expected = {
+            'name': 'foo',
+            'in': 'query',
+            'type': 'string',
+            'required': False
+        }
+        self.assertDictEqual(params[0], expected)
+
     def test_covert_headers_with_request_validator_schema(self):
 
         class RequestSchema(colander.MappingSchema):

tests/test_swagger.py

@@ -69,6 +69,14 @@ def test_with_resp_ref(self):
         validate(spec)
         self.assertIn('responses', spec)
 
+    def test_using_provided_dispatcher_params(self):
+        # todo: improve testing by mocking definitions and ensure that .convert_schema is called
+        default_typ = object()
+        swagger = CorniceSwagger([], custom_type_converters={default_typ: default_typ},
+                                 default_type_converter=default_typ)
+        self.assertIn(default_typ, swagger.definitions.typ_dispatcher.converters)
+        self.assertEqual(default_typ, swagger.definitions.typ_dispatcher.default_converter)
+
     def test_swagger_field_updates_extracted_paths(self):
         swagger = CorniceSwagger([self.service])
         raw_swagger = {