yaks 0.0.0 → 0.1.0

data/spec/json/hal_plant_collection.json

@@ -0,0 +1,34 @@
+{
+   "_links" : {
+      "profile" : { "href" : "http://api.example.com/doc/plant_collection" },
+      "self" : { "href" : "http://api.example.com/plants" }
+  },
+   "_embedded" : {
+      "http://api.example.com/doc/plant_collection" : [
+         {
+            "_links" : {
+               "profile" : { "href" : "http://api.example.com/doc/plant" },
+               "self" : { "href" : "http://api.example.com/plants/7/plain_grass" }
+            },
+            "name" : "Plain grass",
+            "type" : "grass"
+         },
+         {
+            "_links" : {
+               "profile" : { "href" : "http://api.example.com/doc/plant" },
+               "self" : { "href" : "http://api.example.com/plants/15/oak" }
+            },
+            "name" : "Oak",
+            "type" : "tree"
+         },
+         {
+            "_links" : {
+               "profile" : { "href" : "http://api.example.com/doc/plant" },
+               "self" : { "href" : "http://api.example.com/plants/33/passiflora" }
+            },
+            "name" : "Passiflora",
+            "type" : "flower"
+         }
+      ]
+   }
+}

data/spec/spec_helper.rb

@@ -6,7 +6,16 @@ $LOAD_PATH.unshift(ROOT.join('lib'))
 
 require 'yaks'
 require 'virtus'
+require 'json'
 
 require_relative 'support/models'
-require_relative 'support/serializers'
+require_relative 'support/pet_mapper'
+require_relative 'support/pet_peeve_mapper'
+require_relative 'support/friends_mapper'
 require_relative 'support/fixtures'
+require_relative 'support/shorthands'
+require_relative 'support/shared_contexts'
+
+def load_json_fixture(name)
+  JSON.parse(ROOT.join('spec/json', name + '.json').read)
+end

data/spec/support/friends_mapper.rb

@@ -0,0 +1,29 @@
+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/spec/support/pet_mapper.rb

@@ -0,0 +1,5 @@
+class PetMapper < Yaks::Mapper
+  attributes :id, :name, :species
+
+  #link :collection, '/api/pets/{id*}'
+end

data/spec/support/pet_peeve_mapper.rb

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

data/spec/support/serializers.rb

@@ -1,14 +1,14 @@
-class FriendSerializer < Yaks::Serializer
-  attributes :id, :name
+# class FriendSerializer < Yaks::Mapper
+#   attributes :id, :name
 
-  has_many :pets
-  has_one :pet_peeve
-end
+#   has_many :pets
+#   has_one :pet_peeve
+# end
 
-class PetSerializer < Yaks::Serializer
-  attributes :id, :name, :species
-end
+# class PetSerializer < Yaks::Mapper
+#   attributes :id, :name, :species
+# end
 
-class PetPeeveSerializer < Yaks::Serializer
-  attributes :id, :type
-end
+# class PetPeeveSerializer < Yaks::Mapper
+#   attributes :id, :type
+# end

data/spec/support/shared_contexts.rb

@@ -0,0 +1,47 @@
+shared_context 'collection resource' do
+  let(:resource) { Yaks::CollectionResource.new(links, members) }
+  let(:links)    { [] }
+  let(:members)  { [] }
+end
+
+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(
+      {name: "Plain grass", type: "grass"},
+      [plain_grass_self_link, plant_profile_link],
+      {}
+    )
+  end
+
+  let(:oak) do
+    Yaks::Resource.new(
+      {name: "Oak", type: "tree"},
+      [oak_self_link, plant_profile_link],
+      {}
+    )
+  end
+
+  let(:passiflora) do
+    Yaks::Resource.new(
+      {name: "Passiflora", type: "flower"},
+      [passiflora_self_link, plant_profile_link],
+      {}
+    )
+  end
+end

data/spec/support/shorthands.rb

