draper 3.0.0.pre1 → 3.0.0

data/spec/draper/draper_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+require 'support/shared_examples/view_helpers'
+
+module Draper
+  describe Draper do
+    describe '.setup_action_controller' do
+      it 'includes api only compatability if base is ActionController::API' do
+        base = ActionController::API
+
+        Draper.setup_action_controller(base)
+
+        expect(base.included_modules).to include(Draper::Compatibility::ApiOnly)
+      end
+
+      it 'does not include api only compatibility if base ActionController::Base' do
+        base = ActionController::Base
+
+        Draper.setup_action_controller(base)
+
+        expect(base.included_modules).not_to include(Draper::Compatibility::ApiOnly)
+      end
+    end
+  end
+end

data/spec/draper/factory_spec.rb

@@ -27,7 +27,7 @@ module Draper
         factory = Factory.new
         worker = ->(*){ :decorated }
 
-        Factory::Worker.should_receive(:new).and_return(worker)
+        expect(Factory::Worker).to receive(:new).and_return(worker)
         expect(factory.decorate(double)).to be :decorated
       end
 
@@ -35,7 +35,7 @@ module Draper
         factory = Factory.new
         object = double
 
-        Factory::Worker.should_receive(:new).with(anything(), object).and_return(->(*){})
+        expect(Factory::Worker).to receive(:new).with(anything(), object).and_return(->(*){})
         factory.decorate(object)
       end
 
@@ -44,7 +44,7 @@ module Draper
           decorator_class = double
           factory = Factory.new(with: decorator_class)
 
-          Factory::Worker.should_receive(:new).with(decorator_class, anything()).and_return(->(*){})
+          expect(Factory::Worker).to receive(:new).with(decorator_class, anything()).and_return(->(*){})
           factory.decorate(double)
         end
       end
@@ -53,7 +53,7 @@ module Draper
         it "passes nil to the worker" do
           factory = Factory.new
 
-          Factory::Worker.should_receive(:new).with(nil, anything()).and_return(->(*){})
+          expect(Factory::Worker).to receive(:new).with(nil, anything()).and_return(->(*){})
           factory.decorate(double)
         end
       end
@@ -61,10 +61,10 @@ module Draper
       it "passes options to the call" do
         factory = Factory.new
         worker = ->(*){}
-        Factory::Worker.stub new: worker
+        allow(Factory::Worker).to receive(:new).and_return(worker)
         options = {foo: "bar"}
 
-        worker.should_receive(:call).with(options)
+        allow(worker).to receive(:call).with(options)
         factory.decorate(double, options)
       end
 
@@ -72,18 +72,18 @@ module Draper
         it "sets the passed context" do
           factory = Factory.new(context: {foo: "bar"})
           worker = ->(*){}
-          Factory::Worker.stub new: worker
+          allow(Factory::Worker).to receive_messages new: worker
 
-          worker.should_receive(:call).with(baz: "qux", context: {foo: "bar"})
+          expect(worker).to 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
+          allow(Factory::Worker).to receive_messages new: worker
 
-          worker.should_receive(:call).with(context: {baz: "qux"})
+          expect(worker).to receive(:call).with(context: {baz: "qux"})
           factory.decorate(double, context: {baz: "qux"})
         end
       end
@@ -99,9 +99,9 @@ module Draper
         options = {foo: "bar"}
         worker = Factory::Worker.new(double, object)
         decorator = ->(*){}
-        allow(worker).to receive(:decorator){ decorator }        
+        allow(worker).to receive(:decorator){ decorator }
 
-        decorator.should_receive(:call).with(object, options).and_return(:decorated)
+        allow(decorator).to receive(:call).with(object, options).and_return(:decorated)
         expect(worker.call(options)).to be :decorated
       end
 
@@ -109,29 +109,29 @@ module Draper
         it "calls it" do
           worker = Factory::Worker.new(double, double)
           decorator = ->(*){}
-          worker.stub decorator: decorator
+          allow(worker).to receive_messages decorator: decorator
           context = {foo: "bar"}
 
-          decorator.should_receive(:call).with(anything(), context: context)
+          expect(decorator).to 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: ->(*){}
+          allow(worker).to receive_messages decorator: ->(*){}
           context = ->{}
 
-          context.should_receive(:call).with(:foo, :bar)
+          expect(context).to 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: ->(*){}
+          allow(worker).to receive_messages decorator: ->(*){}
           context = ->{}
           hash = {foo: "bar"}
 
-          context.should_receive(:call).with(hash)
+          expect(context).to receive(:call).with(hash)
           worker.call(context: context, context_args: hash)
         end
       end
@@ -140,10 +140,10 @@ module Draper
         it "doesn't call it" do
           worker = Factory::Worker.new(double, double)
           decorator = ->(*){}
