yaks 0.3.1 → 0.4.0.rc1

data/spec/support/youtypeit_models_mappers.rb

@@ -0,0 +1,20 @@
+module Youtypeitwepostit
+  class Message
+    include Virtus.model
+
+    attribute :id, Integer
+    attribute :text, String
+    attribute :date_posted, String
+  end
+
+  class MessageMapper < Yaks::Mapper
+    link :self, 'http://www.youtypeitwepostit.com/api/{id}'
+    link :profile, 'http://www.youtypeitwepostit.com/profiles/message'
+
+    attributes :text, :date_posted
+  end
+
+  class CollectionMapper < Yaks::CollectionMapper
+    link :self, 'http://www.youtypeitwepostit.com/api/'
+  end
+end

data/spec/unit/yaks/collection_mapper_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+RSpec.describe Yaks::CollectionMapper do
+  include_context 'fixtures'
+
+  subject(:mapper) { described_class.new(collection, context) }
+  let(:context) {
+    { resource_mapper: resource_mapper,
+      policy: policy,
+      env: {}
+    }
+  }
+  let(:collection) { [] }
+  let(:resource_mapper) { Class.new(Yaks::Mapper) { type 'the_type' } }
+  let(:policy) { Yaks::DefaultPolicy.new }
+
+  its(:to_resource) {
+    should eql Yaks::CollectionResource.new(
+        type: 'the_type',
+        links: [],
+        attributes: {},
+        members: []
+    )
+  }
+
+  context 'with members' do
+    let(:collection) { [boingboing, wassup]}
+    let(:resource_mapper) { PetMapper }
+
+    its(:to_resource) {
+      should eql Yaks::CollectionResource.new(
+        type: 'pet',
+        links: [],
+        attributes: {},
+        members: [
+          Yaks::Resource.new(type: 'pet', attributes: {:id => 2, :species => "dog", :name => "boingboing"}),
+          Yaks::Resource.new(type: 'pet', attributes: {:id => 3, :species => "cat", :name => "wassup"})
+        ]
+      )
+    }
+  end
+
+  context 'with collection attributes' do
+    subject(:mapper) {
+      Class.new(Yaks::CollectionMapper) do
+        attributes :foo, :bar
+      end.new(collection, context)
+    }
+
+    let(:collection) {
+      Class.new(SimpleDelegator) do
+        def foo ; 123 ; end
+        def bar ; 'pi la~~~' ; end
+      end.new([])
+    }
+
+    its(:to_resource) {
+      should eql Yaks::CollectionResource.new(
+        type: 'the_type',
+        links: [],
+        attributes: { foo: 123, bar: 'pi la~~~' },
+        members: []
+      )
+    }
+  end
+
+  context 'with collection links' do
+    subject(:mapper) {
+      Class.new(Yaks::CollectionMapper) do
+        link :self, 'http://api.example.com/orders'
+      end.new(collection, context)
+    }
+
+    its(:to_resource) {
+      should eql Yaks::CollectionResource.new(
+        type: 'the_type',
+        links: [ Yaks::Resource::Link.new(:self, 'http://api.example.com/orders', {}) ],
+        attributes: { },
+        members: []
+      )
+    }
+  end
+
+end

