yaks 0.9.0 → 0.10.0

data/spec/unit/yaks/configurable_spec.rb

@@ -1,5 +1,5 @@
 class Kitten
-  include Yaks::Attributes.new(:furriness)
+  include Attribs.new(:furriness)
 
   def self.create(opts, &block)
     level = opts[:fur_level]
@@ -9,7 +9,7 @@ class Kitten
 end
 
 class Hanky
-  include Yaks::Attributes.new(:stickyness, :size, :color)
+  include Attribs.new(:stickyness, :size, :color)
 
   def self.create(sticky, opts = {})
     new(stickyness: sticky, size: opts[:size], color: opts[:color])
@@ -19,13 +19,29 @@ end
 RSpec.describe Yaks::Configurable do
   let(:suffix) { SecureRandom.hex(16) }
   subject do
-    eval %Q<
+    # rubocop:disable Lint/Eval
+    eval %<
 class TestConfigurable#{suffix}
   class Config
-    include Yaks::Attributes.new(color: 'blue', taste: 'sour', contents: [])
+    include Attribs.new(color: 'blue', taste: 'sour', contents: [])
+
+    def turn_into_orange
+      with(color: 'orange', taste: 'like an orange')
+    end
+
+    def turn_into_apple
+      with(color: 'green', taste: 'like an apple')
+    end
+
+    def with_color_and_contents(color)
+      with(color: color, contents: yield(contents))
+    end
   end
   extend Yaks::Configurable
 
+  def_set :color, :taste
+  def_forward :turn_into_apple, :turn_into_orange, :with_color_and_contents
+  def_forward appleize: :turn_into_apple
   def_add :kitten, create: Kitten, append_to: :contents, defaults: {fur_level: 7}
   def_add :cat, create: Kitten, append_to: :contents
   def_add :hanky, create: Hanky, append_to: :contents, defaults: {size: 12, color: :red}
@@ -57,7 +73,7 @@ end
     end
 
     it 'should pass on a block' do
-      subject.cat(fur_level: 3) {|l| l+3}
+      subject.cat(fur_level: 3) {|l| l + 3}
       expect(subject.config.contents).to eql [Kitten.new(furriness: 6)]
     end
 
@@ -72,13 +88,56 @@ end
     end
   end
 
-
   describe '#def_set' do
     it 'should set' do
+      subject.color 'red'
+      expect(subject.config.color).to eql 'red'
+    end
+
+    it 'should capture blocks as closures' do
+      subject.color {|x| "#{x} blue"}
+      expect(subject.config.color.call("dark")).to eql 'dark blue'
+    end
+
+    it 'should signal when called without arguments' do
+      expect { subject.color }.to raise_error(ArgumentError, "setting color: no value and no block given")
+    end
+
+    it 'is an error when both a value and a block are passed in' do
+      expect { subject.color('red') {'blue'} }.to raise_error(ArgumentError, "ambiguous invocation setting color: give either a value or a block, not both.")
     end
   end
+
   describe '#def_forward' do
-    it 'should forward' do
+    it 'should generate a method that delegates to the config instance - first position' do
+      subject.turn_into_orange
+      expect(subject.config.color).to eql 'orange'
+    end
+
+    it 'should generate a method that delegates to the config instance - last position' do
+      subject.turn_into_apple
+      expect(subject.config.color).to eql 'green'
+    end
+
+    it 'should work with a hash for mappings' do
+      subject.appleize
+      expect(subject.config.color).to eql 'green'
+    end
+
+    it 'should forward arguments and block' do
+      subject.with_color_and_contents('brown') do |contents|
+        contents + [1, 2, 3]
+      end
+
+      expect(subject.config.color).to eql 'brown'
+      expect(subject.config.contents).to eql [1, 2, 3]
+    end
+  end
+
+  describe '#inherited' do
+    it 'should propagate the config state' do
+      subject.appleize
+      expect(Class.new(subject).config.color).to eql 'green'
     end
   end
 end

data/spec/unit/yaks/default_policy/derive_mapper_from_collection_spec.rb