-          worker.stub decorator: decorator
+          allow(worker).to receive_messages decorator: decorator
           context = {foo: "bar"}
 
-          decorator.should_receive(:call).with(anything(), context: context)
+          expect(decorator).to receive(:call).with(anything(), context: context)
           worker.call(context: context)
         end
       end
@@ -151,9 +151,9 @@ module Draper
       it "does not pass the :context_args option to the decorator" do
         worker = Factory::Worker.new(double, double)
         decorator = ->(*){}
-        worker.stub decorator: decorator
+        allow(worker).to receive_messages decorator: decorator
 
-        decorator.should_receive(:call).with(anything(), foo: "bar")
+        expect(decorator).to receive(:call).with(anything(), foo: "bar")
         worker.call(foo: "bar", context_args: [])
       end
     end
@@ -176,7 +176,7 @@ module Draper
               options = {foo: "bar"}
               worker = Factory::Worker.new(nil, object)
 
-              object.should_receive(:decorate).with(options).and_return(:decorated)
+              expect(object).to receive(:decorate).with(options).and_return(:decorated)
               expect(worker.decorator.call(object, options)).to be :decorated
             end
           end
@@ -231,7 +231,7 @@ module Draper
               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(decorator_class).to receive(:decorate_collection).with(object, foo: "bar", with: nil).and_return(:decorated)
               expect(worker.decorator.call(object, foo: "bar")).to be :decorated
             end
           end

data/spec/draper/finders_spec.rb

@@ -7,20 +7,20 @@ module Draper
 
     describe ".find" do
       it "proxies to the model class" do
-        Product.should_receive(:find).with(1)
+        expect(Product).to receive(:find).with(1)
         ProductDecorator.find(1)
       end
 
       it "decorates the result" do
         found = Product.new
-        Product.stub(:find).and_return(found)
+        allow(Product).to receive(: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)
+        allow(Product).to receive(:find)
         context = {some: "context"}
         decorator = ProductDecorator.find(1, context: context)
 
@@ -30,40 +30,40 @@ module Draper
 
     describe ".find_by_(x)" do
       it "proxies to the model class" do
-        Product.should_receive(:find_by_name).with("apples")
+        expect(Product).to 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)
+        allow(Product).to receive(: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")
+        expect(Product).to 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")
+        expect(Product).to 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")
+        expect(Product).to 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")
+        expect(Product).to 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)
+        allow(Product).to receive(:find_by_name_and_size)
         context = {some: "context"}
         decorator = ProductDecorator.find_by_name_and_size("apples", "large", context: context)
 
@@ -73,13 +73,13 @@ module Draper
 
     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([])
+        expect(Product).to 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)
+        allow(Product).to receive(:find_all_by_name).and_return(found)
         decorator = ProductDecorator.find_all_by_name("apples")
 
         expect(decorator).to be_a Draper::CollectionDecorator
@@ -88,7 +88,7 @@ module Draper
       end
 
       it "passes context to the decorator" do
-        Product.stub(:find_all_by_name)
+        allow(Product).to receive(:find_all_by_name)
         context = {some: "context"}
         decorator = ProductDecorator.find_all_by_name("apples", context: context)
 
@@ -99,7 +99,7 @@ module Draper
     describe ".all" do
       it "returns a decorated collection" do
         found = [Product.new, Product.new]
-        Product.stub all: found
+        allow(Product).to receive_messages all: found
         decorator = ProductDecorator.all
 
         expect(decorator).to be_a Draper::CollectionDecorator
@@ -108,7 +108,7 @@ module Draper
       end
 
       it "passes context to the decorator" do
-        Product.stub(:all)
+        allow(Product).to receive(:all)
         context = {some: "context"}
         decorator = ProductDecorator.all(context: context)
 
@@ -118,20 +118,20 @@ module Draper
 
     describe ".first" do
       it "proxies to the model class" do
-        Product.should_receive(:first)
+        expect(Product).to receive(:first)
         ProductDecorator.first
       end
 
       it "decorates the result" do
         first = Product.new
-        Product.stub(:first).and_return(first)
+        allow(Product).to receive(: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)
+        allow(Product).to receive(:first)
         context = {some: "context"}
         decorator = ProductDecorator.first(context: context)
 
@@ -141,20 +141,20 @@ module Draper
 
     describe ".last" do
       it "proxies to the model class" do
-        Product.should_receive(:last)
+        expect(Product).to receive(:last)
         ProductDecorator.last
       end
 
       it "decorates the result" do
         last = Product.new
-        Product.stub(:last).and_return(last)
+        allow(Product).to receive(: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)
+        allow(Product).to receive(:last)
         context = {some: "context"}
         decorator = ProductDecorator.last(context: context)
 

data/spec/draper/helper_proxy_spec.rb

