Merge pull request #1 from postatum/91415308_review_architecture

Improve and flatten architecture

ramses/__init__.py

@@ -1,8 +1,8 @@
 import pyraml.parser
-from .generators import generate_views
+from .generators import generate_server
 
 
 def includeme(config):
     parsed_raml = pyraml.parser.load(
         config.registry.settings['raml_schema'])
-    generate_views(parsed_raml, config)
+    generate_server(parsed_raml, config)

ramses/generators.py

@@ -1,54 +1,72 @@
+from __future__ import print_function
+
 from .views import RESTView
 from .objects import DemoStorage
+from .utils import (
+    ContentTypes, fields_dict, make_route_name, is_dynamic_uri)
+
 
+def setup_storage_schema(config, resource, route_name):
+    schemas = (ContentTypes.JSON, ContentTypes.TEXT_XML)
+    methods = resource.methods or {}
+    method = (methods.get('post') or
+              methods.get('put'))
+    if not method:
+        print('No methods to setup database schema from. '
+              'Route: {}'.format(route_name))
+        return
 
-def _make_route_name(name):
-    route_name = name.strip('/')
-    route_name = route_name.replace('/', '_').replace('{', '')
-    route_name = route_name.replace('}', '')
-    return route_name
+    for schema_name in schemas:
+        if schema_name not in method.body:
+            continue
+        schema = method.body[schema_name].schema
+        if schema:
+            properties = fields_dict(schema, schema_name)
+            config.registry.storage.setup_schema(
+                route_name, properties)
+            break
+    else:
+        raise Exception('Missing schema for route `{}`'.format())
 
 
-def _setup_schema(config, method_spec, route_name):
-    if 'application/json' not in method_spec.body:
-        raise Exception(
-            'Missing JSON POST schema for route `{}`'.format(route_name))
-    schema = method_spec.body['application/json'].schema
-    config.registry.storage.setup_schema(
-        route_name, schema['properties'])
+def setup_methods_handlers(config, resource, route_name):
+    if not resource.methods:
+        print('No methods to handle. Route: {}'.format(route_name))
 
+    for method_name, method in resource.methods.items():
+        config.add_view(
+            RESTView,
+            route_name=route_name,
+            renderer='json',
+            attr=method_name,
+            request_method=method_name.upper())
 
-def setup_resource(config, resource_uri, resource, uri_prefix=''):
-    resource_uri = uri_prefix + resource_uri
-    route_name = _make_route_name(resource_uri)
-    config.add_route(route_name, resource_uri)
+        print('{}:\t{}{}'.format(
+            method_name.upper(), (config.route_prefix or ''),
+            route_name.replace('_', '/')))
 
-    if not uri_prefix:
-        config.registry.storage.add_model(route_name)
 
-    if resource.methods:
-        for method, method_spec in resource.methods.items():
+def configure_resources(config, resources, uri_prefix=''):
+    for resource_uri, resource in resources.items():
+        resource_uri = uri_prefix + resource_uri
+        route_name = make_route_name(resource_uri)
+        config.add_route(route_name, resource_uri)
 
-            if method == 'post' and method_spec.body:
-                _setup_schema(config, method_spec, route_name)
+        # Do not setup model for dynamic routes for now
+        # Do not generate schema for dynamic routes for now
+        if not is_dynamic_uri(resource_uri):
+            config.registry.storage.add_model(route_name)
+            setup_storage_schema(config, resource, route_name)
 
-            config.add_view(
-                RESTView,
-                route_name=route_name,
-                renderer='json',
-                attr=method,
-                request_method=method.upper())
-            print '{}:\t{}{}'.format(
-                method.upper(), (config.route_prefix or ''),
-                resource_uri)
+        setup_methods_handlers(config, resource, route_name)
 
-    if resource.resources:
-        for subresource_uri, subresource in resource.resources.items():
-            setup_resource(config, subresource_uri, subresource, resource_uri)
+        if resource.resources:
+            configure_resources(config, resource.resources, resource_uri)
 
 
-def generate_views(parsed_raml, config):
-    resources = parsed_raml.resources
+def generate_server(parsed_raml, config):
+    # Setup storage
     config.registry.storage = DemoStorage()
-    for resource_uri, resource in resources.items():
-        setup_resource(config, resource_uri, resource)
+
+    # Setup resources
+    configure_resources(config, parsed_raml.resources)

ramses/utils.py

@@ -0,0 +1,25 @@
+
+class ContentTypes(object):
+    JSON = 'application/json'
+    TEXT_XML = 'text/xml'
+    MULTIPART_FORMDATA = 'multipart/form-data'
+    FORM_URLENCODED = 'application/x-www-form-urlencoded'
+
+
+def fields_dict(schema, schema_name):
+    if schema_name == ContentTypes.JSON:
+        return schema['properties']
+    if schema_name == ContentTypes.TEXT_XML:
+        # Process XML schema
+        pass
+
+
+def make_route_name(name):
+    route_name = name.strip('/')
+    route_name = route_name.replace('/', '_').replace('{', '')
+    route_name = route_name.replace('}', '')
+    return route_name
+
+
+def is_dynamic_uri(uri):
+    return uri.endswith('}')