more generic useable

example_a.py

 from hapic.data import HapicData
 
 app = bottle.Bottle()
+# hapic.global_exception_handler(UnAuthExc, StandardErrorSchema)
+# hapic.global_exception_handler(UnAuthExc2, StandardErrorSchema)
+# hapic.global_exception_handler(UnAuthExc3, StandardErrorSchema)
+bottle.default_app.push(app)
+hapic.set_context(hapic.ext.bottle.bottle_context)
 
 
 def bob(f):
 # print(yaml.dump(ss, default_flow_style=False))
 # time.sleep(1)
 
-print(json.dumps(hapic.generate_doc(app)))
+print(json.dumps(hapic.generate_doc()))
 
 app.run(host='localhost', port=8080, debug=True)

hapic/__init__.py

 # -*- coding: utf-8 -*-
+from hapic.context import BottleContext
 from hapic.hapic import Hapic
 
 _hapic_default = Hapic()
 output_body = _hapic_default.output_body
 # with_api_doc_bis = _hapic_default.with_api_doc_bis
 generate_doc = _hapic_default.generate_doc
+set_context = _hapic_default.set_context
 handle_exception = _hapic_default.handle_exception
 
 # from hapic.hapic import with_api_doc
 # from hapic.hapic import error_schema
 
 
-# class FakeSetContext(object):
-#     def bottle_context(self):
-#         hapic.set_fake_default_context(BottleContext())
-#         def decorator(func):
-#             def wrapper(*args, **kwargs):
-#                 return func(*args, **kwargs)
-#             return wrapper
-#         return decorator
-#
-#
-# class FakeExt(object):
-#     bottle = FakeSetContext()
-#
-#
-# ext = FakeExt()
+class FakeSetContext(object):
+    @property
+    def bottle_context(self):
+        return BottleContext()
+
+
+class FakeExt(object):
+    bottle = FakeSetContext()
+
+
+ext = FakeExt()

hapic/context.py

             status=int(http_code),
         )
 
+    # FIXME: Pas generique
+    def get_app(self):
+        return bottle.default_app()

hapic/doc.py

     # jsonschema based
     if description.input_path:
         schema_class = type(description.input_path.wrapper.processor.schema)
+        # TODO: look schema2parameters ?
         jsonschema = schema2jsonschema(schema_class, spec=spec)
         for name, schema in jsonschema.get('properties', {}).items():
             method_operations.setdefault('parameters', []).append({

hapic/hapic.py

 from hapic.processor import ProcessorInterface
 from hapic.processor import MarshmallowInputProcessor
 
-# TODO: Gérer les erreurs de schema
+# TODO: Gérer les erreurs avec schema
+# TODO: Gérer les erreurs avec schema: pouvoir le spécialiser
 # TODO: Gérer les cas ou c'est une liste la réponse (items, item_nb)
 # TODO: Confusion nommage body/json/forms
 
 # _waiting = {}
 # _endpoints = {}
-# TODO NOW: C'est un gros gros fake !
+# FIXME: Voir
 class ErrorResponseSchema(marshmallow.Schema):
     error_message = marshmallow.fields.String(required=True)
-    error_details = marshmallow.fields.Dict(required=True)
 
-_default_global_context = BottleContext()
+
+    error_details = marshmallow.fields.Dict(required=True)
+# FIXME: C'est un gros gros fake !
 _default_global_error_schema = ErrorResponseSchema()
 
 
     def __init__(self):
         self._buffer = DecorationBuffer()
         self._controllers = []  # type: typing.List[DecoratedController]
+        self._context = None
         # TODO: Permettre la surcharge des classes utilisés ci-dessous
 
     def with_api_doc(self):
 
         return decorator
 
+    def set_context(self, context: ContextInterface) -> None:
+        assert not self._context
+        self._context = context
+
     def output_body(
         self,
         schema: typing.Any,
     ) -> typing.Callable[[typing.Callable[..., typing.Any]], typing.Any]:
         processor = processor or MarshmallowInputProcessor()
         processor.schema = schema
-        context = context or _default_global_context
+        context = context or self._context
 
         decoration = OutputBodyControllerWrapper(
             context=context,
     ) -> typing.Callable[[typing.Callable[..., typing.Any]], typing.Any]:
         processor = processor or MarshmallowInputProcessor()
         processor.schema = schema
-        context = context or _default_global_context
+        context = context or self._context
 
         decoration = OutputHeadersControllerWrapper(
             context=context,
     ) -> typing.Callable[[typing.Callable[..., typing.Any]], typing.Any]:
         processor = processor or MarshmallowInputProcessor()
         processor.schema = schema
-        context = context or _default_global_context
+        context = context or self._context
 
         decoration = InputHeadersControllerWrapper(
             context=context,
     ) -> typing.Callable[[typing.Callable[..., typing.Any]], typing.Any]:
         processor = processor or MarshmallowInputProcessor()
         processor.schema = schema
-        context = context or _default_global_context
+        context = context or self._context
 
         decoration = InputPathControllerWrapper(
             context=context,
     ) -> typing.Callable[[typing.Callable[..., typing.Any]], typing.Any]:
         processor = processor or MarshmallowInputProcessor()
         processor.schema = schema
-        context = context or _default_global_context
+        context = context or self._context
 
         decoration = InputQueryControllerWrapper(
             context=context,
     ) -> typing.Callable[[typing.Callable[..., typing.Any]], typing.Any]:
         processor = processor or MarshmallowInputProcessor()
         processor.schema = schema
-        context = context or _default_global_context
+        context = context or self._context
 
         decoration = InputBodyControllerWrapper(
             context=context,
     ) -> typing.Callable[[typing.Callable[..., typing.Any]], typing.Any]:
         processor = processor or MarshmallowInputProcessor()
         processor.schema = schema
-        context = context or _default_global_context
+        context = context or self._context
 
         decoration = InputBodyControllerWrapper(
             context=context,
         http_code: HTTPStatus = HTTPStatus.INTERNAL_SERVER_ERROR,
         context: ContextInterface = None,
     ) -> typing.Callable[[typing.Callable[..., typing.Any]], typing.Any]:
-        context = context or _default_global_context
+        context = context or self._context
 
         decoration = ExceptionHandlerControllerWrapper(
             handled_exception_class,
             return decoration.get_wrapper(func)
         return decorator
 
-    def generate_doc(self, app=None):
-        # TODO @Damien bottle specific code !
+    def generate_doc(self):
+        # FIXME @Damien bottle specific code !
+        # rendre ca generique
+        app = self._context.get_app()
         doc_generator = DocGenerator()
         return doc_generator.get_doc(self._controllers, app)