data/spec/unit/yaks/collection_resource_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+RSpec.describe Yaks::CollectionResource do
+  subject(:collection) { described_class.new(init_opts) }
+  let(:init_opts) { {} }
+
+  its(:collection?) { should equal true }
+
+  context 'with nothing passed in the contstructor' do
+    its(:type)         { should be_nil  }
+    its(:links)        { should eql []  }
+    its(:attributes)   { should eql({}) }
+    its(:members)      { should eql []  }
+    its(:subresources) { should eql({}) }
+  end
+
+  context 'with a full constructor' do
+    let(:init_opts) {
+      {
+        type: 'order',
+        links: [
+          Yaks::Resource::Link.new('http://rels/summary', 'http://order/10/summary', {}),
+          Yaks::Resource::Link.new(:profile, 'http://rels/collection', {})
+        ],
+        attributes: { total: 10.00 },
+        members: [
+          Yaks::Resource.new(
+            type: 'order',
+            links: [Yaks::Resource::Link.new(:self, 'http://order/10', {})],
+            attributes: { customer: 'John Doe', price: 10.00 }
+          )
+        ]
+      }
+    }
+
+    its(:type)       { should eql 'order' }
+    its(:links)      { should eql [
+        Yaks::Resource::Link.new('http://rels/summary', 'http://order/10/summary', {}),
+        Yaks::Resource::Link.new(:profile, 'http://rels/collection', {})
+      ]
+    }
+    its(:attributes) { should eql( total: 10.00 ) }
+    its(:members)    { should eql [
+        Yaks::Resource.new(
+          type: 'order',
+          links: [Yaks::Resource::Link.new(:self, 'http://order/10', {})],
+          attributes: { customer: 'John Doe', price: 10.00 }
+        )
+      ]
+    }
+
+    its(:subresources) { should eql(
+        'http://rels/collection' => Yaks::CollectionResource.new(
+          type: 'order',
+          attributes: { total: 10.00 },
+          links: [
+            Yaks::Resource::Link.new('http://rels/summary', 'http://order/10/summary', {}),
+            Yaks::Resource::Link.new(:profile, 'http://rels/collection', {})
+          ],
+          members: [
+            Yaks::Resource.new(
+              type: 'order',
+              links: [Yaks::Resource::Link.new(:self, 'http://order/10', {})],
+              attributes: { customer: 'John Doe', price: 10.00 }
+            )
+          ]
+        )
+      )
+    }
+
+  end
+end

data/spec/unit/yaks/config_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+
+RSpec.describe Yaks::Config do
+  include_context 'fixtures'
+
+  def self.configure(&blk)
+    subject(:config) { described_class.new(&blk) }
+  end
+
+  context 'defaults' do
+    configure {}
+
+    its(:default_format) { should equal :hal }
+    its(:policy_class)   { should < Yaks::DefaultPolicy }
+
+    it 'should have empty format options' do
+      expect(config.options_for_format(:hal)).to eql({})
+    end
+  end
+
+  context 'with a default format' do
+    configure do
+      default_format :json_api
+    end
+
+    its(:default_format) { should equal :json_api }
+  end
+
+  context 'with a custom policy class' do
+    MyPolicy = Struct.new(:options)
+    configure do
+      policy MyPolicy
+    end
+
+    its(:policy_class) { should equal MyPolicy }
+    its(:policy)       { should be_a  MyPolicy }
+  end
+
+  context 'with a rel template' do
+    configure do
+      rel_template 'http://rel/foo'
+    end
+
+    its(:policy_options) { should eql(rel_template: 'http://rel/foo') }
+  end
+
+  context 'with format options' do
+    configure do
+      format_options :hal, plural_links: [:self, :profile]
+    end
+
+    specify do
+      expect(config.options_for_format(:hal)).to eql(plural_links: [:self, :profile])
+    end
+  end
+
+  describe '#serialize' do
+    configure do
+      rel_template 'http://api.mysuperfriends.com/{association_name}'
+      format_options :hal, plural_links: [:copyright]
+    end
+
+    specify do
+      expect(config.serialize(john)).to eql(load_json_fixture 'john.hal')
+    end
+  end
+
+  describe '#mapper_namespace' do
+    module MyMappers
+      class PetMapper < Yaks::Mapper
+      end
+    end
+
+    configure do
+      mapper_namespace MyMappers
+    end
+
+    specify do
+      expect(config.policy.derive_mapper_from_object(boingboing)).to eql(MyMappers::PetMapper)
+    end
+  end
+
+  describe '#map_to_primitive' do
+    class TheMapper < Yaks::Mapper
+      attributes :a_date
+    end
+
+    TheModel = Struct.new(:a_date)
+
+    configure do
+      map_to_primitive Date do |object|
+        object.iso8601
+      end
+    end
+
+    let(:model) {
+      TheModel.new(Date.new(2014, 5, 6))
+    }
+
+    specify do
+      expect(config.serialize(model, mapper: TheMapper)).to eq({"a_date"=>"2014-05-06"})
+    end
+  end
+
+  context 'passing in a rack env' do
+    configure do
+      default_format :collection_json
+    end
+
+    let(:rack_env) {
+      { 'HTTP_ACCEPT' => 'application/hal+json;q=0.8, application/vnd.api+json' }
+    }
+
+    it 'should detect serializer based on accept header' do
+      rack_env = { 'HTTP_ACCEPT' => 'application/hal+json;q=0.8, application/vnd.api+json' }
+      expect(config.serializer_class({}, rack_env)).to equal Yaks::Serializer::JsonApi
+    end
+
+    it 'should know to pick the best match' do
+      rack_env = { 'HTTP_ACCEPT' => 'application/hal+json;q=0.8, application/vnd.api+json;q=0.7' }
+      expect(config.serializer_class({}, rack_env)).to equal Yaks::Serializer::Hal
+    end
+
+    it 'should fall back to the default when no mime type is recognized' do
+      rack_env = { 'HTTP_ACCEPT' => 'text/html, application/json' }
+      expect(config.serializer_class({}, rack_env)).to equal Yaks::Serializer::CollectionJson
+    end
+  end
+end

