draper_new 3.0.0

data/spec/draper/factory_spec.rb

@@ -0,0 +1,251 @@
+require 'spec_helper'
+
+module Draper
+  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,166 @@
+require 'spec_helper'
+
+module Draper
+  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 Draper::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 Draper::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 Draper
+  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