@@ -0,0 +1,22 @@
+shared_context 'shorthands' do
+  let(:resource) {
+    ->(attrs, links = nil) {
+      Yaks::Resource.new(Yaks::Hash(attrs), links, nil)
+    }
+  }
+
+  let(:collection_resource) {
+    ->(*attr_hashes) {
+      Yaks::CollectionResource.new(
+        nil,
+        Yaks::List(attr_hashes.map(&resource.method(:call)))
+      )
+    }
+  }
+
+  let(:resource_link) {
+    ->(rel, uri, options = {}) {
+      Yaks::Resource::Link.new(rel, uri, options)
+    }
+  }
+end

data/spec/yaks/collection_resource_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Yaks::CollectionResource do
+  it 'should normalize its arguments' do
+    expect(described_class.new(nil, nil)).to eq(
+      described_class.new(Yaks::List(), Yaks::List())
+    )
+  end
+end

data/spec/yaks/hal_serializer_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Yaks::HalSerializer do
+  include_context 'plant collection resource'
+
+  subject { described_class.new(resource).serialize }
+
+  it { should eq(load_json_fixture('hal_plant_collection')) }
+end

data/spec/yaks/mapper/association_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Yaks::Mapper::Association do
+  describe 'self_link' do
+    context 'without a :self link' do
+      subject { described_class.new(nil, nil, nil, Yaks::List(Yaks::Mapper::Link.new(:alternate, '/foo')), {}) }
+
+      it 'should be nil' do
+        expect(subject.self_link).to be_nil
+      end
+    end
+  end
+
+  context 'with a self link' do
+    subject { described_class.new(nil, nil, nil, Yaks::List(Yaks::Mapper::Link.new(:self, '/self')), {}) }
+
+    it 'should resolve to the self link' do
+      expect(subject.self_link).to eq Yaks::Mapper::Link.new(:self, '/self')
+    end
+  end
+end

data/spec/yaks/mapper/class_methods_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Yaks::Mapper::ClassMethods do
+  subject { Class.new { extend Yaks::Mapper::ClassMethods } }
+
+  describe 'attributes' do
+    before do
+      subject.attributes(:foo, :bar)
+    end
+
+    it 'should allow setting them' do
+      expect( subject.attributes ).to eq Hamster.list(:foo, :bar)
+    end
+
+    describe 'with inheritance' do
+      let(:child) { Class.new(subject) }
+      before { child.attributes(:baz) }
+
+      it 'should inherit attributes from the parent' do
+        expect(child.attributes).to eq Hamster.list(:foo, :bar, :baz)
+      end
+
+      it 'should not alter the parent' do
+        expect(subject.attributes).to eq Hamster.list(:foo, :bar)
+      end
+    end
+  end
+end

data/spec/yaks/mapper/config_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe Yaks::Mapper::Config do
+  subject(:config) { described_class.new }
+
+  describe 'attributes' do
+    context 'an empty config' do
+      it 'should return an empty attributes list' do
+        expect(config.attributes).to eq Yaks::List()
+      end
+    end
+
+    it 'should add attributes' do
+      expect(config.attributes(:foo, :bar, :baz).attributes)
+        .to eq Hamster.list(:foo, :bar, :baz)
+    end
+
+    it 'should be chainable' do
+      expect(
+        config
+          .attributes(:foo, :bar)
+          .attributes(:baz)
+          .attributes
+      ).to eq Hamster.list(:foo, :bar, :baz)
+    end
+  end
+
+  describe 'links' do
+    context 'an empty config' do
+      it 'should have an empty link list' do
+        expect(config.links).to eq Yaks::List()
+      end
+    end
+
+    describe 'adding a link' do
+      let(:config) { subject.link(:self, '/foo/bar/{id}') }
+
+      it 'should have it in the link list' do
+        expect(config.links).to eq Yaks::List(Yaks::Mapper::Link.new(:self, '/foo/bar/{id}'))
+      end
+    end
+
+    describe 'setting a profile' do
+      let(:config) { subject.profile :post }
+
+      it 'should set the profile name' do
+        expect(config.profile).to eq :post
+      end
+    end
+  end
+
+  describe 'associations' do
+    describe 'has_one' do
+      let(:config) { subject.has_one :mother, mapper: Yaks::Mapper }
+
+      it 'should have the association configured' do
+        expect(config.associations).to eq Yaks::List(Yaks::Mapper::HasOne.new(:mother, :mother, Yaks::Mapper, Yaks::List(), {}))
+      end
+    end
+
+    describe 'has_many' do
+      let(:config) { subject.has_many :shoes, mapper: Yaks::Mapper }
+
+      it 'should have the association configured' do
+        expect(config.associations).to eq Yaks::List(Yaks::Mapper::HasMany.new(:shoes, :shoes, Yaks::Mapper, Yaks::List(), {}))
+      end
+    end
+
+    context 'with an :as alternate key' do
+      let(:config) { subject.has_many :shoes, as: :footwear, mapper: Yaks::Mapper }
+
+      it 'should have the given value as its "key"' do
+        expect(config.associations.first.key).to eq :footwear
+      end
+    end
+  end
+end