data/spec/unit/yaks/fp_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+RSpec.describe Yaks::FP do
+  include described_class
+
+  describe '#curry_method' do
+    def method_3args(a,b,c)
+      "#{a}-#{b}-#{c}"
+    end
+
+    it 'should curry the method' do
+      expect(curry_method(:method_3args).(1).(2,3)).to eql "1-2-3"
+    end
+  end
+
+  describe '#send_with_args' do
+    it 'should bind the arguments' do
+      expect(send_with_args(:+, 'foo').('bar')).to eql 'barfoo'
+    end
+
+    it 'should bind the block' do
+      expect(send_with_args(:map) {|x| x.upcase }.(['bar'])).to eql ['BAR']
+    end
+  end
+
+  describe '#identity_function' do
+    it 'should return whatever you pass it' do
+      expect(identity_function.(:foo)).to equal :foo
+    end
+  end
+end

data/spec/unit/yaks/mapper/association_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+RSpec.describe Yaks::Mapper::Association do
+  include Yaks::FP
+
+  let(:name)              { :shoes       }
+  let(:mapper)            { Yaks::Mapper }
+  let(:rel)               { Yaks::Undefined }
+  let(:collection_mapper) { Yaks::Undefined }
+  let(:parent_mapper)     { Yaks::Undefined }
+  let(:map_resource)      { ->(obj, policy) {} }
+  let(:lookup)            { ->(*) {} }
+  let(:policy)            { Yaks::DefaultPolicy.new }
+  let(:context)           { { policy: policy, env: {} } }
+
+  its(:name) { should equal :shoes }
+
+  subject(:association) do
+    described_class.new(name, mapper, rel, collection_mapper)
+  end
+
+  describe '#create_subresource' do
+    subject(:resource_pair) do
+      association.create_subresource(parent_mapper, lookup, context)
+    end
+
+    context 'with a rel specified' do
+      let(:rel) { 'http://api.com/rels/shoes' }
+
+      it 'should use the specified rel' do
+        expect(resource_pair[0]).to eql 'http://api.com/rels/shoes'
+      end
+    end
+
+    context 'without a rel specified' do
+      it 'should infer a rel based on policy' do
+        expect(policy)
+          .to receive(:derive_rel_from_association)
+          .with(parent_mapper, association)
+          .and_return('http://api.com/rel/derived')
+
+        expect(resource_pair[0]).to eql 'http://api.com/rel/derived'
+      end
+    end
+
+    let(:lookup) { { shoes: 'unmapped resource' } }
+
+    it 'should delegate to the map_resource method, to be overridden in child classes' do
+      expect(association)
+        .to receive(:map_resource)
+        .with('unmapped resource', context)
+        .and_return('mapped resource')
+
+      expect(resource_pair[1]).to eql 'mapped resource'
+    end
+  end
+
+  describe '#association_mapper' do
+    context 'with a specified mapper' do
+      let(:mapper) { :a_specific_mapper_class }
+
+      it 'should return the mapper' do
+        expect(association.association_mapper(nil)).to equal :a_specific_mapper_class
+      end
+    end
+
+    context 'with the mapper undefined' do
+      let(:mapper) { Yaks::Undefined }
+
+      it 'should derive a mapper based on policy' do
+        expect(policy)
+          .to receive(:derive_mapper_from_association)
+          .with(association)
+          .and_return(:a_derived_mapper_class)
+
+        expect(association.association_mapper(policy)).to equal :a_derived_mapper_class
+      end
+    end
+  end
+end

data/spec/{yaks → unit/yaks}/mapper/class_methods_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Yaks::Mapper::ClassMethods do
+RSpec.describe Yaks::Mapper::ClassMethods do
   subject { Class.new { extend Yaks::Mapper::ClassMethods } }
 
   describe 'attributes' do