@@ -0,0 +1,47 @@
+RSpec.describe Yaks::DefaultPolicy, '#derive_mapper_from_collection' do
+  subject(:policy) { described_class.new(options) }
+
+  let(:options) { {} }
+
+  context 'given an empty array' do
+    it 'should return the vanilla CollectionMapper' do
+      expect(policy.derive_mapper_from_collection([])).to be Yaks::CollectionMapper
+    end
+  end
+
+  it 'should find the mapper based on naming' do
+    expect(policy.derive_mapper_from_collection([Soy.new])).to be SoyCollectionMapper
+  end
+
+  it 'should not care about the object module' do
+    expect(policy.derive_mapper_from_collection([Grain::Soy.new])).to be SoyCollectionMapper
+  end
+
+  context 'if no collection mapper with a similar name is defined' do
+    let(:options) { {namespace: Namespace} }
+
+    it 'should look for a CollectionMapper in the namespace' do
+      expect(policy.derive_mapper_from_collection([WildSoy.new])).to be(Namespace::CollectionMapper)
+    end
+
+    context 'when trying to lookup CollectionMapper results in something other than an NameError' do
+      let(:options) { {namespace: DislikesCollectionMapper} }
+
+      it 'should propagate the error' do
+        expect {
+          policy.derive_mapper_from_object([])
+        }.to raise_error
+      end
+    end
+
+    context 'when trying to lookup a specific collection mapper results in something other than an NameError' do
+      let(:options) { {namespace: DislikesOtherMappers} }
+
+      it 'should propagate the error' do
+        expect do
+          policy.derive_mapper_from_object([Namespace::Nested::Rye.new])
+        end.to raise_error
+      end
+    end
+  end
+end

data/spec/unit/yaks/default_policy/derive_mapper_from_item_spec.rb