data/spec/yaks/mapper/has_one_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Yaks::Mapper::HasOne do
+  include_context 'shorthands'
+
+  AuthorMapper = Class.new(Yaks::Mapper) { attributes :name }
+
+  let(:name)     { 'William S. Burroughs' }
+  let(:mapper)   { AuthorMapper }
+  let(:has_one)  { described_class.new(:author, :author, mapper, [], {}) }
+  let(:author)   { Struct.new(:name).new(name) }
+
+  it 'should map to a single Resource' do
+    expect(has_one.map_resource(author, {})).to eq resource[{name: name}, [resource_link[:profile, 'author']]]
+  end
+end

data/spec/yaks/mapper/link_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Yaks::Mapper::Link do
+  include_context 'shorthands'
+
+  subject(:link) { described_class.new(rel, template, options) }
+
+  let(:rel) { :next }
+  let(:template) { '/foo/bar/{x}/{y}' }
+  let(:options) { {} }
+  its(:variables) { should eq ['x', 'y'] }
+  its(:uri_template) { should eq URITemplate.new(template) }
+
+  it 'should expand the template' do
+    expect(link.expand(:x => 3, :y => 'foo')).to eq '/foo/bar/3/foo'
+  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
+
+      its(:expand?) { should be_false }
+    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
+  end
+
+end

data/spec/yaks/mapper/map_links_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Yaks::Mapper::MapLinks do
+  let(:policy)           { Class.new(Yaks::DefaultPolicy) { def derive_profile_from_mapper(*); :the_profile ; end }.new }
+  let(:mapper_class) do
+    Class.new(Yaks::Mapper) do
+      def get_title
+        "The Title"
+      end
+    end
+  end
+
+  subject(:mapper) do
+    mapper_class.new(Object.new, policy: policy)
+  end
+
+  context 'with a title proc' do
+    before do
+      mapper_class.link :the_link_rel, '/foo/bar', title: ->{ get_title }
+    end
+
+    it 'should resolve the title' do
+      expect(mapper.map_links).to include Yaks::Resource::Link.new(:the_link_rel, '/foo/bar', title: 'The Title')
+    end
+  end
+
+  context 'with a title string' do
+    before do
+      mapper_class.link :the_link_rel, '/foo/bar', title: 'fixed string'
+    end
+
+    it 'should resolve the title' do
+      expect(mapper.map_links).to include Yaks::Resource::Link.new(:the_link_rel, '/foo/bar', title: 'fixed string')
+    end
+  end
+
+  context 'with no title set' do
+    before do
+      mapper_class.link :the_link_rel, '/foo/bar'
+    end
+
+    it 'should resolve the title' do
+      expect(mapper.map_links).to include Yaks::Resource::Link.new(:the_link_rel, '/foo/bar', {})
+    end
+  end
+end