yaks 0.9.0 → 0.10.0

data/spec/unit/yaks/mapper_spec.rb

@@ -8,23 +8,30 @@ RSpec.describe Yaks::Mapper do
 
   let(:instance) { fake(foo: 'hello', bar: 'world') }
 
-  its(:env) { should equal rack_env }
+  describe "#initialize" do
+    it "should store the context" do
+      expect(mapper.context).to equal yaks_context
+    end
+  end
 
-  describe '#call' do
-    context 'with attributes' do
-      before do
-        mapper_class.attributes :foo, :bar
-      end
+  describe "#env" do
+    its(:env) { should equal rack_env }
+  end
+
+  describe "#policy" do
+    it "should pull it out of the context" do
+      expect(mapper.policy).to equal policy
+    end
+  end
 
+  describe '#call' do
+    shared_examples "a mapper with attributes" do
       it 'should make the configured attributes available on the instance' do
-        expect(mapper.attributes).to eq [
-          Yaks::Mapper::Attribute.new(:foo),
-          Yaks::Mapper::Attribute.new(:bar)
-        ]
+        expect(mapper.attributes).to eq attributes
       end
 
-      it 'should load them from the model' do
-        expect(resource.attributes).to eq(foo: 'hello', bar: 'world')
+      it 'should load attributes from the model' do
+        expect(resource.attributes).to eq(attributes_from_model)
       end
 
       context 'with attribute filtering' do
@@ -37,11 +44,55 @@ RSpec.describe Yaks::Mapper do
         end
 
         it 'should only map the non-filtered attributes' do
-          expect(resource.attributes).to eq(:bar => 'world')
+          expect(resource.attributes).to eq(non_filtered_attributes)
+        end
+      end
+    end
+
+    context "with attribute" do
+      let(:attributes) { [ Yaks::Mapper::Attribute.create(:foo) ] }
+      let(:attributes_from_model) { {foo: 'hello'} }
+      let(:non_filtered_attributes) { {} }
+
+      context "called without block" do
+        before do
+          mapper_class.attribute :foo
+        end
+
+        it_behaves_like "a mapper with attributes"
+      end
+
+      context "called with a block" do
+        let(:block) { proc { object.bar } }
+        let(:attributes) { [ Yaks::Mapper::Attribute.create(:foo, &block) ] }
+        let(:attributes_from_model) { {foo: 'world'} }
+
+        before do
+          mapper_class.attribute :foo, &block
         end
+
+        it_behaves_like "a mapper with attributes"
       end
     end
 
+    context 'with attributes' do
+      let(:attributes) do
+        [
+          Yaks::Mapper::Attribute.create(:foo),
+          Yaks::Mapper::Attribute.create(:bar)
+        ]
+      end
+
+      let(:attributes_from_model) { {foo: 'hello', bar: 'world'} }
+      let(:non_filtered_attributes) { {bar: 'world'} }
+
+      before do
+        mapper_class.attributes :foo, :bar
+      end
+
+      it_behaves_like "a mapper with attributes"
+    end
+
     context 'with links' do
       before do
         mapper_class.link :profile, 'http://foo/bar'
@@ -85,8 +136,8 @@ RSpec.describe Yaks::Mapper do
 
       describe 'has_one' do
         let(:has_one_opts) do
-          { mapper: widget_mapper,
-            rel: 'http://foo.bar/rels/widgets' }
+          {mapper: widget_mapper,
+           rel: 'http://foo.bar/rels/widgets'}
         end
 
         before do
@@ -94,22 +145,21 @@ RSpec.describe Yaks::Mapper do
           mapper_class.has_one(:widget, has_one_opts)
         end
 
-
         it 'should have the subresource in the resource' do
