Make doc generation more generic, see #11 + Pyramid context

.gitignore

 .cache
 *.egg-info
 .coverage
+/build
+/dist

example_a_pyramid.py

             'name': name,
         }
 
-    def bind(self, app):
-        app.route('/hello/{name}', callback=self.hello)
-        app.route('/hello/{name}', callback=self.hello2, method='POST')
-        app.route('/hello3/{name}', callback=self.hello3)
-        app.config.include('pyramid_debugtoolbar')
+    def bind(self, configurator: Configurator):
+        configurator.add_route('hello', '/hello/{name}', request_method='GET')
+        configurator.add_view(self.hello, route_name='hello', renderer='json')
 
+        configurator.add_route('hello2', '/hello/{name}', request_method='POST')  # nopep8
+        configurator.add_view(self.hello2, route_name='hello2', renderer='json')  # nopep8
 
-class PyramRoute(object):
+        configurator.add_route('hello3', '/hello3/{name}', request_method='GET')  # nopep8
+        configurator.add_view(self.hello3, route_name='hello3', renderer='json')  # nopep8
 
-    def __init__(self, app, rule, method, callback, name, **options):
-        self.app = app
-        self.rule = rule
-        self.method = method
-        self.callback = callback
-        self.name = name
 
-        if not self.name:
-            self.name = str(uuid.uuid4())
-
-        with self.app.config as config:
-            config.add_route(self.name, self.rule, request_method=self.method)
-            config.add_view(
-                self.callback, route_name=self.name, renderer='json')
-        #import pdb; pdb.set_trace()
-
-
-class Pyramidapp(object):
-
-    def __init__(self):
-        self.config = Configurator()
-        self.routes = []
-
-    def route(self,
-              rule,
-              callback,
-              method='GET',
-              name=None,
-              **options):
-        r = PyramRoute(self, rule, method, callback, name, **options)
-        self.routes.append(r)
-
-    def run(self, host, port, debug):
-        server = make_server('0.0.0.0', port, self.config.make_wsgi_app())
-        server.serve_forever()
+configurator = Configurator(autocommit=True)
+controllers = Controllers()
 
+controllers.bind(configurator)
 
-app = Pyramidapp()
+hapic.set_context(hapic.ext.pyramid.PyramidContext(configurator))
+print(json.dumps(hapic.generate_doc()))
 
-controllers = Controllers()
-controllers.bind(app)
-
-
-# time.sleep(1)
-# s = hapic.generate_doc(app)
-# ss = json.loads(json.dumps(s))
-# for path in ss['paths']:
-#     for method in ss['paths'][path]:
-#         for response_code in ss['paths'][path][method]['responses']:
-#             ss['paths'][path][method]['responses'][int(response_code)] = ss['paths'][path][method]['responses'][response_code]
-#             del ss['paths'][path][method]['responses'][int(response_code)]
-# print(yaml.dump(ss, default_flow_style=False))
-# time.sleep(1)
-
-# hapic.set_context(hapic.ext.bottle.BottleContext())
-hapic.set_context(hapic.ext.pyramid.PyramidContext())
-#import pdb; pdb.set_trace()
-print(json.dumps(hapic.generate_doc(app)))
-app.run('localhost', 8080, True)
-#server = make_server('0.0.0.0', 8080, app.config.make_wsgi_app())
-# server.serve_forever()
+server = make_server('0.0.0.0', 8080, configurator.make_wsgi_app())
+server.serve_forever()

hapic/context.py

 # -*- coding: utf-8 -*-
-import json
 import typing
 from http import HTTPStatus
 
-import bottle
+from hapic.processor import RequestParameters
+from hapic.processor import ProcessValidationError
 