@@ -18,7 +18,7 @@ module Draper
         view_context = double
         helper_proxy = HelperProxy.new(view_context)
 
-        view_context.stub(:foo) { |arg| arg }
+        allow(view_context).to receive(:foo) { |arg| arg }
         expect(helper_proxy.foo(:passed)).to be :passed
       end
 
@@ -26,7 +26,7 @@ module Draper
         view_context = double
         helper_proxy = HelperProxy.new(view_context)
 
-        view_context.stub(:foo) { |&block| block.call }
+        allow(view_context).to receive(:foo) { |&block| block.call }
         expect(helper_proxy.foo{:yielded}).to be :yielded
       end
 

data/spec/draper/lazy_helpers_spec.rb

@@ -8,12 +8,12 @@ module Draper
       end
 
       it "proxies methods to #helpers" do
-        decorator.helpers.stub(:foo) { |arg| arg }
+        allow(decorator.helpers).to receive(:foo) { |arg| arg }
         expect(decorator.foo(:passed)).to be :passed
       end
 
       it "passes blocks" do
-        decorator.helpers.stub(:foo) { |&block| block.call }
+        allow(decorator.helpers).to receive(:foo) { |&block| block.call }
         expect(decorator.foo{:yielded}).to be :yielded
       end
     end

data/spec/draper/undecorate_chain_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Draper, '.undecorate_chain' do
+  let!(:object) { Model.new }
+  let!(:decorated_inner) { Class.new(Draper::Decorator).new(object) }
+  let!(:decorated_outer) { Class.new(Draper::Decorator).new(decorated_inner) }
+
+  it 'undecorates full chain of decorated objects' do
+    expect(Draper.undecorate_chain(decorated_outer)).to equal object
+  end
+
+  it 'passes a non-decorated object through' do
+    expect(Draper.undecorate_chain(object)).to equal object
+  end
+
+  it 'passes a non-decorator object through' do
+    object = Object.new
+    expect(Draper.undecorate_chain(object)).to equal object
+  end
+end

data/spec/draper/view_context/build_strategy_spec.rb

@@ -14,7 +14,7 @@ module Draper
       context "when a current controller is set" do
         it "returns the controller's view context" do
           view_context = fake_view_context
-          ViewContext.stub controller: fake_controller(view_context)
+          allow(ViewContext).to receive_messages controller: fake_controller(view_context)
           strategy = ViewContext::BuildStrategy::Full.new
 
           expect(strategy.call).to be view_context
@@ -23,31 +23,47 @@ module Draper
 
       context "when a current controller is not set" do
         it "uses ApplicationController" do
-          view_context = fake_view_context
-          stub_const "ApplicationController", double(new: fake_controller(view_context))
-          strategy = ViewContext::BuildStrategy::Full.new
-
-          expect(strategy.call).to be view_context
+          expect(Draper::ViewContext.controller).to be_nil
+          view_context = ViewContext::BuildStrategy::Full.new.call
+          expect(view_context.controller).to eq Draper::ViewContext.controller
+          expect(view_context.controller).to be_an ApplicationController
         end
       end
 
       it "adds a request if one is not defined" do
         controller = Class.new(ActionController::Base).new
-        ViewContext.stub controller: controller
+        allow(ViewContext).to receive_messages controller: controller
         strategy = ViewContext::BuildStrategy::Full.new
 
         expect(controller.request).to be_nil
         strategy.call
         expect(controller.request).to be_an ActionController::TestRequest
-        expect(controller.params).to eq({})
+        expect(controller.params).to be_empty
 
         # sanity checks
         expect(controller.view_context.request).to be controller.request
         expect(controller.view_context.params).to be controller.params
       end
 
+      it "compatible with rails 5.1 change on ActionController::TestRequest.create method" do
+        ActionController::TestRequest.class_eval do
+          if ActionController::TestRequest.method(:create).parameters.first == []
+            def create controller_class
+              create
+            end
+          end
+        end
+        controller = Class.new(ActionController::Base).new
+        allow(ViewContext).to receive_messages controller: controller
+        strategy = ViewContext::BuildStrategy::Full.new
+
+        expect(controller.request).to be_nil
+        strategy.call
+        expect(controller.request).to be_an ActionController::TestRequest
+      end
+
       it "adds methods to the view context from the constructor block" do
-        ViewContext.stub controller: fake_controller
+        allow(ViewContext).to receive(:controller).and_return(fake_controller)
         strategy = ViewContext::BuildStrategy::Full.new do
           def a_helper_method; end
         end
@@ -57,7 +73,7 @@ module Draper
 
       it "includes modules into the view context from the constructor block" do
         view_context = Object.new
-        ViewContext.stub controller: fake_controller(view_context)
+        allow(ViewContext).to receive(:controller).and_return(fake_controller(view_context))
         helpers = Module.new do
           def a_helper_method; end
         end