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

data/yaks/spec/unit/yaks/fp_spec.rb

@@ -1,31 +0,0 @@
-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/yaks/spec/unit/yaks/mapper/association_mapper_spec.rb

@@ -1,60 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Yaks::Mapper::AssociationMapper do
-  include_context '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) }
-
-  fake(:association) { Yaks::Mapper::Association }
-
-  its(:policy) { should be policy }
-
-  let(:mapper_stack) { [:bottom_mapper] }
-
-  describe '#call' do
-    context 'when the association should be rendered as link' do
-      before do
-        stub(association).render_as_link?(parent_mapper) { true }
-        stub(association).map_rel(policy) { 'rels:the_rel' }
-        stub(association).href { 'http://this/is_where_the_associated_thing_can_be_found' }
-      end
-
-      it 'should render a link' do
-        expect(association_mapper.call(Yaks::Resource.new)).to eql Yaks::Resource.new(
-          links: [
-            Yaks::Resource::Link.new(
-              'rels:the_rel',
-              'http://this/is_where_the_associated_thing_can_be_found', {}
-            )
-          ]
-        )
-      end
-    end
-
-    context 'when the association should be rendered as a subresource' do
-      before do
-        stub(association).render_as_link?(parent_mapper) { false }
-        stub(association).map_rel(policy) { 'rels:the_rel' }
-        stub(association).name { :the_name }
-        stub(association).map_resource(:the_object, association_mapper.context) { :the_resource }
-
-        stub(parent_mapper).load_association(:the_name) { :the_object }
-      end
-
-      it 'should render a link' do
-        expect(association_mapper.call(Yaks::Resource.new)).to eql Yaks::Resource.new(
-          subresources: {
-            'rels:the_rel' => :the_resource
-          }
-        )
-      end
-
-      it 'should add the mapper to the mapper_stack' do
-        expect(association_mapper.context[:mapper_stack]).to eql [:bottom_mapper, parent_mapper]
-      end
-    end
-  end
-end

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

@@ -1,135 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Yaks::Mapper::Association do
-  include_context 'yaks context'
-
-  subject(:association) do
-    described_class.new(
-      name: name,
-      mapper: mapper,
-      rel: rel,
-      href: href,
-      link_if: link_if
-    )
-  end
-
-  let(:name)              { :shoes          }
-  let(:mapper)            { Yaks::Mapper    }
-  let(:rel)               { Yaks::Undefined }
-  let(:href)              { Yaks::Undefined }
-  let(:link_if)           { Yaks::Undefined }
-
-  its(:name)         { should equal :shoes }
-  its(:child_mapper) { should equal Yaks::Mapper }
-
-  context 'with a minimal constructor' do
-    subject(:association) { described_class.new(name: :foo) }
-
-    its(:name)         { should be :foo }
-    its(:child_mapper) { should be Yaks::Undefined }
-    its(:rel)          { should be Yaks::Undefined }
-    its(:href)         { should be Yaks::Undefined }
-    its(:link_if)      { should be Yaks::Undefined }
-  end
-
-  let(:parent_mapper_class) { Yaks::Mapper }
-  let(:parent_mapper)       { parent_mapper_class.new(yaks_context) }
-
-  describe '#add_to_resource' do
-    let(:object) { fake(:shoes => []) }
-    let(:rel)    { 'rel:shoes' }
-    before do
-      parent_mapper.call(object)
-    end
-
-    it 'should delegate to AssociationMapper' do
-      expect(association.add_to_resource(Yaks::Resource.new, parent_mapper, yaks_context)).to eql Yaks::Resource.new(subresources: {'rel:shoes' => nil} )
-    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(:render_as_link?) { association.render_as_link?(parent_mapper) }
-
-    context 'when evaluating to true' do
-      it 'should resolve :link_if in the context of the mapper' do
-        expect(render_as_link?).to be true
-      end
-    end
-
-    context 'when evaluating to false' do
-      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
-      end
-    end
-
-    context 'with an Undefined href' do
-      let(:href) { Yaks::Undefined }
-
-      it 'should return falsey' do
-        expect(render_as_link?).to be_falsey
-      end
-    end
-
-    context 'with an Undefined link_if' do
-      let(:link_if) { Yaks::Undefined }
-
-      it 'should return falsey' do
-        expect(render_as_link?).to be_falsey
-      end
-    end
-  end
-
-  describe '#map_rel' do
-    let(:association_rel) { association.map_rel(policy) }
-
-    context 'with a rel specified' do
-      let(:rel) { 'http://api.com/rels/shoes' }
-
-      it 'should use the specified rel' do
-        expect(association_rel).to eql 'http://api.com/rels/shoes'
-      end
-    end
-
-    context 'without a rel specified' do
-      before do
-        stub(policy).derive_rel_from_association(association) {
-          'http://api.com/rel/derived'
-        }
-      end
-
-      it 'should infer a rel based on policy' do
-        expect(association_rel).to eql 'http://api.com/rel/derived'
-      end
-    end
-  end
-
-  describe '#resolve_association_mapper' do
-    context 'with a specified mapper' do
-      let(:mapper) { :a_specific_mapper_class }
-
-      it 'should return the mapper' do
-        expect(association.resolve_association_mapper(nil)).to equal :a_specific_mapper_class
-      end
-    end
-
-    context 'with the mapper undefined' do
-      let(:mapper) { Yaks::Undefined }
-
-      before do
-        stub(policy).derive_mapper_from_association(association) {
-          :a_derived_mapper_class
-        }
-      end
-
-      it 'should derive a mapper based on policy' do
-        expect(association.resolve_association_mapper(policy)).to equal :a_derived_mapper_class
-      end
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Yaks::Mapper::Attribute do
-  include_context 'yaks context'
-
-  subject(:attribute) { described_class.new(:the_name) }
-  fake(:mapper)
-
-  its(:name) { should be :the_name }
-
-  before do
-    stub(mapper).load_attribute(:the_name) { 123 }
-  end
-
-  it 'should add itself to a resource based on a lookup' do
-    expect(attribute.add_to_resource(Yaks::Resource.new, mapper , yaks_context)).to eql(
-      Yaks::Resource.new(attributes: { :the_name => 123 })
-    )
-  end
-end

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