@@ -0,0 +1,114 @@
+RSpec.describe Yaks::DefaultPolicy, '#derive_mapper_from_item' do
+  subject(:policy) { described_class.new(options) }
+
+  let(:options) { {} }
+
+  it 'should use const_get with second argument set to false' do
+    stub(Object).const_get(any_args) { SoyMapper }
+    policy.derive_mapper_from_item(Soy.new)
+    expect(Object).to have_received.const_get("SoyMapper", false)
+  end
+
+  context 'at top level' do
+    it 'should derive it by name' do
+      expect(policy.derive_mapper_from_item(Soy.new)).to be SoyMapper
+    end
+
+    it 'should look for parent class if not found' do
+      expect(policy.derive_mapper_from_item(WildSoy.new)).to be SoyMapper
+    end
+
+    context 'with namespace option set' do
+      let(:options) { {namespace: MyMappers} }
+
+      it 'should look inside the namespace' do
+        expect(policy.derive_mapper_from_item(Soy.new)).to be MyMappers::SoyMapper
+      end
+
+      it 'should look for its parent class mapper in the namespace if not found' do
+        expect(policy.derive_mapper_from_item(WildSoy.new)).to be MyMappers::SoyMapper
+      end
+    end
+  end
+
+  context 'inside a module' do
+    it 'should look inside the module' do
+      expect(policy.derive_mapper_from_item(Grain::Soy.new)).to be Grain::SoyMapper
+    end
+
+    it 'should look for its parent class mapper in the module if not found' do
+      expect(policy.derive_mapper_from_item(Grain::WildSoy.new)).to be Grain::SoyMapper
+    end
+
+    context 'no mapper defined in module' do
+      it 'should look for mapper outside module' do
+        expect(policy.derive_mapper_from_item(Grain::Wheat.new)).to be WheatMapper
+      end
+
+      it 'should look for its parent class mapper outside module' do
+        expect(policy.derive_mapper_from_item(Grain::Durum.new)).to be WheatMapper
+      end
+    end
+
+    context 'with namespace option set' do
+      let(:options) { {namespace: MyMappers} }
+
+      it 'should look inside the module' do
+        expect(policy.derive_mapper_from_item(Grain::Soy.new)).to be MyMappers::Grain::SoyMapper
+      end
+
+      it 'should look for its parent class mapper if not found' do
+        expect(policy.derive_mapper_from_item(Grain::WildSoy.new)).to be MyMappers::Grain::SoyMapper
+      end
+
+      context 'no mapper defined in module' do
+        it 'should look for mapper in namespace top level' do
+          expect(policy.derive_mapper_from_item(Grain::Wheat.new)).to be MyMappers::WheatMapper
+        end
+
+        it 'should look for its parent mapper in namespace top level' do
+          expect(policy.derive_mapper_from_item(Grain::Durum.new)).to be MyMappers::WheatMapper
+        end
+      end
+    end
+
+    context 'deeply nested module' do
+      it 'should look inside the module' do
+        expect(policy.derive_mapper_from_item(Grain::Dry::Soy.new)).to be Grain::Dry::SoyMapper
+      end
+    end
+  end
+
+  context 'when no mapper is found' do
+    it 'should give a nice message' do
+      expect do
+        policy.derive_mapper_from_item(Namespace::Nested::Mung.new)
+      end.to raise_error /Failed to find a mapper for #<Namespace::Nested::Mung:0x\h+>. Did you mean to implement Namespace::Nested::MungMapper\?/
+    end
+
+    context 'with namespace option specified' do
+      let(:options) { {namespace: MyMappers} }
+
+      it 'should give a nice message' do
+        expect do
+          policy.derive_mapper_from_item(Namespace::Nested::Rye.new)
+        end.to raise_error /Failed to find a mapper for #<Namespace::Nested::Rye:0x\h+>. Did you mean to implement MyMappers::Namespace::Nested::RyeMapper\?/
+      end
+    end
+  end
+
+  context 'Object instance' do
+    it 'return ObjectMapper' do
+      expect(policy.derive_mapper_from_item(Object.new)).to be ObjectMapper
+    end
+
+    context 'no mapper available' do
+      before { Object.send(:remove_const, "ObjectMapper") }
+      after  { Object::ObjectMapper = Class.new }
+
+      it 'raise error' do
+        expect { policy.derive_mapper_from_item(Object.new) }.to raise_error RuntimeError
+      end
+    end
+  end
+end

data/spec/unit/yaks/default_policy/derive_mapper_from_object_spec.rb

@@ -1,94 +1,52 @@
 RSpec.describe Yaks::DefaultPolicy, '#derive_mapper_from_object' do
-  subject(:policy) { described_class.new(options) }
-
-  let(:options) { {} }
+  subject(:policy) { described_class.new }
 
   context 'for a single instance' do
-    it 'should derive it by name' do
-      expect(policy.derive_mapper_from_object(Soy.new)).to be SoyMapper
-    end
-
-    context 'given a namespace' do
-      let(:options) { {namespace: MyMappers} }
+    let(:object) { Soy.new }
 
-      it 'should look inside the namespace' do
-        expect(policy.derive_mapper_from_object(Soy.new)).to be MyMappers::SoyMapper
-      end
+    it 'should call derive_mapper_for_item' do
+      stub(policy).derive_mapper_from_item(object) { SoyMapper }
+      policy.derive_mapper_from_object(object)
+      expect(policy).to have_received.derive_mapper_from_item(object)
     end
   end
 
   context 'for array-like objects' do
-    context 'given an empty array' do
-      it 'should return the vanilla CollectionMapper' do
-        expect(policy.derive_mapper_from_object([])).to be Yaks::CollectionMapper
-      end
-    end
+    let(:object) { [Soy.new] }
 
-    it 'should find the mapper based on naming' do
-      expect(policy.derive_mapper_from_object([Soy.new])).to be SoyCollectionMapper
-    end
-
-    context 'if no collection mapper with a similar name is defined' do
-      let(:options) { {namespace: Namespace} }
-
-      it 'should look for a CollectionMapper in the namespace' do
-        expect(policy.derive_mapper_from_object([Wheat.new])).to be(
-          Namespace::CollectionMapper
-        )
-      end
+    it 'should call derive_mapper_for_item' do
+      stub(policy).derive_mapper_from_collection(object) { SoyCollectionMapper }
+      policy.derive_mapper_from_object(object)
+      expect(policy).to have_received.derive_mapper_from_collection(object)
     end
   end
 
