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

data/yaks/spec/support/fixtures.rb

@@ -1,6 +0,0 @@
-shared_context 'fixtures' do
-  let(:john)       { Friend.new(id: 1, name: 'john', pets: [boingboing, wassup], pet_peeve: regexps) }
-  let(:boingboing) { Pet.new(id: 2, name: 'boingboing', species: 'dog')                              }
-  let(:wassup)     { Pet.new(id: 3, name: 'wassup', species: 'cat')                                  }
-  let(:regexps)    { PetPeeve.new(id: 4, type: 'parsing with regexps')                               }
-end

data/yaks/spec/support/friends_mapper.rb

@@ -1,29 +0,0 @@
-class FriendMapper < Yaks::Mapper
-  attributes :id, :name
-
-  link :copyright, '/api/copyright/{year}'
-
-  def year
-    2024
-  end
-
-  has_one :pet_peeve, mapper: PetPeeveMapper
-  has_many :pets, mapper: PetMapper
-
-  # has_one :production_company,          # retrieve as `show.production_company`
-  #         profile: :company,            # use the company profile link from the registry, e.g. 'http://foo.api/profiles/company'
-  #         as: :producer,                # serialize as {"producers" => []} in JSON-API or [{class: ["producer"]}] in Siren
-  #         embed: :link,                 # don't embed the whole data, link to it, could also be embed: :resource
-  #         mapper: CompanyMapper,        # use this to find the resource URL, or to map the embedded resource
-  #         rel: :show_production_company # find the relation in the relation registry, e.g. http://foo.apo/rels/show_production_company
-
-  # # Full derived defaults
-  # has_one :production_company
-  #   # profile: :production_company,  # same as the 'name'
-  #   # as: :production_company,       # same as the 'name'
-  #   # embed: :links                  # depends on what is configured as default
-  #   # mapper: CompanyMapper          # found by matching the profile
-  #   # rel: :show_production_company  # "#{context.profile_name}_#{relation.profile_name}"
-
-  # # has_many :pets
-end

data/yaks/spec/support/models.rb

@@ -1,23 +0,0 @@
-class Pet
-  include Virtus.model
-
-  attribute :id, Integer
-  attribute :name, String
-  attribute :species, String
-end
-
-class PetPeeve
-  include Virtus.model
-
-  attribute :id, Integer
-  attribute :type, String
-end
-
-class Friend
-  include Virtus.model
-
-  attribute :id, Integer
-  attribute :name, String
-  attribute :pets, Array[Pet]
-  attribute :pet_peeve, PetPeeve
-end

data/yaks/spec/support/pet_mapper.rb

@@ -1,3 +0,0 @@
-class PetMapper < Yaks::Mapper
-  attributes :id, :name, :species
-end

data/yaks/spec/support/pet_peeve_mapper.rb

@@ -1,3 +0,0 @@
-class PetPeeveMapper < Yaks::Mapper
-  attributes :id, :type
-end

data/yaks/spec/support/shared_contexts.rb

@@ -1,57 +0,0 @@
-RSpec.shared_context 'collection resource' do
-  let(:resource) do
-    Yaks::CollectionResource.new(
-      links: links,
-      members: members,
-      collection_rel: 'http://api.example.com/rels/plants'
-    )
-  end
-  let(:links)    { [] }
-  let(:members)  { [] }
-end
-
-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 } }
-end
-
-RSpec.shared_context 'plant collection resource' do
-  include_context 'collection resource'
-
-  let(:links)   { [ plants_self_link, plants_profile_link ] }
-  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' ],
-  ].each do |name, type, uri|
-    let(:"#{name}_#{type}_link") { Yaks::Resource::Link.new(type, uri, {}) }
-  end
-
-  let(:plain_grass) do
-    Yaks::Resource.new(
-      attributes: {name: "Plain grass", type: "grass"},
-      links: [plain_grass_self_link, plant_profile_link]
-    )
-  end
-
-  let(:oak) do
-    Yaks::Resource.new(
-      attributes: {name: "Oak", type: "tree"},
-      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],
-    )
-  end
-end

data/yaks/spec/support/youtypeit_models_mappers.rb