-from hapic.exception import OutputValidationException
-# from hapic.hapic import _default_global_error_schema
-from hapic.processor import RequestParameters, ProcessValidationError
+if typing.TYPE_CHECKING:
+    from hapic.decorator import DecoratedController
+
+
+class RouteRepresentation(object):
+    def __init__(
+        self,
+        rule: str,
+        method: str,
+    ) -> None:
+        self.rule = rule
+        self.method = method
 
 
 class ContextInterface(object):
         http_code: HTTPStatus=HTTPStatus.BAD_REQUEST,
     ) -> typing.Any:
         raise NotImplementedError()
+
+    def find_route(
+        self,
+        decorated_controller: 'DecoratedController',
+    ) -> RouteRepresentation:
+        raise NotImplementedError()
+
+    def get_swagger_path(self, contextualised_rule: str) -> str:
+        """
+        Return OpenAPI path with context path
+        :param contextualised_rule: path of original context
+        :return: OpenAPI path
+        """
+        raise NotImplementedError()

hapic/doc.py

 # -*- coding: utf-8 -*-
-import re
 import typing
 
 import bottle
 from apispec import Path
 from apispec.ext.marshmallow.swagger import schema2jsonschema
 
-from hapic.decorator import DecoratedController
+from hapic.context import ContextInterface, RouteRepresentation
 from hapic.decorator import DECORATION_ATTRIBUTE_NAME
+from hapic.decorator import DecoratedController
 from hapic.description import ControllerDescription
 from hapic.exception import NoRoutesException
 from hapic.exception import RouteNotFound
 
-# Bottle regular expression to locate url parameters
-BOTTLE_RE_PATH_URL = re.compile(r'<(?:[^:<>]+:)?([^<>]+)>')
-
 
 def find_bottle_route(
     decorated_controller: DecoratedController,
 
 def bottle_generate_operations(
     spec,
-    bottle_route: bottle.Route,
+    route: RouteRepresentation,
     description: ControllerDescription,
 ):
     method_operations = dict()
             })
 
     operations = {
-        bottle_route.method.lower(): method_operations,
+        route.method.lower(): method_operations,
     }
 
     return operations
     def get_doc(
         self,
         controllers: typing.List[DecoratedController],
-        app,
+        context: ContextInterface,
     ) -> dict:
-        # TODO: Découper, see #11
-        # TODO: bottle specific code !, see #11
-        if not app:
-            app = bottle.default_app()
-        else:
-            bottle.default_app.push(app)
-        flatten = lambda l: [item for sublist in l for item in sublist]
-
         spec = APISpec(
             title='Swagger Petstore',
             version='1.0.0',
             plugins=[
-                'apispec.ext.bottle',
+                # 'apispec.ext.bottle',
                 'apispec.ext.marshmallow',
             ],
         )
         # with app.test_request_context():
         paths = {}
         for controller in controllers:
-            bottle_route = find_bottle_route(controller, app)
-            swagger_path = BOTTLE_RE_PATH_URL.sub(r'{\1}', bottle_route.rule)
+            route = context.find_route(controller)
+            swagger_path = context.get_swagger_path(route.rule)
 
             operations = bottle_generate_operations(
                 spec,
-                bottle_route,
+                route,
                 controller.description,
             )
 
             spec.add_path(path)
 
         return spec.to_dict()
-
-        # route_by_callbacks = []
-        # routes = flatten(app.router.dyna_routes.values())
-        # for path, path_regex, route, func_ in routes:
-        #     route_by_callbacks.append(route.callback)
-        #
-        # for description in self._controllers:
-        #     for path, path_regex, route, func_ in routes:
-        #         if route.callback == description.reference:
-        #             # TODO: use description to feed apispec
-        #             print(route.method, path, description)
-        #             continue

hapic/ext/bottle/context.py

 # -*- coding: utf-8 -*-
 import json
+import re
 import typing
 from http import HTTPStatus
 
 from hapic.exception import OutputValidationException
 from hapic.processor import RequestParameters, ProcessValidationError
 
