yaks-html 0.6.0.alpha → 0.6.0.alpha.1

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

@@ -1,89 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Yaks::Mapper::HasMany do
-  include_context 'yaks context'
-
-  let(:closet_mapper) { closet_mapper_class.new(yaks_context) }
-
-  let(:closet_mapper_class) do
-    Class.new(Yaks::Mapper) do
-      type 'closet'
-      has_many :shoes,
-        rel: 'http://foo/shoes',
-        mapper: Class.new(Yaks::Mapper) { type 'shoe' ; attributes :size, :color }
-    end
-  end
-
-  subject(:shoe_association) { closet_mapper.associations.first }
-
-  its(:singular_name) { should eq 'shoe' }
-
-  let(:closet) {
-    fake(
-      :shoes => [
-        fake(size: 9,    color: :blue),
-        fake(size: 11.5, color: :red),
-      ]
-    )
-  }
-
-  it 'should map the subresources' do
-    expect(closet_mapper.call(closet).subresources).to eql(
-      "http://foo/shoes" => Yaks::CollectionResource.new(
-        type: 'shoe',
-        members: [
-          Yaks::Resource.new(type: 'shoe', attributes: {:size => 9, :color => :blue}),
-          Yaks::Resource.new(type: 'shoe', attributes: {:size => 11.5, :color => :red})
-        ],
-        collection_rel: 'rel:shoes'
-      )
-    )
-  end
-
-  it 'should map nil to a NullResource collection' do
-    expect(closet_mapper.call(fake(shoes: nil)).subresources).to eql(
-      'http://foo/shoes' => Yaks::NullResource.new(collection: true)
-    )
-  end
-
-  context 'without an explicit mapper' do
-    let(:dress_mapper) {
-      Class.new(Yaks::Mapper) { type 'dress' ; attributes :color }
-    }
-
-    before do
-      closet_mapper_class.class_eval do
-        has_many :dresses
-      end
-
-      stub(closet_mapper.policy).derive_mapper_from_association(any_args) do
-        dress_mapper
-      end
-    end
-
-    it 'should derive it from policy' do
-      expect(closet_mapper.policy).to equal policy
-      closet_mapper.call(fake(shoes: [], dresses: [fake(color: 'blue')]))
-    end
-  end
-
-
-  describe '#collection_mapper' do
-    let(:collection_mapper) { Yaks::Undefined }
-    subject(:has_many)  { described_class.new(name: :name, mapper: :mapper, rel: :rel, collection_mapper: collection_mapper) }
-
-    context 'when the collection mapper is undefined' do
-      it 'should derive one from collection and policy' do
-        expect(has_many.collection_mapper([], Yaks::DefaultPolicy.new)).to equal Yaks::CollectionMapper
-      end
-    end
-
-    context 'when the collection mapper is specified' do
-      let(:collection_mapper) { :foo }
-
-      it 'should use the given collection mapper' do
-        expect(has_many.collection_mapper([], Yaks::DefaultPolicy.new)).to equal :foo
-      end
-    end
-  end
-end

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

@@ -1,51 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Yaks::Mapper::HasOne do
-  include_context 'yaks context'
-
-  AuthorMapper = Class.new(Yaks::Mapper) { attributes :name }
-
-  subject(:has_one)  do
-    described_class.new(
-      name: :author,
-      mapper: association_mapper,
-      rel: 'http://rel'
-    )
-  end
-
-  let(:association_mapper) { AuthorMapper }
-  let(:name)               { 'William S. Burroughs' }
-  let(:author)             { fake(:name => name) }
-
-  fake(:policy,
-    derive_type_from_mapper_class: 'author',
-    derive_mapper_from_association: AuthorMapper
-  ){ Yaks::DefaultPolicy }
-
-  its(:singular_name) { should eq 'author' }
-
-  it 'should map to a single Resource' do
-    expect(has_one.map_resource(author, yaks_context)).to eq Yaks::Resource.new(type: 'author', attributes: {name: name})
-  end
-
-  context 'with no mapper specified' do
-    subject(:subresource)    { has_one.add_to_resource(Yaks::Resource.new, parent_mapper, yaks_context) }
-    let(:association_mapper) { Yaks::Undefined }
-    fake(:parent_mapper) { Yaks::Mapper }
-
-    before do
-      stub(parent_mapper).load_association(:author) { author }
-    end
-
-    it 'should derive one based on policy' do
-      expect(subresource).to eql(
-        Yaks::Resource.new(
-          subresources: {
-            'http://rel' => Yaks::Resource.new(type: 'author', attributes: {name: name})
-          }
-        )
-      )
-    end
-
-  end
-end

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

