halibut 0.1.0 → 0.2.0

data/lib/halibut/hal/link.rb

@@ -0,0 +1,81 @@
+module Halibut::HAL
+  # This class represents a HAL Link object.
+  #
+  # spec spec spec.
+  class Link
+    extend Forwardable
+
+    attr_reader :href
+
+    def_delegators :@options, :templated, :templated?, :type,
+                   :name, :profile, :title, :hreflang
+    # Returns an instance of a HAL Link object
+    #
+    # @param [String]  href      URI or URI Template
+    # @param [Boolean] templated true if URI Template or false otherwise
+    # @param [Hash]    opts      Options: type, name, profile, title, hreflang
+    #
+    # @return [Halibut::HAL::Link] HAL Link object
+    def initialize(href, opts={})
+      @href = href
+      @options = Options.new opts
+    end
+
+    # Returns the Link as a Hash
+    #
+    # @return [Hash] hash from Link Object
+    def to_hash
+      { 'href' => href }.merge @options
+    end
+
+    def ==(other)
+      @href == other.href && @options == other.options
+    end
+
+    protected
+    attr_reader :options
+
+    private
+    class Options
+      attr_reader :templated, :type, :name,
+                  :profile, :title, :hreflang
+
+      def initialize opts
+        @templated = opts[:templated] || opts['templated']
+        @type      = opts[:type]      || opts['type']
+        @name      = opts[:name]      || opts['name']
+        @profile   = opts[:profile]   || opts['profile']
+        @title     = opts[:title]     || opts['title']
+        @hreflang  = opts[:hreflang]  || opts['hreflang']
+      end
+
+      # Tells us if the href of the associated link is templated.
+      #
+      # The reason for not returning @templated directly is that all of the
+      # options are optional, thus nil could be returned instead of a boolean.
+      #
+      # @return [true, false] whether the href is a templated uri or not.
+      def templated?
+        @templated || false
+      end
+
+      def to_hash
+        instance_variables.each_with_object({}) do |name, output|
+          next if (ivar = instance_variable_get(name)).nil?
+
+          output[name[1..-1]] = ivar
+        end
+      end
+
+      def ==(other)
+        templated == other.templated &&
+        type      == other.type      &&
+        name      == other.name      &&
+        profile   == other.profile   &&
+        title     == other.title     &&
+        hreflang  == other.hreflang
+      end
+    end
+  end
+
+end

data/lib/halibut/hal/resource.rb

@@ -0,0 +1,74 @@
+module Halibut::HAL
+
+  # This class represents a HAL Resource object.
+  #
+  # spec spec spec
+  class Resource
+    attr_reader :properties, :links, :embedded
+
+    # TDK
+    #
+    # @param [String] href Link that will be added to the self relation.
+    def initialize(href=nil)
+      @links      = Halibut::RelationMap.new
+      @embedded   = Halibut::RelationMap.new
+      @properties = {}
+
+      add_link('self', href) if href
+    end
+
+    # TDK
+    #
+    # @param [Object] property the key
+    # @param [Object] value    the value
+    def set_property(property, value)
+      @properties[property] = value
+    end
+
+    # Returns the value of a property in the resource
+    #
+    # @param [String] property property
+    def get_property property
+      @properties[property]
+    end
+
+    # Adds link to relation
+    #
+    # @param [String]      relation  relation
+    # @param [String]      href      href
+    # @param [true, false] templated templated
+    # @param [Hash]        opts      options: name, type, hreflang
+    def add_link(relation, href, opts={})
+      @links.add relation, Link.new(href, opts)
+    end
+
+    # Embeds resource in relation
+    #
+    # @param [String]   relation relation
+    # @param [Resource] resource resource to embed
+    def embed_resource(relation, resource)
+      @embedded.add relation, resource
+    end
+
+    # Hash representation of the resource.
+    # Will ommit links and embedded keys if they're empty
+    #
+    # @return [Hash] hash representation of the resource
+    def to_hash
+      {}.merge(@properties).tap do |h|
+        h['_links']    = {}.merge @links    unless @links.empty?
+        h['_embedded'] = {}.merge @embedded unless @embedded.empty?
+      end
+    end
+
+    # Compares two resources.
+    #
+    # @param  [Halibut::HAL::Resource] other Resource to compare to
+    # @return [true, false]                  Result of the comparison
+    def ==(other)
+      @properties == other.properties &&
+      @links      == other.links      &&
+      @embedded   == other.embedded
+    end
+  end
+end

