Use new structure of error response. Closes #4.

example_a.py

 # print(yaml.dump(ss, default_flow_style=False))
 # time.sleep(1)
 
-hapic.set_context(hapic.ext.bottle.bottle_context)
+hapic.set_context(hapic.ext.bottle.BottleContext())
 print(json.dumps(hapic.generate_doc(app)))
 
 app.run(host='localhost', port=8080, debug=True)

hapic/decorator.py

 from http import HTTPStatus
 
 # TODO BS 20171010: bottle specific !  # see #5
+import marshmallow
 from bottle import HTTPResponse
 
 from hapic.data import HapicData
         self,
         handled_exception_class: typing.Type[Exception],
         context: typing.Union[ContextInterface, typing.Callable[[], ContextInterface]],  # nopep8
+        schema: marshmallow.Schema,
         http_code: HTTPStatus=HTTPStatus.INTERNAL_SERVER_ERROR,
     ) -> None:
         self.handled_exception_class = handled_exception_class
         self._context = context
         self.http_code = http_code
+        self.schema = schema
 
     @property
     def context(self) -> ContextInterface:
                 func_kwargs,
             )
         except self.handled_exception_class as exc:
-            # TODO: error_dict configurable name, see #4
-            # TODO: Who assume error structure ? We have to rethink it, see #4
-            error_dict = {
-                'error_message': str(exc),
+            # TODO: "error_detail" attribute name should be configurable
+            # TODO BS 20171013: use overrideable mechanism, error object given
+            #  to schema ? see #15
+            raw_response = {
+                'message': str(exc),
+                'code': None,
+                'detail': getattr(exc, 'error_detail', {}),
             }
-            if hasattr(exc, 'error_dict'):
-                error_dict.update(exc.error_dict)
 
             error_response = self.context.get_response(
-                error_dict,
+                raw_response,
                 self.http_code,
             )
             return error_response

hapic/hapic.py

 from hapic.processor import MarshmallowInputProcessor
 from hapic.processor import MarshmallowOutputProcessor
 
-# TODO: Gérer les cas ou c'est une liste la réponse (items, item_nb), see #12
-# TODO: Confusion nommage body/json/forms, see #13
 
-# _waiting = {}
-# _endpoints = {}
 class ErrorResponseSchema(marshmallow.Schema):
-    error_message = marshmallow.fields.String(required=True)
-    error_details = marshmallow.fields.Dict(required=True)
+    message = marshmallow.fields.String(required=True)
+    details = marshmallow.fields.Dict(required=False, missing={})
+    code = marshmallow.fields.Raw(missing=None)
+
 
 _default_global_error_schema = ErrorResponseSchema()
 
 
+# TODO: Gérer les cas ou c'est une liste la réponse (items, item_nb), see #12
+# TODO: Confusion nommage body/json/forms, see #13
+
+
 class Hapic(object):
     def __init__(self):
         self._buffer = DecorationBuffer()
         decoration = ExceptionHandlerControllerWrapper(
             handled_exception_class,
             context,
-            http_code,
+            # TODO BS 20171013: Permit schema overriding, see #15
+            schema=_default_global_error_schema,
+            http_code=http_code,
         )
 
         def decorator(func):