-          expect(resource.subresources).to eq([Yaks::Resource.new(type: 'widget', attributes: {:type => 'super_widget'}, rels: ['http://foo.bar/rels/widgets'])])
+          expect(resource.subresources).to eq([Yaks::Resource.new(type: 'widget', attributes: {type: 'super_widget'}, rels: ['http://foo.bar/rels/widgets'])])
         end
 
         context 'with explicit mapper and rel' do
           it 'should delegate to the given mapper' do
             expect(resource.subresources).to eq([
-              Yaks::Resource.new(type: 'widget', attributes: {:type => 'super_widget'}, rels: ['http://foo.bar/rels/widgets'])
+              Yaks::Resource.new(type: 'widget', attributes: {type: 'super_widget'}, rels: ['http://foo.bar/rels/widgets'])
             ])
           end
         end
 
         context 'with unspecified mapper' do
           let(:has_one_opts) do
-            { rel: 'http://foo.bar/rels/widgets' }
+            {rel: 'http://foo.bar/rels/widgets'}
           end
 
           before do
@@ -120,14 +170,14 @@ RSpec.describe Yaks::Mapper do
 
           it 'should derive the mapper based on policy' do
             expect(resource.subresources).to eq([
-              Yaks::Resource.new(type: 'widget', attributes: {:type => 'super_widget'}, rels: ['http://foo.bar/rels/widgets'])
+              Yaks::Resource.new(type: 'widget', attributes: {type: 'super_widget'}, rels: ['http://foo.bar/rels/widgets'])
             ])
           end
         end
 
         context 'with unspecified rel' do
           let(:has_one_opts) do
-            { mapper: widget_mapper }
+            {mapper: widget_mapper}
           end
 
           before do
@@ -138,7 +188,7 @@ RSpec.describe Yaks::Mapper do
 
           it 'should derive the rel based on policy' do
             expect(resource.subresources).to eq([
-              Yaks::Resource.new(type: 'widget', attributes: {:type => 'super_widget'}, rels: ['http://rel/rel'])
+              Yaks::Resource.new(type: 'widget', attributes: {type: 'super_widget'}, rels: ['http://rel/rel'])
             ])
           end
         end
@@ -226,6 +276,9 @@ RSpec.describe Yaks::Mapper do
       end
     end
 
+    it "should optionally take a rack env" do
+      expect { mapper.call(fake, {}) }.to_not raise_error
+    end
   end # describe '#call'
 
   describe '.mapper_name' do
@@ -283,7 +336,7 @@ RSpec.describe Yaks::Mapper do
     let(:attribute) { fake('Attribute') }
 
     it 'should receive a context' do
-      stub(attribute).add_to_resource(any_args) {|r,_,_| Yaks::Resource.new}
+      stub(attribute).add_to_resource(any_args) {|_r, _, _| Yaks::Resource.new}
 
       mapper.config.attributes[0..-1] = [attribute]
       mapper.call(instance)
@@ -294,7 +347,7 @@ RSpec.describe Yaks::Mapper do
 
   shared_examples 'something that can be added to a resource' do
     it 'should receive a context' do
-      stub(object).add_to_resource(any_args) {|r,_,_| Yaks::Resource.new}
+      stub(object).add_to_resource(any_args) {|_r, _, _| Yaks::Resource.new}
 
       mapper.call(instance)
 
@@ -314,6 +367,12 @@ RSpec.describe Yaks::Mapper do
     it_should_behave_like 'something that can be added to a resource'
   end
 
+  describe "#map_forms" do
+    let(:object) { fake('Form') }
+    before { mapper_class.config = mapper.config.append_to(:forms, object) }
+    it_should_behave_like "something that can be added to a resource"
+  end
+
   describe '#mapper_stack' do
     let(:yaks_context) { super().merge(mapper_stack: [:foo]) }
 
@@ -322,14 +381,36 @@ RSpec.describe Yaks::Mapper do
     end
   end
 
+  describe "#expand_value" do
+    it "should immediately return plain values" do
+      expect(mapper.expand_value(:foo)).to equal :foo
+    end
+
+    it "should resolve lambdas in the context of the mapper" do
+      expect(mapper.expand_value(->{ self })).to be_a Yaks::Mapper
+    end
+  end
+
   describe '#expand_uri' do
     let(:template) { '/foo/bar/{x}/{y}' }