-  context 'for a model class inside a module' do
-    let(:options) { {namespace: Namespace} }
-
-    it 'should take the non-qualified classname, and search the mapper namespace with that' do
-      expect(policy.derive_mapper_from_object(Namespace::Nested::Rye.new)).to be(
-        Namespace::RyeMapper
-      )
-    end
-
-    it 'should take the non-qualified classname when looking for a collection mapper' do
-      expect(policy.derive_mapper_from_object([Namespace::Nested::Rye.new])).to be(
-        Namespace::RyeCollectionMapper
-      )
-    end
-  end
+  context 'mapper_for options set' do
+    subject(:policy) { described_class.new(options) }
 
-  context 'when trying to lookup CollectionMapper results in something other than an NameError' do
-    let(:options) { { namespace: DislikesCollectionMapper } }
+    context 'when mapping a class' do
+      let(:options) { {mapper_rules: {home: HomeMapper, Soy => MyMappers::WheatMapper}} }
 
-    it 'should propagate the error' do
-      expect {
-        policy.derive_mapper_from_object([])
-      }.to raise_error
+      it 'should use the mapping' do
+        expect(policy.derive_mapper_from_object(Soy.new)).to be MyMappers::WheatMapper
+      end
     end
-  end
 
-  context 'when trying to lookup a specific collection mapper results in something other than an NameError' do
-    let(:options) { { namespace: DislikesOtherMappers } }
+    context 'when mapping a symbol' do
+      let(:options) { {mapper_rules: {soy: SoyMapper}} }
 
-    it 'should propagate the error' do
-      expect {
-        policy.derive_mapper_from_object([Namespace::Nested::Rye.new])
-      }.to raise_error
+      it 'should use the mapping' do
+        expect(policy.derive_mapper_from_object(:soy)).to be SoyMapper
+      end
     end
-  end
-
-  context 'when a mapper exists for a superclass' do
-    let(:options) { {namespace: MyMappers} }
 
-    it 'should use the superclass mapper' do
-      expect(policy.derive_mapper_from_object(Namespace::Nested::Mung.new)).to be(MyMappers::BeanMapper)
-    end
-  end
+    context 'when mapping a lambda' do
+      let(:user) { fake(logged_in?: true) }
+      let(:options) { {mapper_rules: {->(user){ user.logged_in? } => SoyMapper}} }
 
-  context 'when no mapper is found' do
-    it 'should give a nice message' do
-      expect {
-        policy.derive_mapper_from_object(Namespace::Nested::Mung.new)
-      }.to raise_error /Failed to find a mapper for #<Namespace::Nested::Mung:0x\h+>. Did you mean to implement MungMapper\?/
+      it 'should use the mapping' do
+        expect(policy.derive_mapper_from_object(user)).to be SoyMapper
+      end
     end
   end
-
 end

data/spec/unit/yaks/default_policy_spec.rb

@@ -1,5 +1,5 @@
 RSpec.describe Yaks::DefaultPolicy do
-  subject(:policy) { described_class.new( options ) }
+  subject(:policy) { described_class.new(options) }
 
   let(:options) { {} }
   let(:association) { Yaks::Mapper::HasMany.create('shoes') }
@@ -12,7 +12,7 @@ RSpec.describe Yaks::DefaultPolicy do
     let(:options) { {foo: :bar} }
 
     it 'should merge default and given options' do
-      expect(policy.options.values_at(:namespace, :foo)).to eql [Kernel, :bar]
+      expect(policy.options.values_at(:namespace, :foo)).to eql [Object, :bar]
     end
   end
 
@@ -39,7 +39,7 @@ RSpec.describe Yaks::DefaultPolicy do
   end
 
   describe '#derive_mapper_from_association' do