@@ -1,20 +0,0 @@
-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/yaks/spec/unit/yaks/collection_mapper_spec.rb

@@ -1,165 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Yaks::CollectionMapper do
-  include_context 'fixtures'
-
-  subject(:mapper) { mapper_class.new(context) }
-  let(:mapper_class) { described_class }
-
-  let(:context) {
-    { item_mapper: item_mapper,
-      policy: policy,
-      env: {},
-      mapper_stack: [] }
-  }
-
-  let(:collection) { [] }
-  let(:item_mapper) { Class.new(Yaks::Mapper) { type 'the_type' } }
-  let(:policy) { Yaks::DefaultPolicy.new }
-
-  it 'should map the collection' do
-    expect(mapper.call(collection)).to eql Yaks::CollectionResource.new(
-      type: 'the_type',
-      links: [],
-      attributes: {},
-      members: [],
-      collection_rel: 'rel:the_types'
-    )
-  end
-
-  context 'with members' do
-    let(:collection) { [boingboing, wassup]}
-    let(:item_mapper) { PetMapper }
-
-    it 'should map the members' do
-      stub(policy).derive_mapper_from_object(any_args) do
-        raise ":item_mapper was specified explicitly, should not be derived from object"
-      end
-
-      expect(mapper.call(collection)).to 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"})
-        ],
-        collection_rel: 'rel:pets'
-      )
-    end
-  end
-
-  context 'without an item_mapper in the context' do
-    let(:context) {
-      {
-        policy: policy,
-        env: {},
-        mapper_stack: []
-      }
-    }
-    let(:collection) { [boingboing, wassup]}
-
-    it 'should infer the item mapper' do
-      expect(mapper.call(collection)).to 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"})
-        ],
-        collection_rel: 'rel:pets'
-      )
-    end
-  end
-
-  context 'with collection attributes' do
-    subject(:mapper) {
-      Class.new(Yaks::CollectionMapper) do
-        attributes :foo, :bar
-      end.new(context)
-    }
-
-    let(:collection) {
-      Class.new(SimpleDelegator) do
-        def foo ; 123 ; end
-        def bar ; 'pi la~~~' ; end
-      end.new([])
-    }
-
-    it 'should map the attributes' do
-      expect(mapper.call(collection)).to eql Yaks::CollectionResource.new(
-        type: 'the_type',
-        links: [],
-        attributes: { foo: 123, bar: 'pi la~~~' },
-        members: [],
-        collection_rel: 'rel:the_types'
-      )
-    end
-  end
-
-  context 'with collection links' do
-    subject(:mapper) {
-      Class.new(Yaks::CollectionMapper) do
-        link :self, 'http://api.example.com/orders'
-      end.new(context)
-    }
-
-    it 'should map the links' do
-      expect(mapper.call(collection)).to eql Yaks::CollectionResource.new(
-        type: 'the_type',
-        links: [ Yaks::Resource::Link.new(:self, 'http://api.example.com/orders', {}) ],
-        attributes: { },
-        members: [],
-        collection_rel: 'rel:the_types'
-      )
-    end
-  end
-
-  describe 'overriding #collection' do
-    let(:mapper_class) do
-      Class.new(described_class) do
-        type 'pet'
-
-        def collection
-          super.drop(1)
-        end
-      end
-    end
-
-    let(:collection) { [boingboing, wassup]}
-    let(:item_mapper) { PetMapper }
-
-    it 'should use the redefined collection method' do
-      expect(mapper.call(collection)).to eql Yaks::CollectionResource.new(
-        type: 'pet',
-        links: [],
-        attributes: {},
-        members: [
-          Yaks::Resource.new(type: 'pet', attributes: {:id => 3, :species => "cat", :name => "wassup"})
-        ],
-        collection_rel: 'rel:pets'
-      )
-    end
-  end
-
-  context 'with an empty collection' do
-
-    context 'without an item_mapper specified' do
-      let(:context) { Yaks::Util.slice_hash(super(), :policy, :env) }
-
-      it 'should use a rel of "collection"' do
-        expect(mapper.([]).collection_rel).to eq 'collection'
-      end
-    end
-
-    context 'with an item_mapper specified' do
-      let(:context) { Yaks::Util.slice_hash(super(), :policy, :env, :item_mapper) }
-
-      it 'should derive the collection rel from the item mapper' do
-        expect(mapper.([]).collection_rel).to eq 'rel:the_types'
-      end
-    end
-
-  end
-end

