Add HALE support

Author: smizell

hypermedia_resource/__init__.py

@@ -1,5 +1,5 @@
 __title__ = 'hypermedia_resource'
-__version__ = '0.1.10'
+__version__ = '0.1.11'
 __author__ = 'Stephen Mizell'
 __license__ = 'MIT'
 

hypermedia_resource/adapters/hale_json.py

@@ -0,0 +1,69 @@
+import json
+from hypermedia_resource.base import HypermediaResource
+
+RESERVED_ATTRIBUTES = ["_links", "_embedded"]
+
+def parse_attributes(hal_rep, resource):
+    attrs = [[key, value] for key, value in hal_rep.items()
+                if key not in RESERVED_ATTRIBUTES]
+    for attr in attrs:
+        resource.attributes.add(attr[0], attr[1])
+
+def parse_link(rel, link, resource):
+    if "templated" in link and link["templated"]:
+        return
+    if (link.has_key("method") and link["method"] != "GET"):
+        resource = resource.actions.add(rel, link["href"], link["method"])
+    else:
+        resource = resource.links.add(rel=rel, href=link["href"])
+    if link.has_key("request_encoding"):
+        resource.response_types.add(link["request_encoding"])
+    if link.has_key("data"):
+        # Right now, it only supports name and values
+        for name, value in link["data"].items():
+            attr = resource.attributes.add(name)
+            if value.has_key("options"):
+                for option in value["options"]:
+                    attr.options.add(option, option)
+    return resource
+
+def parse_links(hal_rep, resource):
+    if not "_links" in hal_rep or not hal_rep["_links"]:
+        return
+    for rel, link in hal_rep["_links"].items():
+        if type(link) is dict:
+            parse_link(rel, link, resource)
+        else:
+            for item in link:
+                parse_link(rel, item, resource)
+
+def parse_embedded(rel, embedded, resource):
+    href = embedded["_links"]["self"]
+    item = resource.embedded_resources.add(rel, href)
+    parse_attributes(embedded, item)
+    parse_links(embedded, item)
+    parse_embeddeds(embedded, item)
+    return item
+
+def parse_embeddeds(hal_rep, resource):
+    if not "_embedded" in hal_rep or not hal_rep["_embedded"]:
+        return
+    for rel, link in hal_rep["_embedded"].items():
+        if type(link) is dict:
+            parse_embedded(rel, link, resource)
+        else:
+            for item in link:
+                parse_embedded(rel, item, resource)
+
+class HaleJSONAdapter(object):
+
+    media_type = "application/vnd.hale+json"
+
+    @classmethod
+    def parse(self, raw_json):
+        hal_rep = json.loads(raw_json)
+        resource = HypermediaResource()
+        parse_attributes(hal_rep, resource)
+        parse_links(hal_rep, resource)
+        parse_embeddeds(hal_rep, resource)
+        return resource

hypermedia_resource/base.py

@@ -55,9 +55,8 @@ class BaseTransitionItem(object):
     def __init__(self, rel, method='GET', **kwargs):
         self.rel = rel
         self.method = method
-        self.hreflang = kwargs.get('embed_as', None)
+        self.hreflang = kwargs.get('hreflang', None)
         self.embed_as = kwargs.get('embed_as', None)
-        self.language = kwargs.get('language', None)
         self.response_types = MediaTypeCollection()
         self.label = kwargs.get('label', None)
 

hypermedia_resource/media_types.py

@@ -3,6 +3,7 @@
 class MediaTypeCollection(ItemCollection):
 
     def __init__(self):
+        super(MediaTypeCollection, self).__init__()
         self.item = MediaTypeItem
 
 class MediaTypeItem(object):

hypermedia_resource/wrappers.py

@@ -58,6 +58,10 @@ def build_response(self, resource, accepts):
 
 class FlaskAPIResource(APIResource):
 
+    def flask_response(self, resource, request, *args, **kwargs):
+        response = self.build_response(resource, request.headers.get('Accept'))
+        return Response(response.body, mimetype=response.media_type, *args, **kwargs)
+
     def get_method(self, request):
         if request.method != "POST":
             return request.method
@@ -70,6 +74,4 @@ def response_for(self, request):
         method = self.get_method(request)
         action_name = self.actions()[method]
         action = getattr(self, action_name)
-        resource = action(request)
-        response = self.build_response(resource, request.headers.get('Accept'))
-        return Response(response.body, mimetype=response.media_type)
+        return action(request)

tests/adapters/hale_json_test.py

