Refactor: break ControllerAPI into VersionAPI, ProjectAPI

1 files changed, 101 insertions, 33 deletions

diff --git a/ick2/controllerapi.py b/ick2/controllerapi.py
index cb553d7..958b35d 100644
--- a/ick2/controllerapi.py
+++ b/ick2/controllerapi.py
@@ -30,62 +30,83 @@ class ControllerAPI:
     def set_state_directory(self, dirname):
         self._state.set_state_directory(dirname)
 
-    def load_projects(self):
+    def load_projects(self):  # pragma: no cover
         return self._state.load_projects()
 
-    def find_missing_route(self, path):  # pragma: no cover
+    def find_missing_route(self, missing_path):  # pragma: no cover
+        self.load_projects()
+
+        apis = {
+            '/version': VersionAPI,
+            '/projects': ProjectAPI,
+        }
+
+        routes = []
+        for path in apis:
+            api = apis[path](self._state)
+            routes.extend(api.get_routes(path))
+        ick2.log.log('info', msg_texg='Found routes', routes=routes)
+        return routes
+
+
+class APIbase:  # pragma: no cover
+
+    def __init__(self, state):
+        self._state = state
+
+    def get_routes(self, path):
         return [
             {
-                'method': 'GET',
-                'path': '/version',
-                'callback': self.GET(self.get_version),
-            },
-            {
                 'method': 'POST',
-                'path': '/projects',
-                'callback': self.POST(self.post_projects),
+                'path': path,
+                'callback': self.POST(self.create),
             },
             {
                 'method': 'GET',
-                'path': '/projects',
-                'callback': self.GET(self.get_projects),
+                'path': path,
+                'callback': self.GET(self.list),
             },
             {
                 'method': 'GET',
-                'path': '/projects/<project>',
-                'callback': self.GET(self.get_project),
+                'path': '{}/<name>'.format(path),
+                'callback': self.GET(self.show),
             },
             {
                 'method': 'PUT',
-                'path': '/projects/<project>',
-                'callback': self.PUT(self.put_projects),
+                'path': '{}/<name>'.format(path),
+                'callback': self.PUT(self.update),
             },
             {
                 'method': 'DELETE',
-                'path': '/projects/<project>',
-                'callback': self.DELETE(self.delete_projects),
+                'path': '{}/<name>'.format(path),
+                'callback': self.DELETE(self.delete),
             },
         ]
 
-    def GET(self, callback):  # pragma: no cover
+    def GET(self, callback):
         def wrapper(content_type, body, **kwargs):
+            ick2.log.log(
+                'xxx', msg_text='GET called', kwargs=kwargs,
+                content_type=content_type, body=body)
             try:
                 if 'raw_uri_path' in kwargs:
                     del kwargs['raw_uri_path']
-                body = callback(**kwargs)
+                    body = callback(**kwargs)
+                    ick2.log.log(
+                        'xxx', msg_text='GET callback returned', body=body)
             except ick2.NotFound as e:
                 return not_found(e)
             return OK(body)
         return wrapper
 
-    def POST(self, callback):  # pragma: no cover
+    def POST(self, callback):
         def wrapper(content_type, body, **kwargs):
             body = callback(body)
             ick2.log.log('trace', msg_text='returned body', body=repr(body))
             return created(body)
         return wrapper
 
-    def PUT(self, callback):  # pragma: no cover
+    def PUT(self, callback):
         def wrapper(content_type, body, **kwargs):
             if 'raw_uri_path' in kwargs:
                 del kwargs['raw_uri_path']
@@ -94,7 +115,7 @@ class ControllerAPI:
             return OK(body)
         return wrapper
 
-    def DELETE(self, callback):  # pragma: no cover
+    def DELETE(self, callback):
         def wrapper(content_type, body, **kwargs):
             try:
                 if 'raw_uri_path' in kwargs:
@@ -105,27 +126,74 @@ class ControllerAPI:
             return OK(body)
         return wrapper
 
+    def create(self, body):
+        raise NotImplementedError()
+
+    def update(self, body, name):
+        raise NotImplementedError()
+
+    def delete(self, name):
+        raise NotImplementedError()
+
+    def list(self):
+        raise NotImplementedError()
+
+    def show(self, name):
+        raise NotImplementedError()
+
+
+class VersionAPI(APIbase):
+
+    def __init__(self, state):
+        super().__init__(state)
+
+    def get_routes(self, path):  # pragma: no cover
+        return [
+            {
+                'method': 'GET',
+                'path': path,
+                'callback': self.GET(self.get_version),
+            }
+        ]
+
     def get_version(self):
         return {'version': ick2.__version__}
 
-    def get_projects(self):
+    def create(self, *args):  # pragma: no cover
+        pass
+
+    def update(self, *args):  # pragma: no cover
+        pass
+
+    def delete(self, *args):  # pragma: no cover
+        pass
+
+    def list(self):  # pragma: no cover
+        pass
+
+    def show(self, *args):  # pragma: no cover
+        pass
+
+
+class ProjectAPI(APIbase):
+
+    def list(self):
         return {
             'projects': self._state.get_projects(),
         }
 
-    def get_project(self, project=None):
-        assert project is not None
-        return self._state.get_project(project)
+    def show(self, name):
+        ick2.log.log('xxxxxxx')
+        return self._state.get_project(name)
 
-    def post_projects(self, project):
-        return self._state.add_project(project)
+    def create(self, body):
+        return self._state.add_project(body)
 
-    def put_projects(self, body, project=None):
-        assert project is not None
-        return self._state.update_project(project, body)
+    def update(self, body, name):
+        return self._state.update_project(name, body)
 
-    def delete_projects(self, project):
-        self._state.remove_project(project)
+    def delete(self, name):
+        self._state.remove_project(name)
 
 
 def response(status_code, body, headers):  # pragma: no cover