@@ -1,67 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Yaks::Mapper::ClassMethods do
-  subject(:mapper_class) do
-    Class.new do
-      extend Yaks::Mapper::ClassMethods
-      attributes :foo, :bar
-      link :some_rel, 'http://some_link'
-      has_one :thing
-      has_many :thingies
-    end
-  end
-
-  describe 'attributes' do
-    it 'should allow setting them' do
-      expect( mapper_class.attributes ).to eq [
-        Yaks::Mapper::Attribute.new(:foo),
-        Yaks::Mapper::Attribute.new(:bar)
-      ]
-    end
-
-    describe 'with inheritance' do
-      let(:child_class) do
-        Class.new(mapper_class) do
-          attributes :baz
-        end
-      end
-
-      let(:grandchild_class) do
-        Class.new(child_class)
-      end
-
-      it 'should inherit attributes from the parent' do
-        expect(child_class.attributes).to eq [
-          Yaks::Mapper::Attribute.new(:foo),
-          Yaks::Mapper::Attribute.new(:bar),
-          Yaks::Mapper::Attribute.new(:baz)
-        ]
-      end
-
-      it 'should create a valid config' do
-        expect(grandchild_class.config).to be_a Yaks::Mapper::Config
-      end
-
-      it 'should not alter the parent' do
-        expect(mapper_class.attributes).to eq [
-          Yaks::Mapper::Attribute.new(:foo),
-          Yaks::Mapper::Attribute.new(:bar),
-        ]
-      end
-    end
-  end
-
-  it 'should register links' do
-    expect(mapper_class.config.links).to eq [
-      Yaks::Mapper::Link.new(:some_rel, 'http://some_link', {})
-    ]
-  end
-
-  it 'should register associations' do
-    expect(mapper_class.config.associations).to eq [
-      Yaks::Mapper::HasOne.new(name: :thing),
-      Yaks::Mapper::HasMany.new(name: :thingies)
-    ]
-  end
-
-end

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

@@ -1,166 +0,0 @@
-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 '#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 [
-        Yaks::Mapper::Attribute.new(:foo),
-        Yaks::Mapper::Attribute.new(:bar),
-        Yaks::Mapper::Attribute.new(:baz)
-      ]
-    end
-
-    it 'should be chainable' do
-      expect(
-        config
-          .attributes(:foo, :bar)
-          .attributes(:baz)
-          .attributes
-      ).to eq [
-        Yaks::Mapper::Attribute.new(:foo),
-        Yaks::Mapper::Attribute.new(:bar),
-        Yaks::Mapper::Attribute.new(: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(name: :mother, mapper: Yaks::Mapper)
-        ]
-      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(name: :mother)
-        ]
-      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(name: :mother, rel: '/api/rels/mother')
-        ]
-      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(name: :shoes, mapper: Yaks::Mapper)
-        ]
-      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(name: :shoes)
-        ]
-      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(name: :shoes, collection_mapper: :a_collection_mapper)
-        ]
-      end
-    end
-  end
-
-  describe "#type" do
-    it "should update the type" do
-      config = config().type :shoe
-      expect(config.type).to be :shoe
-    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(name: :mother)
-      expect(config.associations).to include Yaks::Mapper::HasMany.new(name: :shoes)
-    end
-  end
-end