data/lib/halibut/link_relation.rb

@@ -0,0 +1,29 @@
+module Halibut
+
+  # Domain object that represents a Relation
+  #
+  # spec spec spec.
+  class LinkRelation
+    attr_accessor :name, :curie
+
+    def initialize(name)
+      splits = name.to_s.split(":")
+
+      splits.size < 2 ? @name = splits.first : (@curie, @name = splits)
+    end
+
+    def eql?(other)
+      hash == other.hash
+    end
+
+    def hash
+      instance_variables.hash
+    end
+
+    def to_s
+      @curie and "#{@curie}:#{@name}" or @name
+    end
+
+  end
+
+end

data/lib/halibut/relation_map.rb

@@ -1,39 +1,40 @@
 module Halibut
 
+  # This is an abstract map with behaviour specific to HAL.
+  #
+  # spec spec spec
   class RelationMap
-  
+    extend Forwardable
+
+    def_delegators :@relations, :[], :empty?, :==
+
     def initialize
       @relations = {}
     end
-    
+
+    # Adds an object to a relation.
+    #
+    # @param [String] relation relation that the object belongs to
+    # @param [Object] item     the object to add to the relation
     def add(relation, item)
-      @relations[relation] = [] unless @relations.has_key? relation
-      
-      @relations[relation] << item
-    end
-    
-    def [](relation)
-      @relations[relation]
-    end
-    
-    def empty?
-      @relations.empty?
+      @relations[relation] = @relations[relation].to_a << item
     end
-    
+
+    # Returns a hash corresponding to the object.
+    #
+    # RelationMap doens't just return @relations because it needs to convert
+    # correctly when a relation only has a single item.
+    #
+    # @return [Hash] relation map in hash format
     def to_hash
-      a = @relations.each_with_object({}) do |pair, obj|
+      @relations.each_with_object({}) do |pair, obj|
         key, *value = pair.flatten
-        
+
+        key = key.to_s
+
         obj[key] = value.map &:to_hash
         obj[key].length == 1 and obj[key] = obj[key].first
       end
-      
-    end
-    
-    def ==(other)
-      @relations == other.instance_variable_get(:@relations)
     end
-  
   end
-  
 end

data/lib/halibut/version.rb

@@ -1,4 +1,3 @@
 module Halibut
-  # Halibut.VERSION denotes the version of this library.
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/spec/adapter/json_spec.rb

@@ -0,0 +1,72 @@
+require_relative '../spec_helper'
+
+read_files = ->() {
+  Dir.tap {|it| it.chdir('spec/test-resources/src/main/resources') } \
+     .glob('*.json') \
+     .map {|f| File.read f }
+}
+
+describe Halibut::Adapter::JSON do
+
+  it "serializes to JSON" do
+    resource = Halibut::HAL::Resource.new("http://example.com")
+    subject  = Halibut::Adapter::JSON.dump resource
+    json     = load_json "simple"
+
+    MultiJson.load(subject).must_equal MultiJson.load(json)
+  end
+
+  it "deserializes from JSON" do
+    subject = Halibut::Adapter::JSON.load(load_json "serialize")
+
+    order = Halibut::HAL::Resource.new "/orders/123"
+    order.set_property "total", 30.00
+    order.set_property "currency", "USD"
+    order.set_property "status", "shipped"
+
+    resource = Halibut::HAL::Resource.new "/orders"
+    resource.add_link "find", "/orders{?id}", templated: true
+    resource.add_link "next", "/orders/1", "name" => 'hotdog'
+    resource.add_link "next", "/orders/9"
+    resource.set_property "currentlyProcessing", 14
+    resource.set_property "shippedToday", 20
+    resource.embed_resource "orders", order
+
+    subject.must_equal resource
+  end
+
+  it "provides to_json helper" do
+    json = Halibut::Adapter::JSON.load(load_json "serialize")
+    json = Halibut::Adapter::JSON.dump(json)
+
+    order = Halibut::HAL::Resource.new "/orders/123"
+    order.set_property "total", 30.00
+    order.set_property "currency", "USD"
+    order.set_property "status", "shipped"
+
+    resource = Halibut::HAL::Resource.new "/orders"
+    resource.add_link "find", "/orders{?id}", templated: true
+    resource.add_link "next", "/orders/1", "name" => 'hotdog'
+    resource.add_link "next", "/orders/9"
+    resource.set_property "currentlyProcessing", 14
+    resource.set_property "shippedToday", 20
+    resource.embed_resource "orders", order
+
+    resource.to_json.wont_equal json
+    resource.extend Halibut::Adapter::JSON
+    resource.to_json.must_equal json
+  end
+
+  it "tests against test-resources" do
+    files  = read_files[]
+
+    refilled  = files.map {|f| MultiJson.load f }
+    resources = files.map {|f| Halibut::Adapter::JSON.load f }.map &:to_hash
+
+    zipped = refilled.zip resources
+    zipped.each do |json, hal|
+      json.must_equal hal
+    end
+  end
+
+end