-    let(:expand)   { true }
+    let(:expand) { true }
+    let(:args) { [template, expand] }
 
-    subject(:expanded) { mapper.expand_uri(template, expand) }
+    subject(:expanded) { mapper.expand_uri(*args) }
 
     before do
-      mapper.call( Struct.new(:x, :y) { def foo ; '/foo/foo' ; end }.new(6, 7) )
+      mapper.call(Struct.new(:x, :y) {
+        def foo
+          '/foo/foo'
+        end
+      }.new(6, 7))
+    end
+
+    context "with full expansion" do
+      let(:args) { [template] }
+      it "should expand all template variables" do
+        expect(expanded).to eq "/foo/bar/6/7"
+      end
     end
 
     context 'with expansion turned off' do
@@ -341,7 +422,7 @@ RSpec.describe Yaks::Mapper do
     end
 
     context 'with a URI without expansion variables' do
-      let(:template) { '/orders' }
+      let(:args) { ['/orders'] }
 
       it 'should return the link as is' do
         expect(expanded).to eq '/orders'
@@ -357,12 +438,19 @@ RSpec.describe Yaks::Mapper do
     end
 
     context 'with a symbol for a template' do
-      let(:template) { -> { object.foo } }
+      let(:args) { [->{ object.foo }] }
 
       it 'should use the lookup mechanism for finding the link' do
         expect(expanded).to eq '/foo/foo'
       end
     end
-  end
 
+    context "with a nil uri" do
+      let(:args) { [nil] }
+
+      it "should return nil" do
+        expect(expanded).to be_nil
+      end
+    end
+  end
 end

data/spec/unit/yaks/null_resource_spec.rb

@@ -1,88 +1,119 @@
 RSpec.describe Yaks::NullResource do
   subject(:null_resource) { described_class.new }
 
-  its(:attributes)     { should eql({}) }
-  its(:links)          { should eql [] }
-  its(:rels)           { should eql [] }
-  its(:subresources)   { should eql [] }
-  its(:collection?)    { should be false }
-  its(:null_resource?) { should be true }
-  its(:seq)            { should eql [] }
-
-  it { should respond_to :[] }
+  describe '#initialize' do
+    it 'should have defaults for everything' do
+      expect(described_class.new.to_h).to eql(
+        type: nil,
+        rels: [],
+        links: [],
+        attributes: {},
+        subresources: [],
+        forms: [],
+        collection: false
+      )
+    end
 
-  its(:type) { should be_nil }
+    it 'should allow setting rels' do
+      expect(described_class.new(rels: [:self]).rels).to eql [:self]
+    end
 
-  describe '#each' do
-    its(:each) { should be_a Enumerator }
+    it 'should allow setting the collection flag' do
+      expect(described_class.new(collection: true).collection).to be true
+    end
 
-    it 'should not yield anything' do
-      null_resource.each { fail }
+    it 'should not allow attributes in the contstructor' do
+      expect(described_class.new(attributes: {foo: :bar}).attributes).to eql({})
     end
   end
 
-  it 'should contain nothing' do
-    expect( null_resource[:key] ).to be_nil
+  describe "#attributes" do
+    its(:attributes) { should eql({}) }
   end
 
-  context 'when a collection' do
-    subject(:null_resource) { described_class.new( collection: true ) }
-    its(:collection?) { should be true }
+  describe "#links" do
+    its(:links) { should eql [] }
   end
 
-  it 'should not allow updating attributes' do
-    expect { null_resource.merge_attributes({}) }.to raise_error(
-      Yaks::UnsupportedOperationError, "Operation merge_attributes not supported on Yaks::NullResource"
-    )
+  describe "#rels" do
+    its(:rels) { should eql [] }
   end
 