@@ -1,196 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Yaks::Mapper::Link do
-  include_context 'yaks context'
-
-  subject(:link) { described_class.new(rel, template, options) }
-
-  let(:rel)      { :next }
-  let(:template) { '/foo/bar/{x}/{y}' }
-  let(:options)  { {} }
-
-  its(:template_variables) { should eq [:x, :y] }
-  its(:uri_template) { should eq URITemplate.new(template) }
-
-  let(:object) { Struct.new(:x, :y, :returns_nil).new(3, 4, nil) }
-
-  let(:mapper_class) do
-    Class.new(Yaks::Mapper) do
-      type 'foo'
-    end
-  end
-
-  let(:mapper) do
-    mapper_class.new(yaks_context).tap do |mapper|
-      mapper.call(object) # set @object
-    end
-  end
-
-  describe '#add_to_resource' do
-    it 'should add itself to the resource' do
-      expect(link.add_to_resource(Yaks::Resource.new, mapper, yaks_context)).to eql(
-        Yaks::Resource.new(links: [Yaks::Resource::Link.new(:next, "/foo/bar/3/4", {})])
-      )
-    end
-
-    context 'with a link function returning nothing' do
-      let(:template) { :link_computer }
-      before do
-        mapper_class.class_eval do
-          def link_computer ; end
-        end
-      end
-
-      it 'should not render the link' do
-        expect(link.add_to_resource(Yaks::Resource.new, mapper, yaks_context)).to eql(
-          Yaks::Resource.new
-        )
-      end
-    end
-  end
-
-  describe '#rel?' do
-    it 'should return true if the relation matches' do
-      expect(link.rel?(:next)).to be true
-    end
-
-    it 'should return false if the relation does not match' do
-      expect(link.rel?(:previous)).to be false
-    end
-
-    context 'with URI rels' do
-      let(:rel) { 'http://foo/bar/rel' }
-
-      it 'should return true if the relation matches' do
-        expect(link.rel?('http://foo/bar/rel')).to be true
-      end
-
-      it 'should return false if the relation does not match' do
-        expect(link.rel?('http://foo/bar/other')).to be false
-      end
-    end
-  end
-
-  describe '#expand_with' do
-    it 'should look up expansion values through the provided callable' do
-      expect(link.expand_with(->(var){ var.upcase })).to eq '/foo/bar/X/Y'
-    end
-
-    context 'with expansion turned off' do
-      let(:options) { {expand: false} }
-
-      it 'should keep the template in the response' do
-        expect(link.expand_with(->{ })).to eq '/foo/bar/{x}/{y}'
-      end
-    end
-
-    context 'with a URI without expansion variables' do
-      let(:template) { '/orders' }
-
-      it 'should return the link as is' do
-        expect(link.expand_with(->{ })).to eq '/orders'
-      end
-    end
-
-    context 'with partial expansion' do
-      let(:options) { { expand: [:y] } }
-
-      it 'should only expand the given variables' do
-        expect(link.expand_with({:y => 7}.method(:[]))).to eql '/foo/bar/{x}/7'
-      end
-    end
-
-    context 'with a symbol for a template' do
-      let(:template) { :a_symbol }
-
-      it 'should use the lookup mechanism for finding the link' do
-        expect(link.expand_with({:a_symbol => '/foo/foo'}.method(:[]))).to eq '/foo/foo'
-      end
-    end
-  end
-
-  describe '#map_to_resource_link' do
-    subject(:resource_link) { link.map_to_resource_link(mapper) }
-
-    its(:rel) { should eq :next }
-
-    context 'with attributes' do
-      it 'should not have a title' do
-        expect(resource_link.options.key?(:title)).to be false
-      end
-
-      it 'should not be templated' do
-        expect(resource_link.options[:templated]).to be_falsey
-      end
-
-      context 'with extra options' do
-        let(:options) { {title: 'foo', expand: [:x], foo: :bar} }
-
-        it 'should pass on unknown options' do
-          expect(resource_link.options[:foo]).to eql :bar
-        end
-      end
-
-      it 'should create an instance of Yaks::Resource::Link' do
-        expect(resource_link).to be_a(Yaks::Resource::Link)
-      end
-
-      it 'should expand the URI template' do
-        expect(resource_link.uri).to eq '/foo/bar/3/4'
-      end
-    end
-
-    context 'with expansion turned off' do
-      let(:options) { {expand: false} }
-
-      it 'should be templated' do
-        expect(resource_link.options[:templated]).to be true
-      end
-
-      it 'should not propagate :expand' do
-        expect(resource_link.options.key?(:expand)).to be false
-      end
-    end
-
-    context 'with partial expansion' do
-      let(:options) { {expand: [:x]} }
-
-      it 'should be templated' do
-        expect(resource_link.options[:templated]).to be true
-      end
-    end
-
-    context 'with a title set' do
-      let(:options) { { title: 'link title' } }
-
-      it 'should set the title on the resource link' do
-        expect(resource_link.title).to eq 'link title'
-      end
-    end
-
-    context 'with a title lambda' do
-      let(:options) { { title: -> { "say #{mapper_method}" } } }
-
-      before do
-        mapper_class.class_eval do
-          def mapper_method
-            'hello'
-          end
-        end
-      end
-
-      it 'should evaluate the lambda in the context of the mapper' do
-        expect(resource_link.title).to eq 'say hello'
-      end
-    end
-
-    context 'with a link generation method that returns nil' do
-      let(:template) { :returns_nil }
-
-      it 'should return nil' do
-        expect(resource_link).to be_nil
-      end
-    end
-  end
-
-end