@@ -0,0 +1,146 @@
+import sys
+import unittest
+import json
+import logging
+
+from hypermedia_resource import HypermediaResource
+from hypermedia_resource.adapters.hale_json import HaleJSONAdapter
+
+hale_example = """{
+    "_meta": {
+        "any": {
+            "json": "object"
+        }
+    },
+    "attribute": "value",
+    "_links": {
+        "self": {
+            "href": "..."
+        },
+        "search": {
+            "href": ".../{?send_info}",
+            "templated": true,
+            "method": "GET",
+            "data": {
+                "send_info": {
+                    "options": [
+                        "yes",
+                        "no",
+                        "maybe"
+                    ],
+                    "in": true
+                }
+            }
+        },
+        "agent": {
+            "href": "/agent/1",
+            "method": "GET",
+            "render": "embed"
+        },
+        "customer": [
+            {
+                "href": "/customer/1",
+                "method": "GET"
+            }
+        ],
+        "edit-customer": {
+            "href": ".../1",
+            "method": "PUT",
+            "request_encoding": "application/json",
+            "data": {
+                "name": {
+                    "type": "string",
+                    "required": true
+                },
+                "send_info": {
+                    "options": [
+                        "yes",
+                        "no",
+                        "maybe"
+                    ],
+                    "in": true
+                },
+                "user_id": {
+                    "scope": "href",
+                    "required": true
+                }
+            }
+        }
+    },
+    "_embedded": {
+        "customer": [
+            {
+                "_links": {
+                    "self": {
+                        "href": "/customer/1",
+                        "method": "GET"
+                    },
+                    "edit": {
+                        "href": ".../{?user_id}",
+                        "method": "PUT",
+                        "request_encoding": "application/json",
+                        "render": "resource",
+                        "data": {
+                            "name": {
+                                "type": "string",
+                                "required": true
+                            },
+                            "send_info": {
+                                "options": [
+                                    "yes",
+                                    "no",
+                                    "maybe"
+                                ],
+                                "in": true
+                            },
+                            "user_id": {
+                                "scope": "href",
+                                "required": true
+                            }
+                        }
+                    }
+                },
+                "name": "Tom",
+                "send_info": "yes"
+            }
+        ]
+    }
+}"""
+
+class TestParse(unittest.TestCase):
+
+    def setUp(self):
+        HypermediaResource.adapters.add(HaleJSONAdapter)
+        self.resource = HypermediaResource.adapters.translate_from("application/vnd.hale+json",
+                                                                   hale_example)
+
+    def tearDown(self):
+        HypermediaResource.reset_adapters()
+
+    def test_attributes(self):
+        attr = self.resource.attributes.get("attribute")
+        self.assertEqual(attr.value, "value")
+
+    def test_links(self):
+        self_links = self.resource.links.filter_by_rel("self")
+        self.assertEqual(len(self_links), 1)
+        self_link = self.resource.links.get("self")
+        self.assertEqual(self_link.href, "...")
+        self.assertEqual(len(self.resource.links.all()), 3)
+
+    def test_actions(self):
+        edit_customer = self.resource.actions.get("edit-customer")
+        self.assertEqual(edit_customer.method, "PUT")
+        request_type = edit_customer.response_types.filter_by("media_type", "application/json")
+        self.assertEqual(len(request_type), 1)
+        self.assertEqual(len(edit_customer.attributes.all()), 3)
+        send_info = edit_customer.attributes.filter_by("name", "send_info")[0]
+        self.assertEqual(len(send_info.options.all()), 3)
+
+    def test_embedded(self):
+        logging.basicConfig( stream=sys.stderr )
+        log = logging.getLogger("TestParse.test_embedded")
+        customer = self.resource.embedded_resources.get("customer")
+        log.debug(customer.attributes.all())
+        self.assertEqual(customer.attributes.get("name").value, "Tom")
+

tests/wrappers_test.py

@@ -11,10 +11,10 @@ def adapter():
     adapter.build.return_value = "built"
     return adapter
 
-def request(method='GET', data={}):
+def request(method='GET', form={}):
     request = Mock()
     request.method = method
-    request.data = data
+    request.form = form
     request.headers = Mock()
     request.headers.get = Mock()
     request.headers.get.return_value = "application/hal+json"
@@ -96,7 +96,7 @@ def test_response_for(self, mock_method):
         self.resource.build_response = Mock()
         self.resource.build_response.return_value = response
 
-        self.resource.response_for(request())
+        self.resource.response_for(request('GET', {}))
         self.resource.build_response.assert_called_with(resource, "application/hal+json")
         mock_method.assert_called_with(response.body, mimetype=response.media_type)