data/spec/adapter/xml_spec.rb

@@ -0,0 +1,50 @@
+require_relative '../spec_helper'
+
+
+read_files = ->() {
+  Dir.tap {|it| it.chdir('spec/test-resources/src/main/resources') } \
+     .glob('*.xml') \
+     .map {|f| File.read f }
+}
+
+
+describe Halibut::Adapter::XML do
+
+  it "serializes to XML" do
+    skip "To Be Implemented"
+  end
+
+  it "deserializes from XML" do
+    # skip "Test is failing god knows why."
+    builder = Halibut::Builder.new 'https://example.com/api/customer/123456' do
+      property 'age', "33"
+      property 'expired', "false"
+      property 'id', "123456"
+      property 'name', 'Example Resource'
+      property 'nullprop', ""
+      property 'optional', "true"
+
+      relation 'curie' do
+        link 'https://example.com/apidocs/accounts', name: 'ns'
+        link 'https://example.com/apidocs/roles',    name: 'role'
+      end
+      link 'ns:parent', 'https://example.com/api/customer/1234', name: 'bob',
+                                                                 title: 'The Parent',
+                                                                 hreflang: 'en'
+      link 'ns:users', 'https://example.com/api/customer/123456?users'
+    end.resource
+
+    xml = load_resource('exampleWithNullProperty.xml')
+
+    deserialized = Halibut::Adapter::XML.load(xml)
+    deserialized.must_equal builder, diff(deserialized.to_hash, builder.to_hash)
+  end
+
+  it "provides to_xml helper" do
+    skip "To Be Implemented"
+
+    xml = Halibut::Adapter::XML.load(load_resource 'exampleWithNullProperty.xml')
+    xml = Halibut::Adapter::XML.dump(xml)
+  end
+
+end

data/spec/builder_spec.rb

