yaks 0.9.0 → 0.10.0

data/spec/support/pet_mapper.rb

@@ -1,3 +1,5 @@
 class PetMapper < Yaks::Mapper
   attributes :id, :name, :species
 end
+class GreatPetMapper < Yaks::Mapper; end
+class GreatPetCollectionMapper < Yaks::Mapper; end

data/spec/support/shared_contexts.rb

@@ -14,7 +14,7 @@ RSpec.shared_context 'yaks context' do
   let(:policy)            { Yaks::DefaultPolicy.new }
   let(:rack_env)          { {} }
   let(:mapper_stack)      { [] }
-  let(:yaks_context)      { { policy: policy, env: rack_env, mapper_stack: mapper_stack } }
+  let(:yaks_context)      { {policy: policy, env: rack_env, mapper_stack: mapper_stack} }
 end
 
 RSpec.shared_context 'plant collection resource' do
@@ -24,12 +24,12 @@ RSpec.shared_context 'plant collection resource' do
   let(:members) { [ plain_grass, oak, passiflora ] }
 
   [
-    [ :plant       , :profile , 'http://api.example.com/doc/plant'            ],
-    [ :plants      , :profile , 'http://api.example.com/doc/plant_collection' ],
-    [ :plants      , :self    , 'http://api.example.com/plants'               ],
-    [ :plain_grass , :self    , 'http://api.example.com/plants/7/plain_grass' ],
-    [ :oak         , :self    , 'http://api.example.com/plants/15/oak'        ],
-    [ :passiflora  , :self    , 'http://api.example.com/plants/33/passiflora' ],
+    [ :plant,        :profile,  'http://api.example.com/doc/plant'            ],
+    [ :plants,       :profile,  'http://api.example.com/doc/plant_collection' ],
+    [ :plants,       :self,     'http://api.example.com/plants'               ],
+    [ :plain_grass,  :self,     'http://api.example.com/plants/7/plain_grass' ],
+    [ :oak,          :self,     'http://api.example.com/plants/15/oak'        ],
+    [ :passiflora,   :self,     'http://api.example.com/plants/33/passiflora' ]
   ].each do |name, type, uri|
     let(:"#{name}_#{type}_link") { Yaks::Resource::Link.new(rel: type, uri: uri) }
   end
@@ -44,14 +44,14 @@ RSpec.shared_context 'plant collection resource' do
   let(:oak) do
     Yaks::Resource.new(
       attributes: {name: "Oak", type: "tree"},
-      links: [oak_self_link, plant_profile_link],
+      links: [oak_self_link, plant_profile_link]
     )
   end
 
   let(:passiflora) do
     Yaks::Resource.new(
       attributes: {name: "Passiflora", type: "flower"},
-      links: [passiflora_self_link, plant_profile_link],
+      links: [passiflora_self_link, plant_profile_link]
     )
   end
 end

data/spec/unit/yaks/builder_spec.rb

@@ -1,6 +1,6 @@
 RSpec.describe Yaks::Builder do
   class Buildable
-    include Yaks::Attributes.new(:foo, :bar)
+    include Attribs.new(:foo, :bar)
 
     def self.create(foo, bar)
       new(foo: foo, bar: bar)
@@ -18,30 +18,54 @@ RSpec.describe Yaks::Builder do
   subject do
     Yaks::Builder.new(Buildable, [:finalize]) do
       def_set :foo, :bar
-      def_forward :wrong_type, :update
+      def_forward :wrong_type, :with
     end
   end
 
-  it 'should keep state' do
-    expect(
-      subject.create(3, 4) do
-        foo 7
-        update bar: 6
-      end.to_h
-    ).to eql(foo: 7, bar: 6)
-  end
+  describe '#initialize' do
+    it 'should set the class to be instantiated' do
+      expect(subject.create(1, 2)).to be_instance_of Buildable
+    end
+
+    it 'should accept just a class' do
+      expect { Yaks::Builder.new(Buildable) }.to_not raise_error
+    end
+
+    it 'should define delegators for passed in method names' do
+      expect(subject).to respond_to(:finalize)
+    end
+
+    it 'should store the methods for inspection' do
+      expect(subject.inspect).to eql "#<Builder Buildable [:finalize]>"
+    end
 
