yaks 0.3.1 → 0.4.0.rc1

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

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+RSpec.describe Yaks::Mapper::HasOne do
+  AuthorMapper = Class.new(Yaks::Mapper) { attributes :name }
+
+  let(:name)     { 'William S. Burroughs' }
+  let(:mapper)   { AuthorMapper }
+  let(:has_one)  { described_class.new(:author, mapper, 'http://rel', Yaks::Undefined) }
+  let(:author)   { double(:name => name) }
+  let(:policy)   {
+    double(
+      Yaks::DefaultPolicy,
+      derive_type_from_mapper_class: 'author',
+      derive_mapper_from_association: AuthorMapper
+    )
+  }
+  let(:context) {{policy: policy, env: {}}}
+
+  it 'should map to a single Resource' do
+    expect(has_one.map_resource(author, context)).to eq Yaks::Resource.new(type: 'author', attributes: {name: name})
+  end
+
+  context 'with no mapper specified' do
+    let(:mapper)   { Yaks::Undefined }
+
+    it 'should derive one based on policy' do
+      expect(has_one.create_subresource(nil, {author: author}, context)).to eql [
+        'http://rel',
+        Yaks::Resource.new(type: 'author', attributes: {name: name})
+      ]
+    end
+
+  end
+end

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

@@ -0,0 +1,152 @@
+require 'spec_helper'
+
+RSpec.describe Yaks::Mapper::Link do
+  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) }
+  its(:expand?) { should be true }
+
+  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
+
+      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
+
+    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 }
+
+    let(:object) { Struct.new(:x,:y).new(3,4) }
+
+    let(:mapper) do
+      Yaks::Mapper.new(object, nil)
+    end
+
+    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}" } } }
+
+      it 'should evaluate the lambda in the context of the mapper' do
+        expect(mapper).to receive(:mapper_method).and_return('hello')
+        expect(resource_link.title).to eq 'say hello'
+      end
+    end
+
+  end
+
+end

data/spec/unit/yaks/mapper_spec.rb