data/yaks/spec/unit/yaks/collection_resource_spec.rb

@@ -1,77 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Yaks::CollectionResource do
-  subject(:collection) { described_class.new(init_opts) }
-  let(:init_opts) { {} }
-
-  its(:collection?)    { should be true }
-  its(:null_resource?) { should be false }
-
-  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({}) }
-    its(:collection_rel)  { should eql('members') }
-  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 }
-          )
-        ],
-        collection_rel: 'http://api.example.org/rels/orders'
-      }
-    }
-
-    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(:collection_rel) { should eq 'http://api.example.org/rels/orders'}
-
-    its(:subresources) { should eql(
-        'http://api.example.org/rels/orders' => 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 }
-            )
-          ],
-          collection_rel: 'http://api.example.org/rels/orders'
-        )
-      )
-    }
-
-  end
-end

data/yaks/spec/unit/yaks/config/dsl_spec.rb

@@ -1,87 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Yaks::Config::DSL do
-  subject!(:dsl) { described_class.new(yaks_config, &config_block) }
-
-  let(:yaks_config)  { Yaks::Config.new }
-  let(:config_block) { nil }
-
-  def self.configure(&blk)
-    let(:config_block) { blk }
-  end
-
-  describe '#initialize' do
-    its(:config) { should equal yaks_config }
-
-    it 'should set a default policy' do
-      expect(yaks_config.policy_class.new).to be_a_kind_of Yaks::DefaultPolicy
-    end
-
-    it 'should execute the given block in instance scope' do
-      dsl = described_class.new(yaks_config) do
-        @config = :foo
-      end
-      expect(dsl.config).to be :foo
-    end
-
-    describe 'policy redefinitions' do
-      configure do
-        derive_type_from_mapper_class do |mapper_class|
-          :inside_redefined_policy_method
-        end
-      end
-
-      it 'should delegate and redefine' do
-        expect(yaks_config.policy.derive_type_from_mapper_class(nil)).to be :inside_redefined_policy_method
-      end
-
-      it 'should not change the original class definition' do
-        expect(Yaks::DefaultPolicy.new.derive_type_from_mapper_class(fake(name: 'FooMapper'))).to eql 'foo'
-      end
-    end
-  end
-
-  describe '#format_options' do
-    configure { format_options :hal, singular_link: [:self] }
-    specify   { expect(yaks_config.format_options[:hal]).to eq(singular_link: [:self]) }
-  end
-
-  describe '#default_format' do
-    configure { default_format :json_api }
-    specify   { expect(yaks_config.default_format).to be :json_api }
-  end
-
-  describe '#policy' do
-    configure { policy 'MyPolicyClass' }
-    specify   { expect(yaks_config.policy_class).to eql 'MyPolicyClass' }
-  end
-
-  describe '#rel_template' do
-    configure { rel_template 'rels:{rel}' }
-    specify   { expect(yaks_config.policy_options[:rel_template]).to eql 'rels:{rel}' }
-  end
-
-  describe '#json_serializer' do
-    configure { json_serializer { |i| "foo #{i}" } }
-    specify   { expect(yaks_config.serializers[:json].call(7)).to eql 'foo 7' }
-  end
-
-  describe '#mapper_namespace' do
-    configure { mapper_namespace RSpec }
-    specify   { expect(yaks_config.policy_options[:namespace]).to eql RSpec }
-  end
-
-  describe '#map_to_primitive' do
-    Foo = Class.new do
-      attr_reader :foo
-
-      def initialize(foo)
-        @foo = foo
-      end
-    end
-
-    configure { map_to_primitive(Foo) {|c| c.foo } }
-    specify   { expect(yaks_config.primitivize.call({:abc => Foo.new('hello')})).to eql 'abc' => 'hello' }
-  end
-
-end