-  it 'should unwrap again' do
-    expect( subject.create(3, 4) { finalize } ).to eql Buildable.new(foo: 7, bar: 8)
+    it 'should evaluate the passed in block' do
+      expect(subject).to respond_to(:foo)
+    end
   end
 
-  context 'with no methods to forward' do
-    subject do
-      Yaks::Builder.new(Buildable)
+  describe '#create' do
+    it 'should keep state' do
+      expect(
+        subject.create(3, 4) do
+          foo 7
+          with bar: 6
+        end.to_h
+      ).to eql(foo: 7, bar: 6)
     end
 
-    it 'should still work' do
-      expect(subject.create(3,4)).to eql Buildable.new(foo: 3, bar: 4)
+    it 'should unwrap again' do
+      expect(subject.create(3, 4) { finalize }).to eql Buildable.new(foo: 7, bar: 8)
+    end
+
+    context 'with no methods to forward' do
+      subject do
+        Yaks::Builder.new(Buildable)
+      end
+
+      it 'should still work' do
+        expect(subject.create(3, 4)).to eql Buildable.new(foo: 3, bar: 4)
+      end
     end
   end
 
@@ -66,5 +90,4 @@ RSpec.describe Yaks::Builder do
       expect(subject.inspect).to eql '#<Builder Buildable [:foo, :bar]>'
     end
   end
-
 end

data/spec/unit/yaks/collection_mapper_spec.rb

@@ -1,4 +1,4 @@
-RSpec.describe Yaks::CollectionMapper do
+RSpec.describe Yaks::CollectionMapper, '#call' do
   include_context 'fixtures'
 
   subject(:mapper) { mapper_class.new(context) }
@@ -6,10 +6,10 @@ RSpec.describe Yaks::CollectionMapper do
   let(:mapper_stack) { [] }
 
   let(:context) {
-    { item_mapper: item_mapper,
-      policy: policy,
-      env: {},
-      mapper_stack: mapper_stack }
+    {item_mapper: item_mapper,
+     policy: policy,
+     env: {},
+     mapper_stack: mapper_stack}
   }
 
   let(:collection) { [] }
@@ -32,7 +32,7 @@ RSpec.describe Yaks::CollectionMapper do
 
   context 'when at the top of the stack' do
     it 'should have a "collection" rel derived from the type' do
-      expect(mapper.call(collection).rels).to eql  ['rel:the_types']
+      expect(mapper.call(collection).rels).to eql ['rel:the_types']
     end
   end
 
@@ -58,8 +58,8 @@ RSpec.describe Yaks::CollectionMapper do
         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"})
+          Yaks::Resource.new(type: 'pet', attributes: {id: 2, species: "dog", name: "boingboing"}),
+          Yaks::Resource.new(type: 'pet', attributes: {id: 3, species: "cat", name: "wassup"})
         ],
         rels: ['rel:pets']
       )
@@ -82,8 +82,8 @@ RSpec.describe Yaks::CollectionMapper do
         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"})
+          Yaks::Resource.new(type: 'pet', attributes: {id: 2, species: "dog", name: "boingboing"}),
+          Yaks::Resource.new(type: 'pet', attributes: {id: 3, species: "cat", name: "wassup"})
         ],
         rels: ['rel:pets']
       )
@@ -99,8 +99,13 @@ RSpec.describe Yaks::CollectionMapper do
 
     let(:collection) {
       Class.new(SimpleDelegator) do
-        def foo ; 123 ; end
-        def bar ; 'pi la~~~' ; end
+        def foo
+          123
+        end
+
+        def bar
+          'pi la~~~'
+        end
       end.new([])
     }
 
@@ -108,7 +113,7 @@ RSpec.describe Yaks::CollectionMapper do
       expect(mapper.call(collection)).to eql Yaks::CollectionResource.new(
         type: 'the_type',
         links: [],
-        attributes: { foo: 123, bar: 'pi la~~~' },
+        attributes: {foo: 123, bar: 'pi la~~~'},
         members: [],
         rels: ['rel:the_types']
       )