@@ -9,7 +9,7 @@ describe Yaks::Mapper::ClassMethods do
     end
 
     it 'should allow setting them' do
-      expect( subject.attributes ).to eq Hamster.list(:foo, :bar)
+      expect( subject.attributes ).to eq [:foo, :bar]
     end
 
     describe 'with inheritance' do
@@ -17,11 +17,11 @@ describe Yaks::Mapper::ClassMethods do
       before { child.attributes(:baz) }
 
       it 'should inherit attributes from the parent' do
-        expect(child.attributes).to eq Hamster.list(:foo, :bar, :baz)
+        expect(child.attributes).to eq [:foo, :bar, :baz]
       end
 
       it 'should not alter the parent' do
-        expect(subject.attributes).to eq Hamster.list(:foo, :bar)
+        expect(subject.attributes).to eq [:foo, :bar]
       end
     end
   end

data/spec/unit/yaks/mapper/config_spec.rb

@@ -0,0 +1,191 @@
+require 'spec_helper'
+
+RSpec.describe Yaks::Mapper::Config do
+  Undefined = Yaks::Undefined
+
+  subject(:config) { described_class.new(nil, [], [], []) }
+
+  describe '#initialize' do
+    subject(:config) { described_class.new('foo', [:a], [:b], [:c]) }
+
+    its(:type)         { should eql 'foo' }
+    its(:attributes)   { should eql [:a] }
+    its(:links)        { should eql [:b] }
+    its(:associations) { should eql [:c] }
+  end
+
+  describe '#updated' do
+    context 'with no updates' do
+      let(:config) {
+        super()
+          .type('foo')
+          .attributes(:a, :b, :c)
+          .link(:foo, 'http://bar')
+          .has_many(:bars)
+      }
+
+      it 'should update attributes' do
+        expect(config.updated(attributes: [:foo])).to eql described_class.new(
+          'foo',
+          [:foo],
+          [Yaks::Mapper::Link.new(:foo, 'http://bar', {})],
+          [Yaks::Mapper::HasMany.new(:bars, Undefined, Undefined, Undefined)]
+        )
+      end
+
+      it 'should update links' do
+        expect(config.updated(links: [:foo])).to eql described_class.new(
+          'foo',
+          [:a, :b, :c],
+          [:foo],
+          [Yaks::Mapper::HasMany.new(:bars, Undefined, Undefined, Undefined)]
+        )
+      end
+
+      it 'should update associations' do
+        expect(config.updated(associations: [:foo])).to eql described_class.new(
+          'foo',
+          [:a, :b, :c],
+          [Yaks::Mapper::Link.new(:foo, 'http://bar', {})],
+          [:foo]
+        )
+      end
+    end
+  end
+
+  describe '#attributes' do
+    context 'an empty config' do
+      it 'should return an empty attributes list' do
+        expect(config.attributes).to eq []
+      end
+    end
+
+    it 'should add attributes' do
+      expect(config.attributes(:foo, :bar, :baz).attributes)
+        .to eq [:foo, :bar, :baz]
+    end
+
+    it 'should be chainable' do
+      expect(
+        config
+          .attributes(:foo, :bar)
+          .attributes(:baz)
+          .attributes
+      ).to eq [:foo, :bar, :baz]
+    end
+  end
+
+  describe '#links' do
+    context 'an empty config' do
+      it 'should have an empty link list' do
+        expect(config.links).to eq []
+      end
+    end
+
+    describe 'adding links' do
+      let(:config) {
+        subject
+          .link(:self, '/foo/bar/{id}')
+          .link(:profile, '/profile/foo')
+      }
+
+      it 'should have the links in the link list' do
+        expect(config.links).to include Yaks::Mapper::Link.new(:profile, '/profile/foo', {})
+        expect(config.links).to include Yaks::Mapper::Link.new(:self, '/foo/bar/{id}', {})
+      end
+    end
+
+    describe 'links with the same rel' do
+      let(:config) {
+        subject
+          .link(:self, '/foo/self')
+          .link(:self, '/foo/me')
+      }
+
+      it 'should have the links in the defined order' do
+        expect(config.links).to eql [
+          Yaks::Mapper::Link.new(:self, '/foo/self', {}),
+          Yaks::Mapper::Link.new(:self, '/foo/me', {})
+        ]
+      end
+    end
+  end
+
+  describe '#has_one' do
+    context 'with a mapper specified' do
+      let(:config) { subject.has_one :mother, mapper: Yaks::Mapper }
+
+      it 'should have the association configured' do
+        expect(config.associations).to eq [
+          Yaks::Mapper::HasOne.new(:mother, Yaks::Mapper, Undefined, Undefined)
+        ]
+      end
+    end
+
+    context 'with no options' do
+      let(:config) { subject.has_one :mother }
+
+      it 'should have undefined mapper, rel, collection_mapper' do
+        expect(config.associations).to eq [
+          Yaks::Mapper::HasOne.new(:mother, Undefined, Undefined, Undefined)
+        ]
+      end
+    end
+
+    context 'with a rel specified' do
+      let(:config) { subject.has_one :mother, rel: '/api/rels/mother' }
+
+      it 'should have the rel' do
+        expect(config.associations).to eq [
+          Yaks::Mapper::HasOne.new(:mother, Undefined, '/api/rels/mother', Undefined)
+        ]
+      end
+
+    end
+  end
+
+  describe '#has_many' do
+    context 'with a mapper specified' do
+      let(:config) { subject.has_many :shoes, mapper: Yaks::Mapper }
+
+      it 'should have the association configured' do
+        expect(config.associations).to eq [
+          Yaks::Mapper::HasMany.new(:shoes, Yaks::Mapper, Undefined, Undefined)
+        ]
+      end
+    end
+
+    context 'with no options' do
+      let(:config) { subject.has_many :shoes }
+
+      it 'should have undefined mapper, rel, collection_mapper' do
+        expect(config.associations).to eq [
+          Yaks::Mapper::HasMany.new(:shoes, Undefined, Undefined, Undefined)
+        ]
+      end
+    end
+
+    context 'with a collection mapper set' do
+      let(:config) { subject.has_many :shoes, collection_mapper: :a_collection_mapper }
+
+      it 'should have the association configured' do
+        expect(config.associations).to eq [
+          Yaks::Mapper::HasMany.new(:shoes, Undefined, Undefined, :a_collection_mapper)
+        ]
+      end
+    end
+  end
+
+  context 'multiple associations' do
+    let(:config) {
+      subject
+        .has_many(:shoes)
+        .has_one(:mother)
+    }
+
+    it 'should have them all present' do
+      expect(config.associations).to include Yaks::Mapper::HasOne.new(:mother, Undefined, Undefined, Undefined)
+      expect(config.associations).to include Yaks::Mapper::HasMany.new(:shoes, Undefined, Undefined, Undefined)
+    end
+  end
+end