-    let(:options) { { namespace: Namespace } }
+    let(:options) { {namespace: Namespace} }
 
     it 'should derive using the singular association name, and look inside the namespace' do
       expect(policy.derive_mapper_from_association(association)).to be Namespace::ShoeMapper
@@ -53,10 +53,9 @@ RSpec.describe Yaks::DefaultPolicy do
   end
 
   describe '#expand_rel' do
-    let(:options) { { rel_template: 'http://foo/{?rel}' } }
+    let(:options) { {rel_template: 'http://foo/{?rel}'} }
     it 'should expand the given template' do
       expect(policy.expand_rel('rockets')).to eql 'http://foo/?rel=rockets'
     end
   end
-
 end

data/spec/unit/yaks/format/collection_json_spec.rb

@@ -7,7 +7,7 @@ RSpec.describe Yaks::Format::CollectionJson do
     it { should deep_eql(load_json_fixture('plant_collection.collection')) }
   end
 
-  context '#links?' do
+  describe '#links?' do
     context 'when resource is not a collection' do
       let(:resource) {
         Yaks::Resource.new(
@@ -52,7 +52,7 @@ RSpec.describe Yaks::Format::CollectionJson do
     end
   end
 
-  context '#queries?' do
+  describe '#queries?' do
     let(:resource) {
       Yaks::Resource.new(
         attributes: {foo: 'fooval', bar: 'barval'},
@@ -124,7 +124,7 @@ RSpec.describe Yaks::Format::CollectionJson do
     end
   end
 
-  context '#template?' do
+  describe '#template?' do
     context 'when no template form has been specified' do
       let(:format) {
         described_class.new
@@ -144,14 +144,14 @@ RSpec.describe Yaks::Format::CollectionJson do
 
     context 'when a template form has been specified' do
       let(:format) {
-        described_class.new(:template => :template_form_name)
+        described_class.new(template: :template_form_name)
       }
 
       context 'and the form is not present' do
         let(:resource) {
           Yaks::Resource.new(
-          attributes: {foo: 'fooval', bar: 'barval'},
-          forms: [Yaks::Resource::Form.new(name: :not_the_form_name)]
+            attributes: {foo: 'fooval', bar: 'barval'},
+            forms: [Yaks::Resource::Form.new(name: :not_the_form_name)]
           )
         }
 
@@ -167,8 +167,8 @@ RSpec.describe Yaks::Format::CollectionJson do
       context 'and the form is present' do
         let(:resource) {
           Yaks::Resource.new(
-          attributes: {foo: 'fooval', bar: 'barval'},
-          forms: [Yaks::Resource::Form.new(name: :template_form_name)]
+            attributes: {foo: 'fooval', bar: 'barval'},
+            forms: [Yaks::Resource::Form.new(name: :template_form_name)]
           )
         }
 
@@ -183,7 +183,7 @@ RSpec.describe Yaks::Format::CollectionJson do
     end
   end
 
-  context 'serialize_links' do
+  describe '#serialize_links' do
     context 'without title' do
       let(:resource) {
         Yaks::Resource.new(
@@ -203,10 +203,10 @@ RSpec.describe Yaks::Format::CollectionJson do
             "items" => [
               {
                 "data" => [
-                  { "name"=>"foo", "value"=>"fooval" },
-                  { "name"=>"bar", "value"=>"barval" }
+                  {"name" => "foo", "value" => "fooval"},
+                  {"name" => "bar", "value" => "barval"}
                 ],
-                "links" => [{"rel"=>"the_rel", "href"=>"the_uri"}]
+                "links" => [{"rel" => "the_rel", "href" => "the_uri"}]
               }
             ]
           }
@@ -233,10 +233,10 @@ RSpec.describe Yaks::Format::CollectionJson do
             "items" => [
               {
                 "data" => [
-                  { "name"=>"foo", "value"=>"fooval" },
-                  { "name"=>"bar", "value"=>"barval" }
+                  {"name" => "foo", "value" => "fooval"},
+                  {"name" => "bar", "value" => "barval"}
                 ],
-                "links" => [{"name"=>"the_name", "rel"=>"the_rel", "href"=>"the_uri"}]
+                "links" => [{"name" => "the_name", "rel" => "the_rel", "href" => "the_uri"}]
               }
             ]
           }
@@ -245,7 +245,7 @@ RSpec.describe Yaks::Format::CollectionJson do
     end
   end
 
-  context 'serialize_queries' do
+  describe '#serialize_queries' do
     let(:resource) {
       Yaks::Resource.new(
         attributes: {foo: 'fooval', bar: 'barval'},
@@ -277,13 +277,13 @@ RSpec.describe Yaks::Format::CollectionJson do
               "items" => [
                 {
                   "data" => [
-                    { "name"=>"foo", "value"=>"fooval" },
-                    { "name"=>"bar", "value"=>"barval" }
+                    {"name" => "foo", "value" => "fooval"},
+                    {"name" => "bar", "value" => "barval"}
                   ]
                 }
               ],
               "queries" => [
-                { "href"=>"/foo", "rel"=>"search" }
+                {"href" => "/foo", "rel" => "search"}
               ]
             }
           )
@@ -315,17 +315,16 @@ RSpec.describe Yaks::Format::CollectionJson do
               "items" => [
                 {
                   "data" => [
-                    { "name"=>"foo", "value"=>"fooval" },
-                    { "name"=>"bar", "value"=>"barval" }
+                    {"name" => "foo", "value" => "fooval"},
+                    {"name" => "bar", "value" => "barval"}
                   ]
                 }
               ],
               "queries" => [
-                { "href"=>"/foo", "rel"=>"search", "prompt"=>"My query prompt",
-                  "data"=>
-                  [
-                    { "name"=>"foo", "value"=>"" },
-                    { "name"=>"bar", "value"=>"", "prompt"=>"My Bar Field" }
+                {"href" => "/foo", "rel" => "search", "prompt" => "My query prompt",
+                 "data" =>                   [
+                    {"name" => "foo", "value" => ""},
+                    {"name" => "bar", "value" => "", "prompt" => "My Bar Field"}
                   ]
                 }
               ]
@@ -336,9 +335,9 @@ RSpec.describe Yaks::Format::CollectionJson do
     end
   end
 
-  context 'serialize_template' do
+  describe '#serialize_template' do
     let(:format) {
-      described_class.new(:template => :form_for_new)
+      described_class.new(template: :form_for_new)
     }
 
     let(:resource) {
@@ -367,15 +366,15 @@ RSpec.describe Yaks::Format::CollectionJson do
             "items" => [
               {
                 "data" => [
-                  { "name"=>"foo", "value"=>"fooval" },
-                  { "name"=>"bar", "value"=>"barval" }
+                  {"name" => "foo", "value" => "fooval"},
+                  {"name" => "bar", "value" => "barval"}
                 ]
               }
             ],
             "template" => {
               "data" => [
-                { "name"=>"foo", "value"=>"", "prompt"=>"My Foo Field" },
-                { "name"=>"bar", "value"=>"", "prompt"=>"My Bar Field" }
+                {"name" => "foo", "value" => "", "prompt" => "My Foo Field"},
+                {"name" => "bar", "value" => "", "prompt" => "My Bar Field"}
               ]
             }
           }
@@ -398,15 +397,15 @@ RSpec.describe Yaks::Format::CollectionJson do
             "items" => [
               {
                 "data" => [
-                  { "name"=>"foo", "value"=>"fooval" },
-                  { "name"=>"bar", "value"=>"barval" }
+                  {"name" => "foo", "value" => "fooval"},
+                  {"name" => "bar", "value" => "barval"}
                 ]
               }
             ],
             "template" => {
               "data" => [
-                { "name"=>"foo", "value"=>"" },
-                { "name"=>"bar", "value"=>"" }
+                {"name" => "foo", "value" => ""},
+                {"name" => "bar", "value" => ""}
               ]
             }
           }