drape 1.0.0.beta1

data/spec/draper/factory_spec.rb

@@ -0,0 +1,250 @@
+require 'spec_helper'
+
+module Drape
+  describe Factory do
+    describe '#initialize' do
+      it 'accepts valid options' do
+        valid_options = { with: Decorator, context: { foo: 'bar' } }
+        expect { Factory.new(valid_options) }.not_to raise_error
+      end
+
+      it 'rejects invalid options' do
+        expect { Factory.new(foo: 'bar') }.to raise_error ArgumentError, /Unknown key/
+      end
+    end
+
+    describe '#decorate' do
+      context 'when object is nil' do
+        it 'returns nil' do
+          factory = Factory.new
+
+          expect(factory.decorate(nil)).to be_nil
+        end
+      end
+
+      it 'calls a worker' do
+        factory = Factory.new
+        worker = ->(*) { :decorated }
+
+        Factory::Worker.should_receive(:new).and_return(worker)
+        expect(factory.decorate(double)).to be :decorated
+      end
+
+      it 'passes the object to the worker' do
+        factory = Factory.new
+        object = double
+
+        Factory::Worker.should_receive(:new).with(anything, object).and_return(->(*) {})
+        factory.decorate(object)
+      end
+
+      context 'when the :with option was given' do
+        it 'passes the decorator class to the worker' do
+          decorator_class = double
+          factory = Factory.new(with: decorator_class)
+
+          Factory::Worker.should_receive(:new).with(decorator_class, anything).and_return(->(*) {})
+          factory.decorate(double)
+        end
+      end
+
+      context 'when the :with option was omitted' do
+        it 'passes nil to the worker' do
+          factory = Factory.new
+
+          Factory::Worker.should_receive(:new).with(nil, anything).and_return(->(*) {})
+          factory.decorate(double)
+        end
+      end
+
+      it 'passes options to the call' do
+        factory = Factory.new
+        worker = ->(*) {}
+        Factory::Worker.stub new: worker
+        options = { foo: 'bar' }
+
+        worker.should_receive(:call).with(options)
+        factory.decorate(double, options)
+      end
+
+      context 'when the :context option was given' do
+        it 'sets the passed context' do
+          factory = Factory.new(context: { foo: 'bar' })
+          worker = ->(*) {}
+          Factory::Worker.stub new: worker
+
+          worker.should_receive(:call).with(baz: 'qux', context: { foo: 'bar' })
+          factory.decorate(double, { baz: 'qux' })
+        end
+
+        it 'is overridden by explicitly-specified context' do
+          factory = Factory.new(context: { foo: 'bar' })
+          worker = ->(*) {}
+          Factory::Worker.stub new: worker
+
+          worker.should_receive(:call).with(context: { baz: 'qux' })
+          factory.decorate(double, context: { baz: 'qux' })
+        end
+      end
+    end
+  end
+
+  describe Factory::Worker do
+    describe '#call' do
+      it 'calls the decorator method' do
+        object = double
+        options = { foo: 'bar' }
+        worker = Factory::Worker.new(double, object)
+        decorator = ->(*) {}
+        allow(worker).to receive(:decorator) { decorator }
+
+        decorator.should_receive(:call).with(object, options).and_return(:decorated)
+        expect(worker.call(options)).to be :decorated
+      end
+
+      context 'when the :context option is callable' do
+        it 'calls it' do
+          worker = Factory::Worker.new(double, double)
+          decorator = ->(*) {}
+          worker.stub decorator: decorator
+          context = { foo: 'bar' }
+
+          decorator.should_receive(:call).with(anything, context: context)
+          worker.call(context: -> { context })
+        end
+
+        it 'receives arguments from the :context_args option' do
+          worker = Factory::Worker.new(double, double)
+          worker.stub decorator: ->(*) {}
+          context = -> {}
+
+          context.should_receive(:call).with(:foo, :bar)
+          worker.call(context: context, context_args: [:foo, :bar])
+        end
+
+        it 'wraps non-arrays passed to :context_args' do
+          worker = Factory::Worker.new(double, double)
+          worker.stub decorator: ->(*) {}
+          context = -> {}
+          hash = { foo: 'bar' }
+
+          context.should_receive(:call).with(hash)
+          worker.call(context: context, context_args: hash)
+        end
+      end
+
+      context 'when the :context option is not callable' do
+        it "doesn't call it" do
+          worker = Factory::Worker.new(double, double)
+          decorator = ->(*) {}
+          worker.stub decorator: decorator
+          context = { foo: 'bar' }
+
+          decorator.should_receive(:call).with(anything, context: context)
+          worker.call(context: context)
+        end
+      end
+
+      it 'does not pass the :context_args option to the decorator' do
+        worker = Factory::Worker.new(double, double)
+        decorator = ->(*) {}
+        worker.stub decorator: decorator
+
+        decorator.should_receive(:call).with(anything, foo: 'bar')
+        worker.call(foo: 'bar', context_args: [])
+      end
+    end
+
+    describe '#decorator' do
+      context 'for a singular object' do
+        context 'when decorator_class is specified' do
+          it 'returns the .decorate method from the decorator' do
+            decorator_class = Class.new(Decorator)
+            worker = Factory::Worker.new(decorator_class, double)
+
+            expect(worker.decorator).to eq decorator_class.method(:decorate)
+          end
+        end
+
+        context 'when decorator_class is unspecified' do
+          context 'and the object is decoratable' do
+            it "returns the object's #decorate method" do
+              object = double
+              options = { foo: 'bar' }
+              worker = Factory::Worker.new(nil, object)
+
+              object.should_receive(:decorate).with(options).and_return(:decorated)
+              expect(worker.decorator.call(object, options)).to be :decorated
+            end
+          end
+
+          context 'and the object is not decoratable' do
+            it 'raises an error' do
+              object = double
+              worker = Factory::Worker.new(nil, object)
+
+              expect { worker.decorator }.to raise_error UninferrableDecoratorError
+            end
+          end
+        end
+
+        context 'when the object is a struct' do
+          it 'returns a singular decorator' do
+            object = Struct.new(:stuff).new('things')
+
+            decorator_class = Class.new(Decorator)
+            worker = Factory::Worker.new(decorator_class, object)
+
+            expect(worker.decorator).to eq decorator_class.method(:decorate)
+          end
+        end
+      end
+
+      context 'for a collection object' do
+        context 'when decorator_class is a CollectionDecorator' do
+          it 'returns the .decorate method from the collection decorator' do
+            decorator_class = Class.new(CollectionDecorator)
+            worker = Factory::Worker.new(decorator_class, [])
+
+            expect(worker.decorator).to eq decorator_class.method(:decorate)
+          end
+        end
+
+        context 'when decorator_class is a Decorator' do
+          it 'returns the .decorate_collection method from the decorator' do
+            decorator_class = Class.new(Decorator)
+            worker = Factory::Worker.new(decorator_class, [])
+
+            expect(worker.decorator).to eq decorator_class.method(:decorate_collection)
+          end
+        end
+
+        context 'when decorator_class is unspecified' do
+          context 'and the object is decoratable' do
+            it "returns the .decorate_collection method from the object's decorator" do
+              object = []
+              decorator_class = Class.new(Decorator)
+              allow(object).to receive(:decorator_class) { decorator_class }
+              allow(object).to receive(:decorate) { nil }
+              worker = Factory::Worker.new(nil, object)
+
+              decorator_class
+                  .should_receive(:decorate_collection).with(object, foo: 'bar', with: nil)
+                  .and_return(:decorated)
+
+              expect(worker.decorator.call(object, foo: 'bar')).to be :decorated
+            end
+          end
+
+          context 'and the object is not decoratable' do
+            it 'returns the .decorate method from CollectionDecorator' do
+              worker = Factory::Worker.new(nil, [])
+
+              expect(worker.decorator).to eq CollectionDecorator.method(:decorate)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/draper/finders_spec.rb