-  it 'should not allow adding links' do
-    expect { null_resource.add_link(nil) }.to raise_error(
-      Yaks::UnsupportedOperationError, "Operation add_link not supported on Yaks::NullResource"
-    )
+  describe "#subresources" do
+    its(:subresources) { should eql [] }
   end
 
-  it 'should not allow adding forms' do
-    expect { null_resource.add_form(nil) }.to raise_error(
-      Yaks::UnsupportedOperationError, "Operation add_form not supported on Yaks::NullResource"
-    )
+  describe "#collection?" do
+    its(:collection?) { should be false }
+
+    context 'when a collection' do
+      subject(:null_resource) { described_class.new(collection: true) }
+      its(:collection?) { should be true }
+    end
   end
 
-  it 'should not allow adding subresources' do
-    expect { null_resource.add_subresource(nil) }.to raise_error(
-      Yaks::UnsupportedOperationError, "Operation add_subresource not supported on Yaks::NullResource"
-    )
+  describe "#null_resource?" do
+    its(:null_resource?) { should be true }
   end
 
-  describe '#initialize' do
-    it 'should have defaults for everything' do
-      expect( described_class.new.to_h ).to eql({
-        type: nil,
-        rels: [],
-        links: [],
-        attributes: {},
-        subresources: [],
-        forms: [],
-        collection: false})
+  describe "#seq" do
+    its(:seq) { should eql [] }
+  end
+
+  describe "#[]" do
+    it 'should contain nothing' do
+      expect(null_resource[:key]).to be_nil
     end
+  end
 
-    it 'should allow setting rels' do
-      expect( described_class.new(rels: [:self]).rels ).to eql [:self]
+  describe "#type" do
+    its(:type) { should be_nil }
+  end
+
+  describe '#each' do
+    its(:each) { should be_a Enumerator }
+
+    it 'should not yield anything' do
+      null_resource.each { raise }
     end
+  end
 
-    it 'should allow setting the collection flag' do
-      expect( described_class.new(collection: true).collection ).to be true
+  describe "#merge_attributes" do
+    it 'should not allow updating attributes' do
+      expect { null_resource.merge_attributes({}) }.to raise_error(
+        Yaks::UnsupportedOperationError, "Operation merge_attributes not supported on Yaks::NullResource"
+      )
     end
+  end
 
-    it 'should not allow attributes in the contstructor' do
-      expect( described_class.new(attributes: {foo: :bar}).attributes ).to eql({})
+  describe "#add_link" do
+    it 'should not allow adding links' do
+      expect { null_resource.add_link(nil) }.to raise_error(
+        Yaks::UnsupportedOperationError, "Operation add_link not supported on Yaks::NullResource"
+      )
+    end
+  end
+
+  describe "#add_form" do
+    it 'should not allow adding forms' do
+      expect { null_resource.add_form(nil) }.to raise_error(
+        Yaks::UnsupportedOperationError, "Operation add_form not supported on Yaks::NullResource"
+      )
+    end
+  end
+
+  describe "#add_subresource" do
+    it 'should not allow adding subresources' do
+      expect { null_resource.add_subresource(nil) }.to raise_error(
+        Yaks::UnsupportedOperationError, "Operation add_subresource not supported on Yaks::NullResource"
+      )
     end
   end
 
   describe '#map' do
     context 'when a collection' do
       it 'should always return []' do
-        expect( described_class.new(collection: true).map{} ).to eql []
+        expect(described_class.new(collection: true).map{}).to eql []
       end
     end
 

data/spec/unit/yaks/pipeline_spec.rb

@@ -2,12 +2,12 @@ RSpec.describe Yaks::Pipeline do
   subject(:pipeline) { described_class.new(steps) }
   let(:steps) {
     [
-      [:step1, ->(i, e) { i + 1 }],
-      [:step2, ->(i, e) { i + 10 }],
-      [:step3, ->(i, e) { i + e[:foo] }],
+      [:step1, ->(i, _e) { i + 1 }],
+      [:step2, ->(i, _e) { i + 10 }],
+      [:step3, ->(i, e) { i + e[:foo] }]
     ]
   }