+# Bottle regular expression to locate url parameters
+BOTTLE_RE_PATH_URL = re.compile(r'<(?:[^:<>]+:)?([^<>]+)>')
+
 
 class BottleContext(ContextInterface):
     def get_request_parameters(self, *args, **kwargs) -> RequestParameters:

hapic/ext/pyramid/context.py

 # -*- coding: utf-8 -*-
 import json
+import re
 import typing
 from http import HTTPStatus
 
 from pyramid.request import Request
 from pyramid.response import Response
-
+from pyramid.config import Configurator
 
 from hapic.context import ContextInterface
+from hapic.context import RouteRepresentation
+from hapic.decorator import DecoratedController
+from hapic.decorator import DECORATION_ATTRIBUTE_NAME
+from hapic.ext.bottle.context import BOTTLE_RE_PATH_URL
 from hapic.exception import OutputValidationException
-from hapic.processor import RequestParameters, ProcessValidationError
+from hapic.processor import RequestParameters
+from hapic.processor import ProcessValidationError
+
+# Bottle regular expression to locate url parameters
+PYRAMID_RE_PATH_URL = re.compile(r'')
 
 
 class PyramidContext(ContextInterface):
+    def __init__(self, configurator: Configurator):
+        self.configurator = configurator
+
     def get_request_parameters(self, *args, **kwargs) -> RequestParameters:
         req = args[-1]  # TODO : Check
         assert isinstance(req, Request)
             ],
             status=int(http_code),
         )
+
+    def find_route(
+        self,
+        decorated_controller: DecoratedController,
+    ) -> RouteRepresentation:
+        for category in self.configurator.introspector.get_category('views'):
+            view_intr = category['introspectable']
+            route_intr = category['related']
+
+            reference = decorated_controller.reference
+            route_token = getattr(
+                view_intr.get('callable'),
+                DECORATION_ATTRIBUTE_NAME,
+                None,
+            )
+
+            match_with_wrapper = view_intr.get('callable') == reference.wrapper
+            match_with_wrapped = view_intr.get('callable') == reference.wrapped
+            match_with_token = route_token == reference.token
+
+            if match_with_wrapper or match_with_wrapped or match_with_token:
+                # TODO BS 20171107: C'est une liste de route sous pyramid !!!
+                # Mais de toute maniere les framework womme pyramid, flask
+                # peuvent avoir un controlleur pour plusieurs routes doc
+                # .find_route doit retourner une liste au lieu d'une seule
+                # route
+                route_pattern = route_intr[0].get('pattern')
+                route_method = route_intr[0].get('request_methods')[0]
+
+                return RouteRepresentation(
+                    # TODO BS 20171107: ce code n'es pas du tout finis
+                    # (import bottle)
+                    rule=BOTTLE_RE_PATH_URL.sub(
+                        r'{\1}',
+                        route_pattern,
+                    ),
+                    method=route_method,
+                )
+
+    def get_swagger_path(self, contextualised_rule: str) -> str:
+        # TODO BS 20171110: Pyramid allow route like '/{foo:\d+}', so adapt
+        # and USE regular expression (see https://docs.pylonsproject.org/projects/pyramid/en/latest/narr/urldispatch.html#custom-route-predicates)  # nopep8
+        return contextualised_rule

hapic/hapic.py

         self._buffer = DecorationBuffer()
         self._controllers = []  # type: typing.List[DecoratedController]
         self._context = None  # type: ContextInterface
+        self.doc_generator = DocGenerator()
 
         # This local function will be pass to different components
         # who will need context but declared (like with decorator)
             return decoration.get_wrapper(func)
         return decorator
 
-    def generate_doc(self, app):
-        # FIXME: j'ai du tricher avec app, see #11
-        # FIXME @Damien bottle specific code ! see #11
-        # rendre ca generique
-        app = app or self._context.get_app()
-        doc_generator = DocGenerator()
-        return doc_generator.get_doc(self._controllers, app)
+    def generate_doc(self):
+        return self.doc_generator.get_doc(self._controllers, self.context)