yaks 0.9.0 → 0.10.0

data/spec/unit/yaks/format/hal_spec.rb

@@ -9,7 +9,7 @@ RSpec.describe Yaks::Format::Hal do
 
   context 'with multiple links on the same rel' do
     let(:format) {
-      described_class.new(:plural_links => 'my_plural_rel')
+      described_class.new(plural_links: 'my_plural_rel')
     }
 
     let(:resource) {
@@ -32,8 +32,8 @@ RSpec.describe Yaks::Format::Hal do
         'bar' => 'barval',
         '_links' => {
           "my_plural_rel" => [
-            {"href"=>"the_uri1"},
-            {"href"=>"the_uri2"}
+            {"href" => "the_uri1"},
+            {"href" => "the_uri2"}
           ]
         }
       )

data/spec/unit/yaks/format/json_api_spec.rb

@@ -5,126 +5,167 @@ RSpec.describe Yaks::Format::JsonAPI do
   context 'with no subresources' do
     let(:resource) { Yaks::Resource.new(type: 'wizard', attributes: {foo: :bar}) }
 
-    it 'should not include a "linked" key' do
+    it 'should not include an "included" key' do
       expect(format.call(resource)).to eql(
-        {data: [{type: :wizards, foo: :bar}]}
+        data: {type: 'wizards', attributes: {foo: :bar}}
       )
     end
   end
 