-  let(:env) {{ foo: 100 }}
+  let(:env) {{foo: 100}}
 
   describe '#call' do
     it 'should call steps in turn, passing in the last result and env' do
@@ -19,7 +19,7 @@ RSpec.describe Yaks::Pipeline do
     let(:hooks)   { [] }
 
     describe 'before' do
-      let(:hooks) { [[:before, :step2, :before_step2, ->(i, e) { i - (i % 100) }]] }
+      let(:hooks) { [[:before, :step2, :before_step2, ->(i, _e) { i - (i % 100) }]] }
 
       it 'should insert a hook before the step' do
         expect(pipeline.insert_hooks(hooks).call(1000, env)).to equal 1110
@@ -27,7 +27,7 @@ RSpec.describe Yaks::Pipeline do
     end
 
     describe 'after' do
-      let(:hooks) { [[:after, :step2, :after_step2, ->(i, e) { i - (i % 100) }]] }
+      let(:hooks) { [[:after, :step2, :after_step2, ->(i, _e) { i - (i % 100) }]] }
 
       it 'should insert a hook after the step' do
         expect(pipeline.insert_hooks(hooks).call(1000, env)).to equal 1100
@@ -53,7 +53,7 @@ RSpec.describe Yaks::Pipeline do
     describe 'multiple hooks' do
       let(:hooks) {
         [
-          [:after, :step2, :after_step2, ->(i, e) { i % 10 }],
+          [:after, :step2, :after_step2, ->(i, _e) { i % 10 }],
           [:skip, :step3]
         ]
       }
@@ -65,76 +65,103 @@ RSpec.describe Yaks::Pipeline do
 
     it 'should return a pipeline with the right step names' do
       expect(pipeline
-              .insert_hooks([[:before, :step2, :step1_1, ->(i, e) { i+1 }]])
-              .insert_hooks([[:before, :step1_1, :step1_0, ->(i, e) { i+10 }]])
-              .insert_hooks([[:after,  :step1_1, :step1_2, ->(i, e) { i+100 }]])
-              .insert_hooks([[:around, :step1_1, :step1_1_0, ->(i, e, &b) { b.call(i, e)+1000 }]])
-              .insert_hooks([[:around, :step1_2, :step1_3, ->(i, e, &b) { b.call(i, e)+1000 }]])
-              .insert_hooks([[:after,  :step1_3, :step1_4, ->(i, e) { i + 10000 }]])
+              .insert_hooks([[:before, :step2, :step1_1, ->(i, _e) { i + 1 }]])
+              .insert_hooks([[:before, :step1_1, :step1_0, ->(i, _e) { i + 10 }]])
+              .insert_hooks([[:after,  :step1_1, :step1_2, ->(i, _e) { i + 100 }]])
+              .insert_hooks([[:around, :step1_1, :step1_1_0, ->(i, e, &b) { b.call(i, e) + 1000 }]])
+              .insert_hooks([[:around, :step1_2, :step1_3, ->(i, e, &b) { b.call(i, e) + 1000 }]])
+              .insert_hooks([[:after,  :step1_3, :step1_4, ->(i, _e) { i + 10_000 }]])
               .call(1000, env)
-            ).to equal 13222
+            ).to equal 13_222
     end
+  end
+
+  let(:fake_step) {
+    Class.new do
+      include Attribs.new(:transitive, :call, inverse: nil)
+      alias_method :transitive?, :transitive
+    end
+  }
+
+  let(:transitive_step) {
+    fake_step.new(transitive: true, inverse: ->(_x, _env) {}, call: "t")
+  }
+
+  let(:intransitive_step) {
+    fake_step.new(transitive: false, call: "i")
+  }
 
+  subject(:pipeline) { described_class.new(steps) }
+
+  describe '#transitive?' do
+    context 'with transitive steps' do
+      let(:steps) { [[:name1, transitive_step]] }
+      it 'should be transitive' do
+        expect(pipeline.transitive?).to be true
+      end
+    end
   end