@@ -0,0 +1,177 @@
+require 'spec_helper'
+
+RSpec.describe Yaks::Mapper do
+  subject(:mapper)       { mapper_class.new(instance, context) }
+
+  let(:mapper_class) { Class.new(Yaks::Mapper) { type 'foo' } }
+  let(:instance)     { double(foo: 'hello', bar: 'world') }
+  let(:policy)       { nil }
+  let(:options)      { {} }
+  let(:context) {{policy: policy, env: {}}}
+
+  describe '#map_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 [:foo, :bar]
+    end
+
+    it 'should load them from the model' do
+      expect(mapper.map_attributes).to eq(foo: 'hello', bar: 'world')
+    end
+
+    context 'with attribute filtering' do
+      before do
+        mapper_class.class_eval do
+          def filter(attrs)
+            attrs.to_a - [:foo]
+          end
+        end
+      end
+
+      it 'should only map the non-filtered attributes' do
+        expect(mapper.map_attributes).to eq(:bar => 'world')
+      end
+    end
+  end
+
+  describe '#map_links' do
+    before do
+      mapper_class.link :profile, 'http://foo/bar'
+    end
+
+    it 'should map the link' do
+      expect(mapper.map_links).to eq [
+        Yaks::Resource::Link.new(:profile, 'http://foo/bar', {})
+      ]
+    end
+
+    it 'should use the link in the resource' do
+      expect(mapper.to_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(mapper.map_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
+
+  describe '#map_subresources' do
+    let(:instance)      { double(widget: widget) }
+    let(:widget)        { double(type: 'super_widget') }
+    let(:widget_mapper) { Class.new(Yaks::Mapper) { type 'widget' } }
+    let(:policy)        { double('Policy') }
+
+    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(mapper.to_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(mapper.map_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
+
+        it 'should derive the mapper based on policy' do
+          expect(policy).to receive(:derive_mapper_from_association) {|assoc|
+            expect(assoc).to be_a Yaks::Mapper::HasOne
+            widget_mapper
+          }
+          expect(mapper.map_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
+
+        it 'should derive the rel based on policy' do
+          expect(policy).to receive(:derive_rel_from_association) {|parent_mapper, assoc|
+            expect(parent_mapper).to equal mapper
+            expect(assoc).to be_a Yaks::Mapper::HasOne
+            'http://rel/rel'
+          }
+          expect(mapper.map_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 filter(attrs) [] end
+          end
+        end
+
+        it 'should not map the resource' do
+          expect(mapper.map_subresources).to eq({})
+        end
+      end
+    end
+  end
+
+  describe '#load_attributes' do
+    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(mapper.map_attributes).to eq(fooattr: 'hello my friend', bar: 'world')
+      end
+    end
+  end
+
+  describe '#to_resource' do
+    let(:instance) { nil }
+
+    it 'should return a NullResource when the subject is nil' do
+      expect(mapper.to_resource).to be_a Yaks::NullResource
+    end
+  end
+end

data/spec/unit/yaks/resource_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+RSpec.describe Yaks::Resource do
+  subject(:resource) { described_class.new(init_opts) }
+  let(:init_opts) { {} }
+
+  its(:type)         { should be_nil }
+  its(:attributes)   { should eql({}) }
+  its(:links)        { should eql [] }
+  its(:subresources) { should eql({}) }
+
+  context 'with a type' do
+    let(:init_opts) { { type: 'post' } }
+    its(:type) { should eql 'post' }
+  end
+
+  context 'with attributes' do
+    let(:init_opts) { { attributes: {name: 'Arne', age: 31} } }
+
+    it 'should delegate [] to attribute access' do
+      expect(resource[:name]).to eql 'Arne'
+    end
+  end
+
+  context 'with links' do
+    let(:init_opts) { { links: [Yaks::Resource::Link.new(:self, '/foo/bar', {})] } }
+    its(:links) { should eql [Yaks::Resource::Link.new(:self, '/foo/bar', {})] }
+  end
+
+  context 'with subresources' do
+    let(:init_opts) { { subresources: { 'comments' => [Yaks::Resource.new(type: 'comment')] } } }
+    its(:subresources) { should eql 'comments' => [Yaks::Resource.new(type: 'comment')]  }
+  end
+
+  its(:collection?) { should equal false }
+
+  it 'should act as a collection of one' do
+    expect(resource.each.to_a).to eql [resource]
+  end
+end

data/spec/{yaks/hal_serializer_spec.rb → unit/yaks/serializer/hal_spec.rb}

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

data/spec/unit/yaks/serializer_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Yaks::Serializer do
+  describe '.by_name' do
+    specify { expect(Yaks::Serializer.by_name(:hal)).to eql Yaks::Serializer::Hal }
+    specify { expect(Yaks::Serializer.by_name(:json_api)).to eql Yaks::Serializer::JsonApi }
+  end
+
+  describe '.by_mime_type' do
+    specify { expect(Yaks::Serializer.by_mime_type('application/hal+json')).to eql Yaks::Serializer::Hal }
+  end
+end

data/spec/unit/yaks/util_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+RSpec.describe Yaks::Util do
+  include Yaks::Util
+
+  describe '#Resolve' do
+    it 'should return non-proc-values' do
+      expect(Resolve('foo')).to eql 'foo'
+    end
+
+    it 'should resolve a proc' do
+      expect(Resolve(->{ 123 })).to eql 123
+    end
+
+    it 'should resolve the proc in the given context' do
+      expect(Resolve(->{ upcase }, 'foo')).to eql 'FOO'
+    end
+
+    it 'should resolve a proc without context in the context it was lexically defined' do
+      expect(Resolve(->{ self })).to be_a RSpec::Core::ExampleGroup
+    end
+
+    it 'should receive the context as an argument when it has an arity > 0' do
+      expect(Resolve(->(s){ s.upcase }, 'foo')).to eql 'FOO'
+    end
+
+    it 'should work with method objects' do
+      expect(Resolve('foo'.method(:upcase))).to eql 'FOO'
+    end
+  end
+
+  describe '#camelize' do
+    it 'should camelize' do
+      expect(camelize('foo_bar/baz')).to eql 'FooBar::Baz'
+    end
+  end
+
+  describe '#underscore' do
+    it 'should underscorize' do
+      expect(underscore('FooBar::Baz-Quz::Quux')).to eql 'foo_bar/baz__quz/quux'
+    end
+  end
+end

data/spec/yaml/confucius.yaml

@@ -0,0 +1,10 @@
+--- !ruby/object:Scholar
+id: 9
+name: "孔子"
+pinyin: "Kongzi"
+latinized: "Confucius"
+works:
+  - !ruby/object:Work
+    id: 11
+    chinese_name: "論語"
+    english_name: "Analects"

data/spec/yaml/youtypeitwepostit.yaml

@@ -0,0 +1,9 @@
+---
+- !ruby/object:Youtypeitwepostit::Message
+  id: 12091295723803341
+  text: "massage"
+  date_posted: "2014-05-29T07:56:58.035Z"
+- !ruby/object:Youtypeitwepostit::Message
+  id: 613856331910938
+  text: "Squid!"
+  date_posted: "2013-03-28T21:51:08.406Z"

data/yaks.gemspec

@@ -7,7 +7,7 @@ Gem::Specification.new do |gem|
   gem.version     = Yaks::VERSION
   gem.authors     = [ 'Arne Brasseur' ]
   gem.email       = [ 'arne@arnebrasseur.net' ]
-  gem.description = 'Serialize to JSON-API and similar'
+  gem.description = 'Serialize to hypermedia. HAL, JSON-API, etc.'
   gem.summary     = gem.description
   gem.homepage    = 'https://github.com/plexus/yaks'
   gem.license     = 'MIT'
@@ -17,15 +17,14 @@ Gem::Specification.new do |gem|
   gem.test_files       = `git ls-files -- spec`.split($/)
   gem.extra_rdoc_files = %w[README.md]
 
-  gem.add_runtime_dependency 'hamster'
-  gem.add_runtime_dependency 'inflection'   , '~> 1.0.0' #  12k , flog:  226.8
-  gem.add_runtime_dependency 'concord'      , '~> 0.1.4' #   8k , flog:   62.3
-  gem.add_runtime_dependency 'uri_template' , '~> 0.6.0' # 104k , flog: 1521.4
-
-  # For comparison, ActiveSupport has a flog score of 11134.7
+  gem.add_runtime_dependency 'inflection'   , '~> 1.0'
+  gem.add_runtime_dependency 'concord'      , '~> 0.1.4'
+  gem.add_runtime_dependency 'uri_template' , '~> 0.6.0'
+  gem.add_runtime_dependency 'rack-accept'  , '~> 0.4.5'
 
   gem.add_development_dependency 'virtus'
-  gem.add_development_dependency 'rspec', '~> 2.14'
+  gem.add_development_dependency 'rspec', '~> 3.0'
   gem.add_development_dependency 'rake'
   gem.add_development_dependency 'mutant-rspec'
+  gem.add_development_dependency 'rspec-its'
 end