data/spec/unit/yaks/mapper/has_many_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+RSpec.describe Yaks::Mapper::HasMany do
+  let(:closet_mapper) do
+    Class.new(Yaks::Mapper) do
+      has_many :shoes,
+        rel: 'http://foo/shoes',
+        mapper: Class.new(Yaks::Mapper) { type 'shoes' ; attributes :size, :color }
+    end
+  end
+
+  let(:closet) {
+    double(
+      :shoes => [
+        double(size: 9,    color: :blue),
+        double(size: 11.5, color: :red),
+      ]
+    )
+  }
+
+  it 'should map the subresources' do
+    expect(closet_mapper.new(closet, policy: Yaks::DefaultPolicy.new, env: {}).map_subresources).to eql(
+      "http://foo/shoes" => Yaks::CollectionResource.new(
+        type: 'shoes',
+        members: [
+          Yaks::Resource.new(type: 'shoes', attributes: {:size => 9, :color => :blue}),
+          Yaks::Resource.new(type: 'shoes', attributes: {:size => 11.5, :color => :red})
+        ]
+      )
+    )
+  end
+
+  describe '#collection_mapper' do
+    let(:collection_mapper) { Yaks::Undefined }
+    subject(:has_many)  { described_class.new(:name, :mapper, :rel, collection_mapper) }
+
+    context 'when the collection mapper is undefined' do
+      its(:collection_mapper) { should equal Yaks::CollectionMapper }
+    end
+
+    context 'when the collection mapper is specified' do
+      let(:collection_mapper) { :foo }
+      its(:collection_mapper) { should equal :foo }
+    end
+  end
+end