data/yaks/spec/unit/yaks/mapper_spec.rb

@@ -1,303 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Yaks::Mapper do
-  include_context 'yaks context'
-
-  subject(:mapper)   { mapper_class.new(yaks_context) }
-  let(:resource)     { mapper.call(instance) }
-
-  let(:mapper_class) { Class.new(Yaks::Mapper) { type 'foo' } }
-
-  let(:instance) { fake(foo: 'hello', bar: 'world') }
-
-  its(:env) { should equal rack_env }
-
-  describe '#call' do
-    context 'with attributes' do
-      before do
-        mapper_class.attributes :foo, :bar
-      end
-
-      it 'should make the configured attributes available on the instance' do
-        expect(mapper.attributes).to eq [
-          Yaks::Mapper::Attribute.new(:foo),
-          Yaks::Mapper::Attribute.new(:bar)
-        ]
-      end
-
-      it 'should load them from the model' do
-        expect(resource.attributes).to eq(foo: 'hello', bar: 'world')
-      end
-
-      context 'with attribute filtering' do
-        before do
-          mapper_class.class_eval do
-            def attributes
-              super.reject {|attr| attr.name == :foo}
-            end
-          end
-        end
-
-        it 'should only map the non-filtered attributes' do
-          expect(resource.attributes).to eq(:bar => 'world')
-        end
-      end
-    end
-
-    context 'with links' do
-      before do
-        mapper_class.link :profile, 'http://foo/bar'
-      end
-
-      it 'should map the link' do
-        expect(resource.links).to eq [
-          Yaks::Resource::Link.new(:profile, 'http://foo/bar', {})
-        ]
-      end
-
-      it 'should use the link in the resource' do
-        expect(resource.links).to include Yaks::Resource::Link.new(:profile, 'http://foo/bar', {})
-      end
-
-      context 'with the same link rel defined multiple times' do
-        before do
-          mapper_class.class_eval do
-            link(:self, 'http://foo/bam')
-            link(:self, 'http://foo/baz')
-            link(:self, 'http://foo/baq')
-          end
-        end
-
-        it 'should map all the links' do
-          expect(resource.links).to eq [
-            Yaks::Resource::Link.new(:profile, 'http://foo/bar', {}),
-            Yaks::Resource::Link.new(:self, 'http://foo/bam', {}),
-            Yaks::Resource::Link.new(:self, 'http://foo/baz', {}),
-            Yaks::Resource::Link.new(:self, 'http://foo/baq', {})
-          ]
-        end
-      end
-    end
-
-    context 'with subresources' do
-      let(:widget)   { fake(type: 'super_widget') }
-      let(:instance) { fake(widget: widget) }
-      let(:widget_mapper) { Class.new(Yaks::Mapper) { type 'widget' } }
-      fake(:policy) { Yaks::DefaultPolicy }
-
-      describe 'has_one' do
-        let(:has_one_opts) do
-          { mapper: widget_mapper,
-            rel: 'http://foo.bar/rels/widgets' }
-        end
-
-        before do
-          widget_mapper.attributes :type
-          mapper_class.has_one(:widget, has_one_opts)
-        end
-
-
-        it 'should have the subresource in the resource' do
-          expect(resource.subresources).to eq("http://foo.bar/rels/widgets" => Yaks::Resource.new(type: 'widget', attributes: {:type => "super_widget"}))
-        end
-
-        context 'with explicit mapper and rel' do
-          it 'should delegate to the given mapper' do
-            expect(resource.subresources).to eq(
-              "http://foo.bar/rels/widgets" => Yaks::Resource.new(type: 'widget', attributes: {:type => "super_widget"})
-            )
-          end
-        end
-
-        context 'with unspecified mapper' do
-          let(:has_one_opts) do
-            { rel: 'http://foo.bar/rels/widgets' }
-          end
-
-          before do
-            stub(policy).derive_mapper_from_association(mapper.associations.first) do
-              widget_mapper
-            end
-          end
-
-          it 'should derive the mapper based on policy' do
-            expect(resource.subresources).to eq(
-              "http://foo.bar/rels/widgets" => Yaks::Resource.new(type: 'widget', attributes: {:type => "super_widget"})
-            )
-          end
-        end
-
-        context 'with unspecified rel' do
-          let(:has_one_opts) do
-            { mapper: widget_mapper }
-          end
-
-          before do
-            stub(policy).derive_rel_from_association(mapper.associations.first) do
-              'http://rel/rel'
-            end
-          end
-
-          it 'should derive the rel based on policy' do
-            expect(resource.subresources).to eq(
-              "http://rel/rel" => Yaks::Resource.new(type: 'widget', attributes: {:type => "super_widget"})
-            )
-          end
-        end
-
-        context 'with the association filtered out' do
-          before do
-            mapper_class.class_eval do
-              def associations
-                []
-              end
-            end
-          end
-
-          it 'should not map the resource' do
-            expect(resource.subresources).to eq({})
-          end
-        end
-      end
-    end
-
-    context 'when the mapper implements a method with the attribute name' do
-      before do
-        mapper_class.class_eval do
-          attributes :fooattr, :bar
-
-          def fooattr
-            "#{object.foo} my friend"
-          end
-        end
-      end
-
-      it 'should get the attribute from the mapper' do
-        expect(resource.attributes).to eq(fooattr: 'hello my friend', bar: 'world')
-      end
-    end
-
-    context 'with a nil subject' do
-      it 'should return a NullResource when the subject is nil' do
-        expect(mapper.call(nil)).to be_a Yaks::NullResource
-      end
-    end
-
-    context 'with a link generated by a method that returns nil' do
-      before do
-        mapper_class.class_eval do
-          attributes :id
-          link :bar_link, :link_generating_method
-
-          def link_generating_method
-          end
-        end
-      end
-
-      it 'should not render the link' do
-        expect(mapper.call(fake(id: 123))).to eql Yaks::Resource.new(
-          type: 'foo',
-          attributes: {id: 123}
-        )
-      end
-    end
-  end
-
-  describe '.mapper_name' do
-    context 'with a type configured' do
-      it 'should use the type' do
-        expect(mapper_class.mapper_name(policy)).to eql 'foo'
-      end
-    end
-
-    context 'without a type configured' do
-      let(:mapper_class) { PetMapper }
-
-      it 'should infer the type from the name' do
-        expect(mapper_class.mapper_name(policy)).to eql 'pet'
-      end
-    end
-  end
-
-  describe '#mapper_name' do
-    context 'with a type configured' do
-      it 'should use the type' do
-        expect(mapper.mapper_name).to eql 'foo'
-      end
-    end
-
-    context 'without a type configured' do
-      let(:mapper_class) { PetMapper }
-
-      it 'should infer the type from the name' do
-        expect(mapper.mapper_name).to eql 'pet'
-      end
-    end
-  end
-
-  describe '#load_attribute' do
-    context 'with the attribute defined as a method on the mapper' do
-      it 'should call the local implementation' do
-        def mapper.foo
-          14
-        end
-
-        expect(mapper.load_attribute(:foo)).to eql 14
-      end
-    end
-
-    context 'without a mapper method with the attribute name' do
-      it 'should call the method on the object being mapped' do
-        mapper.call(instance) # set @object
-        expect(mapper.load_attribute(:foo)).to eql 'hello'
-      end
-    end
-  end
-
-  describe '#map_attributes' do
-    let(:attribute) { fake('Attribute') }
-
-    it 'should receive a context' do
-      stub(attribute).add_to_resource(any_args) {|r,_,_| Yaks::Resource.new}
-
-      mapper.config.attributes[0..-1] = [attribute]
-      mapper.call(instance)
-
-      expect(attribute).to have_received.add_to_resource(any(Yaks::Resource), mapper, yaks_context)
-    end
-  end
-
-  describe '#map_links' do
-    let(:link) { fake('Link') }
-
-    it 'should receive a context' do
-      stub(link).add_to_resource(any_args) {|r,_,_| Yaks::Resource.new}
-
-      mapper.config.links[0..-1] = [link]
-      mapper.call(instance)
-
-      expect(link).to have_received.add_to_resource(any(Yaks::Resource), mapper, yaks_context)
-    end
-  end
-
-  describe '#map_subresources' do
-    let(:association) { fake('Association') }
-
-    it 'should receive a context' do
-      stub(association).add_to_resource(any_args) {|r,_,_| Yaks::Resource.new}
-
-      mapper.config.associations[0..-1] = [association]
-      mapper.call(instance)
-
-      expect(association).to have_received.add_to_resource(any(Yaks::Resource), mapper, yaks_context)
-    end
-  end
-
-  describe '#mapper_stack' do
-    let(:yaks_context) { super().merge(mapper_stack: [:foo]) }
-
-    it 'should delegate to context' do
-      expect(mapper.mapper_stack).to eql [:foo]
-    end
-  end
-end