@@ -126,7 +131,7 @@ RSpec.describe Yaks::CollectionMapper do
       expect(mapper.call(collection)).to eql Yaks::CollectionResource.new(
         type: 'the_type',
         links: [ Yaks::Resource::Link.new(rel: :self, uri: 'http://api.example.com/orders') ],
-        attributes: { },
+        attributes: {},
         members: [],
         rels: ['rel:the_types']
       )
@@ -153,7 +158,7 @@ RSpec.describe Yaks::CollectionMapper do
         links: [],
         attributes: {},
         members: [
-          Yaks::Resource.new(type: 'pet', attributes: {:id => 3, :species => "cat", :name => "wassup"})
+          Yaks::Resource.new(type: 'pet', attributes: {id: 3, species: "cat", name: "wassup"})
         ],
         rels: ['rel:pets']
       )
@@ -161,12 +166,11 @@ RSpec.describe Yaks::CollectionMapper do
   end
 
   context 'with an empty collection' do
-
     context 'without an item_mapper specified' do
       let(:context) { Yaks::Util.slice_hash(super(), :policy, :env, :mapper_stack) }
 
       it 'should use a rel of "collection"' do
-        expect(mapper.([]).rels).to eq ['collection']
+        expect(mapper.call([]).rels).to eq ['collection']
       end
     end
 
@@ -174,9 +178,8 @@ RSpec.describe Yaks::CollectionMapper do
       let(:context) { Yaks::Util.slice_hash(super(), :policy, :env, :mapper_stack, :item_mapper) }
 
       it 'should derive the collection rel from the item mapper' do
-        expect(mapper.([]).rels).to eq ['rel:the_types']
+        expect(mapper.call([]).rels).to eq ['rel:the_types']
       end
     end
-
   end
 end

data/spec/unit/yaks/collection_resource_spec.rb

@@ -22,12 +22,12 @@ RSpec.describe Yaks::CollectionResource do
           Yaks::Resource::Link.new(rel: 'http://rels/summary', uri: 'http://order/10/summary'),
           Yaks::Resource::Link.new(rel: :profile, uri: 'http://rels/collection')
         ],
-        attributes: { total: 10.00 },
+        attributes: {total: 10.00},
         members: [
           Yaks::Resource.new(
             type: 'order',
             links: [Yaks::Resource::Link.new(rel: :self, uri: 'http://order/10')],
-            attributes: { customer: 'John Doe', price: 10.00 }
+            attributes: {customer: 'John Doe', price: 10.00}
           )
         ],
         rels: ['http://api.example.org/rels/orders']
@@ -35,17 +35,19 @@ RSpec.describe Yaks::CollectionResource do
     }
 
     its(:type)       { should eql 'order' }