@@ -0,0 +1,165 @@
+require 'spec_helper'
+
+module Drape
+  describe Finders do
+    protect_class ProductDecorator
+    before { ProductDecorator.decorates_finders }
+
+    describe '.find' do
+      it 'proxies to the model class' do
+        Product.should_receive(:find).with(1)
+        ProductDecorator.find(1)
+      end
+
+      it 'decorates the result' do
+        found = Product.new
+        Product.stub(:find).and_return(found)
+        decorator = ProductDecorator.find(1)
+        expect(decorator).to be_a ProductDecorator
+        expect(decorator.object).to be found
+      end
+
+      it 'passes context to the decorator' do
+        Product.stub(:find)
+        context = { some: 'context' }
+        decorator = ProductDecorator.find(1, context: context)
+
+        expect(decorator.context).to be context
+      end
+    end
+
+    describe '.find_by_(x)' do
+      it 'proxies to the model class' do
+        Product.should_receive(:find_by_name).with('apples')
+        ProductDecorator.find_by_name('apples')
+      end
+
+      it 'decorates the result' do
+        found = Product.new
+        Product.stub(:find_by_name).and_return(found)
+        decorator = ProductDecorator.find_by_name('apples')
+        expect(decorator).to be_a ProductDecorator
+        expect(decorator.object).to be found
+      end
+
+      it 'proxies complex ProductDecorators' do
+        Product.should_receive(:find_by_name_and_size).with('apples', 'large')
+        ProductDecorator.find_by_name_and_size('apples', 'large')
+      end
+
+      it 'proxies find_last_by_(x) ProductDecorators' do
+        Product.should_receive(:find_last_by_name_and_size).with('apples', 'large')
+        ProductDecorator.find_last_by_name_and_size('apples', 'large')
+      end
+
+      it 'proxies find_or_initialize_by_(x) ProductDecorators' do
+        Product.should_receive(:find_or_initialize_by_name_and_size).with('apples', 'large')
+        ProductDecorator.find_or_initialize_by_name_and_size('apples', 'large')
+      end
+
+      it 'proxies find_or_create_by_(x) ProductDecorators' do
+        Product.should_receive(:find_or_create_by_name_and_size).with('apples', 'large')
+        ProductDecorator.find_or_create_by_name_and_size('apples', 'large')
+      end
+
+      it 'passes context to the decorator' do
+        Product.stub(:find_by_name_and_size)
+        context = { some: 'context' }
+        decorator = ProductDecorator.find_by_name_and_size('apples', 'large', context: context)
+
+        expect(decorator.context).to be context
+      end
+    end
+
+    describe '.find_all_by_' do
+      it 'proxies to the model class' do
+        Product.should_receive(:find_all_by_name_and_size).with('apples', 'large').and_return([])
+        ProductDecorator.find_all_by_name_and_size('apples', 'large')
+      end
+
+      it 'decorates the result' do
+        found = [Product.new, Product.new]
+        Product.stub(:find_all_by_name).and_return(found)
+        decorator = ProductDecorator.find_all_by_name('apples')
+
+        expect(decorator).to be_a Drape::CollectionDecorator
+        expect(decorator.decorator_class).to be ProductDecorator
+        expect(decorator).to eq found
+      end
+
+      it 'passes context to the decorator' do
+        Product.stub(:find_all_by_name)
+        context = { some: 'context' }
+        decorator = ProductDecorator.find_all_by_name('apples', context: context)
+
+        expect(decorator.context).to be context
+      end
+    end
+
+    describe '.all' do
+      it 'returns a decorated collection' do
+        found = [Product.new, Product.new]
+        Product.stub all: found
+        decorator = ProductDecorator.all
+
+        expect(decorator).to be_a Drape::CollectionDecorator
+        expect(decorator.decorator_class).to be ProductDecorator
+        expect(decorator).to eq found
+      end
+
+      it 'passes context to the decorator' do
+        Product.stub(:all)
+        context = { some: 'context' }
+        decorator = ProductDecorator.all(context: context)
+
+        expect(decorator.context).to be context
+      end
+    end
+
+    describe '.first' do
+      it 'proxies to the model class' do
+        Product.should_receive(:first)
+        ProductDecorator.first
+      end
+
+      it 'decorates the result' do
+        first = Product.new
+        Product.stub(:first).and_return(first)
+        decorator = ProductDecorator.first
+        expect(decorator).to be_a ProductDecorator
+        expect(decorator.object).to be first
+      end
+
+      it 'passes context to the decorator' do
+        Product.stub(:first)
+        context = { some: 'context' }
+        decorator = ProductDecorator.first(context: context)
+
+        expect(decorator.context).to be context
+      end
+    end
+
+    describe '.last' do
+      it 'proxies to the model class' do
+        Product.should_receive(:last)
+        ProductDecorator.last
+      end
+
+      it 'decorates the result' do
+        last = Product.new
+        Product.stub(:last).and_return(last)
+        decorator = ProductDecorator.last
+        expect(decorator).to be_a ProductDecorator
+        expect(decorator.object).to be last
+      end
+
+      it 'passes context to the decorator' do
+        Product.stub(:last)
+        context = { some: 'context' }
+        decorator = ProductDecorator.last(context: context)
+
+        expect(decorator.context).to be context
+      end
+    end
+  end
+end