@@ -0,0 +1,185 @@
+require_relative 'spec_helper'
+
+
+require 'hash'
+
+describe Halibut::Builder do
+  describe "Empty resource" do
+    it "builds empty resource with no self link" do
+      builder  = Halibut::Builder.new
+      resource = Halibut::HAL::Resource.new
+
+      builder.resource.must_equal resource
+    end
+
+    it "builds empty resource with self link" do
+      builder  = Halibut::Builder.new 'default'
+      resource = Halibut::HAL::Resource.new 'default'
+
+      builder.resource.must_equal resource
+    end
+  end
+
+  describe "Properties" do
+    it "builds resource with a single property" do
+      builder = Halibut::Builder.new do
+        property 'foo', 'bar'
+      end
+
+      resource = Halibut::HAL::Resource.new
+      resource.set_property 'foo', 'bar'
+
+      builder.resource.properties['foo'].must_equal 'bar'
+      builder.resource.must_equal resource, diff(builder.resource.to_hash, resource.to_hash)
+    end
+
+    it "builds resource with several properties" do
+      builder = Halibut::Builder.new do
+        property 'foo', 'bar'
+        property 'baz', 'quux'
+        property 'medals', { gold: 1, silver: 5, bronze: 10 }
+      end
+
+      resource = Halibut::HAL::Resource.new
+      resource.set_property 'foo', 'bar'
+      resource.set_property 'baz', 'quux'
+      resource.set_property 'medals', { gold: 1, silver: 5, bronze: 10 }
+
+      builder.resource.properties['foo'].must_equal 'bar'
+      builder.resource.properties['baz'].must_equal 'quux'
+      builder.resource.properties['medals'].must_equal({ gold: 1, silver: 5, bronze: 10 })
+
+      builder.resource.must_equal resource, diff(builder.resource.to_hash, resource.to_hash)
+    end
+
+  end
+
+  describe "Links" do
+    it "builds resource with a single links per relation" do
+      builder = Halibut::Builder.new do
+        link 'cs:broms', '/broms/1'
+        link 'cs:search', '/search{?broms,noms}', templated: true
+      end
+
+      resource = Halibut::HAL::Resource.new
+      resource.add_link 'cs:broms', '/broms/1'
+      resource.add_link 'cs:search', '/search{?broms,noms}', templated: true
+
+      resource.must_equal builder.resource, diff(builder.resource.to_hash, resource.to_hash)
+    end
+
+    it "builds resource with multiple links per relation" do
+      builder = Halibut::Builder.new do
+        link 'cs:broms', '/broms/1'
+        link 'cs:broms', '/broms/2'
+        link 'cs:search', '/search{?broms,noms}', templated: true
+      end
+
+      resource = Halibut::HAL::Resource.new
+      resource.add_link 'cs:broms', '/broms/1'
+      resource.add_link 'cs:broms', '/broms/2'
+      resource.add_link 'cs:search', '/search{?broms,noms}', templated: true
+
+      resource.must_equal builder.resource, diff(builder.resource.to_hash, resource.to_hash)
+    end
+  end
+
+  describe "Embedded resources" do
+    it "builds resource with a single resource per relation" do
+      builder = Halibut::Builder.new do
+        resource 'games', '/game/1' do
+          property :name,    'Crash Bandicoot'
+          property :console, 'PlayStation'
+        end
+      end
+
+      game = Halibut::HAL::Resource.new '/game/1'
+      game.set_property(:name, 'Crash Bandicoot')
+      game.set_property(:console, 'PlayStation')
+
+      resource = Halibut::HAL::Resource.new
+      resource.embed_resource('games', game)
+
+      builder.resource.must_equal resource, diff(builder.resource.to_hash, resource.to_hash)
+    end
+
+    it "builds resource with multiple resourcer per relation" do
+      builder = Halibut::Builder.new do
+        resource 'games', '/game/1' do
+          property :name,    'Crash Bandicoot'
+          property :console, 'PlayStation'
+        end
+        resource 'games', '/game/2' do
+          property :name,    'Super Mario Land'
+          property :console, 'Game Boy'
+        end
+      end
+
+      game1 = Halibut::HAL::Resource.new '/game/1'
+      game1.set_property(:name, 'Crash Bandicoot')
+      game1.set_property(:console, 'PlayStation')
+
+      game2 = Halibut::HAL::Resource.new '/game/2'
+      game2.set_property(:name, 'Super Mario Land')
+      game2.set_property(:console, 'Game Boy')
+
+      resource = Halibut::HAL::Resource.new
+      resource.embed_resource('games', game1)
+      resource.embed_resource('games', game2)
+
+      builder.resource.must_equal resource, diff(builder.resource.to_hash, resource.to_hash)
+    end
+  end
+
+  describe "Relation helper" do
+    it "builds resource using relation DSL" do
+      builder = Halibut::Builder.new do
+        relation 'games' do
+          link '/games/1'
+          link '/games/2'
+          link '/games/3'
+        end
+        link 'next', '/games/next'
+        relation 'users' do
+          resource '/users/1' do
+            property :name, "foo"
+            property :nick, "bar"
+          end
+        end
+      end
+
+      user = Halibut::HAL::Resource.new '/users/1'
+      user.set_property :name, "foo"
+      user.set_property :nick, "bar"
+
+      resource = Halibut::HAL::Resource.new
+      resource.add_link 'games', '/games/1'
+      resource.add_link 'games', '/games/2'
+      resource.add_link 'games', '/games/3'
+      resource.add_link 'next', '/games/next'
+      resource.embed_resource 'users', user
+
+      builder.resource.must_equal resource, diff(builder.resource.to_hash, resource.to_hash)
+    end
+  end
+
+  describe "Namespace helper" do
+    let(:name) { 'cs' }
+    let(:href) { 'http://cs-api.herokuapp.com/rels/{rel}' }
+
+    it "builds resource using curie DSL" do
+      builder = Halibut::Builder.new do
+        namespace 'cs', 'http://cs-api.herokuapp.com/rels/{rel}'
+      end
+
+      builder = Halibut::Builder.new
+      builder.namespace 'cs', 'http://cs-api.herokuapp.com/rels/{rel}'
+
+      curie = builder.resource.links['curie'].first
+
+      curie.name.must_equal name
+      curie.href.must_equal href
+    end
+  end
+
+end