-  context 'with both a "href" attribute and a self link' do
+  context 'collection with metadata' do
     let(:resource) {
-      Yaks::Resource.new(
+      Yaks::CollectionResource.new(
         type: 'wizard',
-        attributes: {
-          href: '/the/href'
-        },
-        links: [
-          Yaks::Resource::Link.new(rel: :self, uri: '/the/self/link')
-        ]
+        members: [Yaks::Resource.new(type: 'wizard', attributes: {foo: :bar})],
+        attributes: {meta: {page: {limit: 20, offset: 0, count: 25}}}
       )
     }
 
-    # TODO should it really behave this way? better to give preference to self link.
-    it 'should give preference to the href attribute' do
+    it 'should include the "meta" key' do
       expect(format.call(resource)).to eql(
-        {data: [
-            {
-              type: :wizards,
-              href: '/the/href'
-            }
-          ]
-        }
+        meta: {page: {limit: 20, offset: 0, count: 25}},
+        data: [{type: 'wizards', attributes: {foo: :bar}}]
       )
     end
   end
 
-  context 'with a self link' do
+  context 'with links and subresources' do
     let(:resource) {
       Yaks::Resource.new(
-          type: 'wizard',
-          links: [
-              Yaks::Resource::Link.new(rel: :self, uri: '/the/self/link')
-          ]
+        type: 'wizard',
+        subresources: [
+          Yaks::Resource.new(rels: ['rel:favourite_spell'], type: 'spell', attributes: {id: 1}),
+        ],
+        links: [
+          Yaks::Resource::Link.new(rel: :self, uri: '/the/self/link'),
+          Yaks::Resource::Link.new(rel: :profile, uri: '/the/profile/link'),
+        ]
       )
     }
-    it 'should use the self link in output' do
+
+    it 'should include the links in the "links" key' do
       expect(format.call(resource)).to eql(
-         {data: [
-             {
-                 type: :wizards,
-                 href: '/the/self/link'
-             }
-         ]
-         }
+        data: {
+          type: 'wizards',
+          links: {
+            self: "/the/self/link",
+            profile: "/the/profile/link",
+            'favourite_spell' => {linkage: {type: "spells", id: "1"}},
+          }
+        },
+        included: [{type: 'spells', id: "1"}]
       )
-
     end
   end
 
   context 'with subresources' do
     let(:resource) {
       Yaks::Resource.new(
-          type: 'wizard',
-          subresources: [
-              Yaks::Resource.new(type: 'spell', attributes: {id: 777, name: 'Lucky Sevens'})
-          ]
+        type: 'wizard',
+        subresources: [
+          Yaks::Resource.new(rels: ['rel:favourite_spell'], type: 'spell', attributes: {id: 777, name: 'Lucky Sevens'})
+        ]
       )
     }
-    it 'should include links and linked' do
+
+    it 'should include subresource links and included' do
       expect(format.call(resource)).to eql(
-         {
-           data: [
-             {
-               type: :wizards,
-               links: {'spell'  => {type: 'spells', id: 777}}
-             }
-           ],
-           linked: [{type: :spells, id: 777, name: 'Lucky Sevens'}]
-         }
+        data: {
+          type: 'wizards',
+          links: {'favourite_spell'  => {linkage: {type: 'spells', id: "777"}}}
+        },
+        included: [{type: 'spells', id: "777", attributes: {name: 'Lucky Sevens'}}]
       )
     end
+  end
+
+  context 'with duplicate subresources' do
+    let(:resource) {
+      Yaks::CollectionResource.new(
+        type: 'wizard',
+        members: [
+          Yaks::Resource.new(type: 'wizard', attributes: {id: 7}, subresources: [
+            Yaks::Resource.new(type: 'spell', attributes: {id: 1}, rels: ['rel:favourite_spell']),
+          ]),
+          Yaks::Resource.new(type: 'wizard', attributes: {id: 3}, subresources: [
+            Yaks::Resource.new(type: 'spell', attributes: {id: 1}, rels: ['rel:favourite_spell']),
+          ]),
+          Yaks::Resource.new(type: 'wizard', attributes: {id: 2}, subresources: [
+            Yaks::Resource.new(type: 'spell', attributes: {id: 12}, rels: ['rel:favourite_spell']),
+          ]),
+          Yaks::Resource.new(type: 'wizard', attributes: {id: 9}, subresources: [
+            Yaks::Resource.new(type: 'wand', attributes: {id: 1}, rels: ['rel:wand']),
+          ]),
+        ],
+      )
+    }
 
+    it 'should include the each subresource only once' do
+      expect(format.call(resource)).to eql(
+        data: [
+          {type: 'wizards', id: '7', links: {'favourite_spell' => {linkage: {type: 'spells', id: '1'}}}},
+          {type: 'wizards', id: '3', links: {'favourite_spell' => {linkage: {type: 'spells', id: '1'}}}},
+          {type: 'wizards', id: '2', links: {'favourite_spell' => {linkage: {type: 'spells', id: '12'}}}},
+          {type: 'wizards', id: '9', links: {'wand'            => {linkage: {type: 'wands',  id: '1'}}}},
+        ],
+        included: [
+          {type: 'spells', id: '1'},
+          {type: 'spells', id: '12'},
+          {type: 'wands',  id: '1'},
+        ]
+      )
+    end
   end
 
   context 'with null subresources' do
     let(:resource) {
       Yaks::Resource.new(
-          type: 'wizard',
-          subresources: [
-              Yaks::NullResource.new
-          ]
+        type: 'wizard',
+        subresources: [Yaks::NullResource.new]
       )
     }
-    it 'should not include links' do
+
+    it 'should not include subresource links' do
       expect(format.call(resource)).to eql(
-         {data: [
-             {
-                 type: :wizards,
-             }
-         ]
-         }
+        data: {type: 'wizards'}
       )
     end
   end
 
-  context 'with no subresources or links' do
+  context 'with no subresources or subresource links' do
     let(:resource) {
       Yaks::Resource.new(
-          type: 'wizard',
-          subresources: []
+        type: 'wizard',
+        subresources: []
       )
     }
-    it 'should not include links' do
+
+    it 'should not include subresource links' do
       expect(format.call(resource)).to eql(
-         {data: [
-             {
-                 type: :wizards
-             }
-         ]
-         }
+        data: {type: 'wizards'}
       )
     end
   end
 
+  context 'with links as collection' do
+    let(:resource) {
+      Yaks::CollectionResource.new(
+        type: 'wizard',
+        links: [
+          Yaks::Resource::Link.new(rel: :prev, uri: '/prev/page/link'),
+          Yaks::Resource::Link.new(rel: :next, uri: '/next/page/link'),
+        ]
+      )
+    }
+
+    it 'should include links' do
+      expect(format.call(resource)).to eql(
+        data: [],
+        links: {
+          prev: '/prev/page/link',
+          next: '/next/page/link',
+        }
+      )
+    end
+  end
 end

data/spec/unit/yaks/format_spec.rb

@@ -28,4 +28,38 @@ RSpec.describe Yaks::Format do
       expect(Yaks::Format.media_types.values_at(:collection_json, :hal, :json_api)).to eql(["application/vnd.collection+json", "application/hal+json", "application/vnd.api+json"])
     end
   end
+
+  let(:init_opts) { Hash.new }
+  subject(:format) { Yaks::Format.new(init_opts) }
+
+  describe "#initialize" do
+    it 'should set options' do
+      expect(format.send(:options)).to equal init_opts
+    end
+
+    it 'should default to an empty hash' do
+      expect(Yaks::Format.new.send(:options)).to eql({})
+    end
+  end
+
+  describe "#call" do
+    it 'should set the environment' do
+      format.call(nil, foo: 1)
+      expect(format.env).to eql(foo: 1)
+    end
+
+    it 'should default to an empty environment' do
+      format.call(:foo)
+      expect(format.env).to eql({})
+    end
+
+    it 'should delegate to #serialize_resource' do
+      stub(format).serialize_resource(:foo) {|_r| :bar}
+      expect(format.call(:foo)).to equal :bar
+    end
+  end
+
+  describe '#serialize_resource' do
+    specify { expect(format.serialize_resource(:foo)).to be_nil }
+  end
 end

data/spec/unit/yaks/fp/callable_spec.rb

@@ -1,11 +1,13 @@
-RSpec.describe Yaks::FP::Callable do
+RSpec.describe Yaks::FP::Callable, "#to_proc" do
   it 'should delegate to_proc to method(:call)' do
     obj = Class.new do
       include Yaks::FP::Callable
 
-      def call(x) ; x * x ; end
+      def call(x)
+        x * x
+      end
     end.new
 
-    expect([1,2,3].map(&obj)).to eql [1,4,9]
+    expect([1, 2, 3].map(&obj)).to eql [1, 4, 9]
   end
 end

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

@@ -1,16 +1,34 @@
 RSpec.describe Yaks::Mapper::AssociationMapper do
   include_context 'yaks context'
 
-  subject(:association_mapper) { described_class.new(parent_mapper, association, yaks_context) }
+  subject(:association_mapper) {
+    described_class.new(parent_mapper, association, yaks_context)
+  }
 
   let(:parent_mapper_class) { Yaks::Mapper }
-  let(:parent_mapper)       { parent_mapper_class.new(yaks_context) }
+  let(:parent_mapper) { parent_mapper_class.new(yaks_context) }
+  let(:mapper_stack) { [:bottom_mapper] }
 
   fake(:association) { Yaks::Mapper::Association }
 
-  its(:policy) { should be policy }
+  describe "#policy" do
+    its(:policy) { should be policy }
+  end
+
+  describe "#initialize" do
+    its(:parent_mapper) { should equal parent_mapper }
+    its(:association) { should equal association }
 
-  let(:mapper_stack) { [:bottom_mapper] }
+    it "should add the parent mapper to the mapper stack" do
+      expect(association_mapper.context[:mapper_stack])
+        .to eql [:bottom_mapper, parent_mapper]
+    end
+
+    it "should set the rel based on the association" do
+      stub(association).map_rel(policy) { '/association/rel' }
+      expect(association_mapper.rel).to eql '/association/rel'
+    end
+  end
 
   describe '#call' do
     context 'when the association should be rendered as link' do

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

@@ -1,8 +1,15 @@
 RSpec.describe Yaks::Mapper::Association do
   include_context 'yaks context'
 
+  let(:association_class) {
+    Class.new(described_class) do
+      def map_resource(_object, _context)
+      end
+    end
+  }
+
   subject(:association) do
-    described_class.new(
+    association_class.new(
       name: name,
       item_mapper: mapper,
       rel: rel,
@@ -23,7 +30,7 @@ RSpec.describe Yaks::Mapper::Association do
   its(:item_mapper) { should equal Yaks::Mapper }
 
   context 'with a minimal constructor' do
-    subject(:association) { described_class.new(name: :foo) }
+    subject(:association) { association_class.new(name: :foo) }
 
     its(:name)         { should be :foo }
     its(:item_mapper)  { should be Yaks::Undefined }
@@ -36,7 +43,7 @@ RSpec.describe Yaks::Mapper::Association do
   let(:parent_mapper)       { parent_mapper_class.new(yaks_context) }
 
   describe '#add_to_resource' do
-    let(:object) { fake(:shoes => []) }
+    let(:object) { fake(shoes: []) }
     let(:rel)    { 'rel:shoes' }
 
     before do
@@ -56,6 +63,12 @@ RSpec.describe Yaks::Mapper::Association do
       end
     end
 
+    context 'without a condition' do
+      it 'should add the association' do
+        expect(association.add_to_resource(Yaks::Resource.new, parent_mapper, yaks_context).subresources.length).to be 1
+      end
+    end
+
     context 'with a falsey condition' do
       let(:if)     { ->{ false } }
 
@@ -63,13 +76,12 @@ RSpec.describe Yaks::Mapper::Association do
         expect(association.add_to_resource(Yaks::Resource.new, parent_mapper, yaks_context).subresources.length).to be 0
       end
     end
-
   end
 
   describe '#render_as_link?' do
     let(:href)     { '/foo/{bar}/baz' }
     let(:link_if)  { -> { env.fetch('env_entry') == 123 } }
-    let(:rack_env) { { 'env_entry' => 123 } }
+    let(:rack_env) { {'env_entry' => 123} }
 
     let(:render_as_link?) { association.render_as_link?(parent_mapper) }
 
@@ -80,7 +92,7 @@ RSpec.describe Yaks::Mapper::Association do
     end
 
     context 'when evaluating to false' do
-      let(:rack_env) { { 'env_entry' => 0 } }
+      let(:rack_env) { {'env_entry' => 0} }
 
       it 'should resolve :link_if in the context of the mapper' do
         expect(render_as_link?).to be false
@@ -154,24 +166,24 @@ RSpec.describe Yaks::Mapper::Association do
 
   describe '.create' do
     it 'should take a name' do
-      expect(described_class.create(:foo).name).to be :foo
+      expect(association_class.create(:foo).name).to be :foo
     end
 
     it 'should optionally take a mapper' do
-      expect(described_class.create(:foo, mapper: :bar).item_mapper).to be :bar
+      expect(association_class.create(:foo, mapper: :bar).item_mapper).to be :bar
     end
 
     it 'should take other options' do
-      expect(described_class.create(:foo, mapper: :bar, href: 'xxx').href).to eql 'xxx'
+      expect(association_class.create(:foo, mapper: :bar, href: 'xxx').href).to eql 'xxx'
     end
 
     it 'should respect attribute defaults' do
-      expect(described_class.create(:foo, href: 'xxx').item_mapper).to be Yaks::Undefined
+      expect(association_class.create(:foo, href: 'xxx').item_mapper).to be Yaks::Undefined
     end
 
     it 'should not munge the options hash' do
       opts  = {mapper: :foo}
-      described_class.create(:foo, opts)
+      association_class.create(:foo, opts)
       expect(opts).to eql(mapper: :foo)
     end
   end