-    its(:links)      { should eql [
+    its(:links)      {
+      should eql [
         Yaks::Resource::Link.new(rel: 'http://rels/summary', uri: 'http://order/10/summary'),
         Yaks::Resource::Link.new(rel: :profile, uri: 'http://rels/collection')
       ]
     }
-    its(:attributes) { should eql( total: 10.00 ) }
-    its(:members)    { should eql [
+    its(:attributes) { should eql(total: 10.00) }
+    its(:members)    {
+      should eql [
         Yaks::Resource.new(
           type: 'order',
           links: [Yaks::Resource::Link.new(rel: :self, uri: 'http://order/10')],
-          attributes: { customer: 'John Doe', price: 10.00 }
+          attributes: {customer: 'John Doe', price: 10.00}
         )
       ]
     }
@@ -55,10 +57,16 @@ RSpec.describe Yaks::CollectionResource do
   end
 
   describe '#seq' do
-    let(:init_opts) { { members: [1,2,3] } }
+    let(:init_opts) { {members: [1, 2, 3]} }
 
     it 'iterates over the members' do
-      expect(subject.seq.map(&:next)).to eql [2,3,4]
+      expect(subject.seq.map(&:next)).to eql [2, 3, 4]
+    end
+  end
+
+  describe '#collection?' do
+    it 'should always be true' do
+      expect(subject.collection?).to be true
     end
   end
 end

data/spec/unit/yaks/config_spec.rb

@@ -16,42 +16,176 @@ RSpec.describe Yaks::Config do
       its(:hooks)               { should eql([])  }
       its(:format_options_hash) { should eql({})}
     end
+  end
+
+  describe '#default_format' do
+    configure do
+      default_format :json_api
+    end
+
+    its(:default_format) { should equal :json_api }
+  end
+
+  describe '#policy_class' do
+    MyPolicy = Struct.new(:options)
+    configure do
+      policy_class MyPolicy
+    end
+
+    its(:policy_class) { should equal MyPolicy }
+    its(:policy)       { should be_a MyPolicy  }
+  end
+
+  describe '#rel_template' do
+    configure do
+      mapper_namespace Object
+      rel_template 'http://rel/foo'
+    end
+
+    its(:policy_options) { should eql(namespace: Object, rel_template: 'http://rel/foo') }
+  end
+
+  describe '#mapper_for' do
+    let(:expected_options) do
+      {
+        namespace: Object,
+        mapper_rules: {
+          home: HomeMapper,
+          Soy => MyMappers::WheatMapper
+        }
+      }
+    end
+    configure do
+      mapper_namespace Object
+      mapper_for Soy, MyMappers::WheatMapper
+      mapper_for :home, HomeMapper
+    end
+
+    its(:policy_options) { should eql(expected_options) }
+  end
 
-    context 'with a default format' do
-      configure do
-        default_format :json_api
+  describe '#format_options' do
+    configure do
+      format_options :hal, plural_links: [:self, :profile]
+      format_options :collection_json, template: :template_form_name
+    end
+
+    it 'should set format options' do
+      expect(config.format_options_hash[:hal]).to eql(plural_links: [:self, :profile])
+    end
+  end
+
+  describe '#json_serializer' do
+    configure do
+      json_serializer(&:upcase)
+    end
+
+    specify do
+      expect(config.serializers[:json].call('foo')).to eql "FOO"
+    end
+  end
+
+  describe '#map_to_primitive' do
+    configure do
+      map_to_primitive Date do |date|
+        date.strftime("%Y-%m")
       end
+    end
 
-      its(:default_format) { should equal :json_api }
+    it 'registers how to handle a primitive type' do
+      expect(config.primitivize.call(Date.new(2015, 10))).to eql "2015-10"
     end
 
-    context 'with a custom policy class' do
-      MyPolicy = Struct.new(:options)
-      configure do
-        policy_class MyPolicy
+    it 'should not change the existing primitize instance' do
+      old_prim = config.primitivize
+      config.map_to_primitive Date do |date|
+        date.strftime("%m-%Y")
       end
+      expect(old_prim.call(Date.new(2015, 10))).to eql "2015-10"
+    end
+  end
 
-      its(:policy_class) { should equal MyPolicy }
-      its(:policy)       { should be_a  MyPolicy }
+  describe '#mapper_namespace' do
+    configure do
+      rel_template '/foo/{rel}'
+      mapper_namespace Yaks::Mapper
+    end
+
+    it 'configures the policy to look in the given namespace' do
+      expect(config.policy.options[:namespace]).to eql Yaks::Mapper
     end
 
-    context 'with a rel template' do
-      configure do
-        rel_template 'http://rel/foo'
+    it 'should not overwrite other options' do
+      expect(config.policy.options[:rel_template]).to eql '/foo/{rel}'
+    end
+  end
+
+  describe '#policy' do
+    PolicyClass = Class.new do
+      include Attribs.new(:namespace)
+    end
+
+    configure do
+      policy_class PolicyClass
+      mapper_namespace Yaks::Mapper
+    end
+
+    it 'returns an instantiated policy' do
+      expect(config.policy).to eql PolicyClass.new(namespace: Yaks::Mapper)
+    end
+  end
+
+  describe '#derive_mapper_from_object' do
+    configure { }
+    let(:object) { Pet.new(id: 7, name: 'fifi', species: 'cat') }
+    subject do
+      config.derive_mapper_from_object do |object|
+        mapper_class = super(object)
+        Object.const_get("Great#{mapper_class.name}")
       end
+    end
+
+    its(:policy_class) { should <= Yaks::DefaultPolicy }
 
-      its(:policy_options) { should eql(rel_template: 'http://rel/foo') }
+    it 'should override the policy method' do
+      expect(subject.policy.derive_mapper_from_object(object)).to be GreatPetMapper
     end
+  end
 
-    context 'with format options' do
-      configure do
-        format_options :hal, plural_links: [:self, :profile]
+  describe '#derive_mapper_from_item' do
+    configure { }
+    let(:object) { Pet.new(id: 7, name: 'fifi', species: 'cat') }
+    subject do
+      config.derive_mapper_from_item do |object|
+        mapper_class = super(object)
+        Object.const_get("Great#{mapper_class.name}")
       end
+    end
+
+    its(:policy_class) { should <= Yaks::DefaultPolicy }
+
+    it 'should override the policy method' do
+      expect(subject.policy.derive_mapper_from_item(object)).to be GreatPetMapper
+      expect(subject.policy.derive_mapper_from_object(object)).to be GreatPetMapper
+    end
+  end
 
-      specify do
-        expect(config.format_options_hash[:hal]).to eql(plural_links: [:self, :profile])
+  describe '#derive_mapper_from_collection' do
+    configure { }
+    let(:object) { [Pet.new(id: 7, name: 'fifi', species: 'cat')] }
+    subject do
+      config.derive_mapper_from_collection do |object|
+        mapper_class_name = super(object).name.split('::').last
+        Object.const_get("GreatPet#{mapper_class_name}")
       end
     end
+
+    its(:policy_class) { should <= Yaks::DefaultPolicy }
+
+    it 'should override the policy method' do
+      expect(subject.policy.derive_mapper_from_collection(object)).to be GreatPetCollectionMapper
+      expect(subject.policy.derive_mapper_from_object(object)).to be GreatPetCollectionMapper
+    end
   end
 
   describe '#call' do
@@ -66,4 +200,66 @@ RSpec.describe Yaks::Config do
     end
   end
 
+  describe '#map' do
+    configure {}
+
+    it 'only performs the mapping stage' do
+      expect(config.map(wassup))
+        .to eql Yaks::Resource.new(
+                  type: "pet",
+                  attributes: {id: 3, name: "wassup", species: "cat"}
+                )
+    end
+  end
+
+  describe '#read' do
+    configure {
+      default_format :json_api
+    }
+
+    it 'invokes the reader for the given format' do
+      expect(config.read('{"data": [{"type": "pets",
+                                     "id": 3,
+                                     "name": "wassup",
+                                     "species": "cat"}]}').members.first)
+        .to eql Yaks::Resource.new(
+                  type: "pet",
+                  attributes: {id: 3, name: "wassup", species: "cat"}
+                )
+    end
+  end
+
+  describe '#format' do
+    configure {
+      default_format :hal
+    }
+
+    it 'invokes the formatter on a resource' do
+      expect(config.format(Yaks::Resource.new(attributes: {shape: "round"})))
+        .to eql("shape" => "round")
+    end
+  end
+
+  describe '#runner' do
+    configure {}
+
+    it 'provides a Yaks::Runner' do
+      expect(config.runner(:foo, bar: 1))
+        .to eql Yaks::Runner.new(config: config, object: :foo, options: {bar: 1})
+    end
+  end
+
+  describe '#serializer' do
+    configure do
+      serializer(:foo) {|x| x.upcase.reverse }
+    end
+
+    it 'registers a serializer for a given type' do
+      expect(config.serializers[:foo].call('bar')).to eql 'RAB'
+    end
+
+    it 'should keep existing serializers' do
+      expect(config.serializers[:json].call([:foo, :bar], {})).to eql %{[\n  "foo",\n  "bar"\n]}
+    end
+  end
 end