data/spec/draper/helper_proxy_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+module Drape
+  describe HelperProxy do
+    describe '#initialize' do
+      it 'sets the view context' do
+        view_context = double
+        helper_proxy = HelperProxy.new(view_context)
+
+        expect(helper_proxy.send(:view_context)).to be view_context
+      end
+    end
+
+    describe '#method_missing' do
+      protect_class HelperProxy
+
+      it 'proxies methods to the view context' do
+        view_context = double
+        helper_proxy = HelperProxy.new(view_context)
+
+        view_context.stub(:foo) { |arg| arg }
+        expect(helper_proxy.foo(:passed)).to be :passed
+      end
+
+      it 'passes blocks' do
+        view_context = double
+        helper_proxy = HelperProxy.new(view_context)
+
+        view_context.stub(:foo) { |&block| block.call }
+        expect(helper_proxy.foo { :yielded }).to be :yielded
+      end
+
+      it 'defines the method for better performance' do
+        helper_proxy = HelperProxy.new(double(foo: 'bar'))
+
+        expect(HelperProxy.instance_methods).not_to include :foo
+        helper_proxy.foo
+        expect(HelperProxy.instance_methods).to include :foo
+      end
+    end
+
+    describe '#respond_to_missing?' do
+      it 'allows #method to be called on the view context' do
+        helper_proxy = HelperProxy.new(double(foo: 'bar'))
+
+        expect(helper_proxy.respond_to?(:foo)).to be_truthy
+      end
+    end
+
+    describe 'proxying methods which are overriding' do
+      it 'proxies :capture' do
+        view_context = double
+        helper_proxy = HelperProxy.new(view_context)
+
+        allow(view_context).to receive(:capture) { |*args, &block| [*args, block.call] }
+        expect(helper_proxy.capture(:first_arg, :second_arg) { :yielded })
+            .to be_eql [:first_arg, :second_arg, :yielded]
+      end
+    end
+  end
+end