-end
 
+  describe '#inverse' do
+  end
+end
 
-    # describe 'after' do
-    #   let(:hooks) { proc { after(:format) { :after_format_impl } } }
-
-    #   it 'should insert a hook after the step' do
-    #     expect(runner.steps.map(&:first)).to eql [
-    #       :map, :format, :after_format, :primitivize, :serialize
-    #     ]
-    #     expect(runner.steps[1].last).to be runner.formatter
-    #     expect(runner.steps[2].last.call).to be :after_format_impl
-    #   end
-    # end
-
-    # describe 'around' do
-    #   let(:hooks) do
-    #     proc {
-    #       around(:serialize) do |res, env, &block|
-    #         "serialized[#{env}][#{block.call(res, env)}]"
-    #       end
-    #     }
-    #   end
-
-    #   it 'should insert a hook around the step' do
-    #     expect(runner.steps.map(&:first)).to eql [
-    #       :map, :format, :primitivize, :serialize
-    #     ]
-    #     expect(runner.steps.assoc(:serialize).last.call(["res1"], "env1")).to eql(
-    #       "serialized[env1][[\n  \"res1\"\n]]"
-    #     )
-    #   end
-    # end
-
-    # describe 'around' do
-    #   let(:hooks) { ->(*) { skip(:serialize) } }
-
-    #   it 'should skip a certain step' do
-    #     expect(runner.steps.map(&:first)).to eql [
-    #       :map, :format, :primitivize
-    #     ]
-    #   end
-    # end
-
-    # describe 'multiple hooks' do
-    #   let(:hooks) {
-    #     proc {
-    #       after(:format) { :after_format_impl }
-    #       skip(:serialize)
-    #     }
-    #   }
-
-    #   it 'should insert the hooks' do
-    #     expect(runner.steps.map(&:first)).to eql [
-    #       :map, :format, :after_format, :primitivize
-    #     ]
-    #   end
-
-    #   it 'should pass on unchanged steps' do
-    #     expect(runner.steps.assoc(:map)[1]).to eql runner.mapper
-    #   end
-    # end
+# describe 'after' do
+#   let(:hooks) { proc { after(:format) { :after_format_impl } } }
+
+#   it 'should insert a hook after the step' do
+#     expect(runner.steps.map(&:first)).to eql [
+#       :map, :format, :after_format, :primitivize, :serialize
+#     ]
+#     expect(runner.steps[1].last).to be runner.formatter
+#     expect(runner.steps[2].last.call).to be :after_format_impl
+#   end
+# end
+
+# describe 'around' do
+#   let(:hooks) do
+#     proc {
+#       around(:serialize) do |res, env, &block|
+#         "serialized[#{env}][#{block.call(res, env)}]"
+#       end
+#     }
+#   end
+
+#   it 'should insert a hook around the step' do
+#     expect(runner.steps.map(&:first)).to eql [
+#       :map, :format, :primitivize, :serialize
+#     ]
+#     expect(runner.steps.assoc(:serialize).last.call(["res1"], "env1")).to eql(
+#       "serialized[env1][[\n  \"res1\"\n]]"
+#     )
+#   end
+# end
+
+# describe 'around' do
+#   let(:hooks) { ->(*) { skip(:serialize) } }
+
+#   it 'should skip a certain step' do
+#     expect(runner.steps.map(&:first)).to eql [
+#       :map, :format, :primitivize
+#     ]
+#   end
+# end
+
+# describe 'multiple hooks' do
+#   let(:hooks) {
+#     proc {
+#       after(:format) { :after_format_impl }
+#       skip(:serialize)
+#     }
+#   }
+
+#   it 'should insert the hooks' do
+#     expect(runner.steps.map(&:first)).to eql [
+#       :map, :format, :after_format, :primitivize
+#     ]
+#   end
+
+#   it 'should pass on unchanged steps' do
+#     expect(runner.steps.assoc(:map)[1]).to eql runner.mapper
+#   end
+# end