draper 4.0.4 → 4.0.5

data/spec/draper/draper_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-require 'support/shared_examples/view_helpers'
-SimpleCov.command_name 'test:unit'
-
-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

@@ -1,247 +0,0 @@
-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 }
-
-        expect(Factory::Worker).to 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
-
-        expect(Factory::Worker).to 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)
-
-          expect(Factory::Worker).to 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
-
-          expect(Factory::Worker).to receive(:new).with(nil, anything()).and_return(->(*){})
-          factory.decorate(double)
-        end
-      end
-
-      it "passes options to the call" do
-        factory = Factory.new
-        worker = ->(*){}
-        allow(Factory::Worker).to receive(:new).and_return(worker)
-        options = {foo: "bar"}
-
-        allow(worker).to 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 = ->(*){}
-          allow(Factory::Worker).to receive_messages new: worker
-
-          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 = ->(*){}
-          allow(Factory::Worker).to receive_messages new: worker
-
-          expect(worker).to 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 }
-
-        allow(decorator).to 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 = ->(*){}
-          allow(worker).to receive_messages decorator: decorator
-          context = {foo: "bar"}
-
-          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)
-          allow(worker).to receive_messages decorator: ->(*){}
-          context = ->{}
-
-          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)
-          allow(worker).to receive_messages decorator: ->(*){}
-          context = ->{}
-          hash = {foo: "bar"}
-
-          expect(context).to 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 = ->(*){}
-          allow(worker).to receive_messages decorator: decorator
-          context = {foo: "bar"}
-
-          expect(decorator).to 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 = ->(*){}
-        allow(worker).to receive_messages decorator: decorator
-
-        expect(decorator).to 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)
-
-              expect(object).to 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)
-
-              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
-
-          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

@@ -1,166 +0,0 @@
-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
-        expect(Product).to receive(:find).with(1)
-        ProductDecorator.find(1)
-      end
-
-      it "decorates the result" do
-        found = Product.new
-        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
-        allow(Product).to receive(: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
-        expect(Product).to receive(:find_by_name).with("apples")
-        ProductDecorator.find_by_name("apples")
-      end
-
-      it "decorates the result" do
-        found = Product.new
-        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
-        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
-        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
-        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
-        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
-        allow(Product).to receive(: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
-        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]
-        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
-        expect(decorator.decorator_class).to be ProductDecorator
-        expect(decorator).to eq found
-      end
-
-      it "passes context to the decorator" do
-        allow(Product).to receive(: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]
-        allow(Product).to receive_messages 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
-        allow(Product).to receive(: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
-        expect(Product).to receive(:first)
-        ProductDecorator.first
-      end
-
-      it "decorates the result" do
-        first = Product.new
-        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
-        allow(Product).to receive(: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
-        expect(Product).to receive(:last)
-        ProductDecorator.last
-      end
-
-      it "decorates the result" do
-        last = Product.new
-        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
-        allow(Product).to receive(: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

@@ -1,61 +0,0 @@
-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)
-
-        allow(view_context).to receive(: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)
-
-        allow(view_context).to receive(: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

data/spec/draper/lazy_helpers_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-
-module Draper
-  describe LazyHelpers do
-    describe "#method_missing" do
-      let(:decorator) do
-        Struct.new(:helpers){include Draper::LazyHelpers}.new(double)
-      end
-
-      it "proxies methods to #helpers" do
-        allow(decorator.helpers).to receive(:foo) { |arg| arg }
-        expect(decorator.foo(:passed)).to be :passed
-      end
-
-      it "passes blocks" do
-        allow(decorator.helpers).to receive(:foo) { |&block| block.call }
-        expect(decorator.foo{:yielded}).to be :yielded
-      end
-    end
-  end
-end

data/spec/draper/query_methods/load_strategy_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-require 'active_record'
-
-module Draper
-  module QueryMethods
-    describe LoadStrategy do
-      describe '#new' do
-        subject { described_class.new(:active_record) }
-
-        it { is_expected.to be_an_instance_of(LoadStrategy::ActiveRecord) }
-      end
-    end
-
-    describe LoadStrategy::ActiveRecord do
-      describe '#allowed?' do
-        it 'checks whether or not ActiveRecord::Relation::VALUE_METHODS has the given method' do
-          allow(::ActiveRecord::Relation::VALUE_METHODS).to receive(:include?)
-
-          described_class.new.allowed? :foo
-
-          expect(::ActiveRecord::Relation::VALUE_METHODS).to have_received(:include?).with(:foo)
-        end
-      end
-    end
-  end
-end

data/spec/draper/query_methods_spec.rb

@@ -1,80 +0,0 @@
-require 'spec_helper'
-require_relative '../dummy/app/decorators/post_decorator'
-
-Post = Struct.new(:id) { }
-
-module Draper
-  describe QueryMethods do
-    let(:fake_strategy) { instance_double(QueryMethods::LoadStrategy::ActiveRecord) }
-
-    before { allow(QueryMethods::LoadStrategy).to receive(:new).and_return(fake_strategy) }
-
-    describe '#method_missing' do
-      let(:collection) { [ Post.new, Post.new ] }
-      let(:collection_context) { { user: 'foo' } }
-      let(:collection_decorator) { PostDecorator.decorate_collection(collection, context: collection_context) }
-
-      context 'when strategy allows collection to call the method' do
-        let(:results) { spy(:results) }
-
-        before do
-          allow(fake_strategy).to receive(:allowed?).with(:some_query_method).and_return(true)
-          allow(collection).to receive(:send).with(:some_query_method).and_return(results)
-        end
-
-        it 'calls the method on the collection and decorate it results' do
-          collection_decorator.some_query_method
-
-          expect(results).to have_received(:decorate)
-        end
-
-        it 'calls the method on the collection and keeps the decoration options' do
-          collection_decorator.some_query_method
-
-          expect(results).to have_received(:decorate).with({ context: collection_context, with: PostDecorator })
-        end
-      end
-
-      context 'when strategy does not allow collection to call the method' do
-        before { allow(fake_strategy).to receive(:allowed?).with(:some_query_method).and_return(false) }
-
-        it 'raises NoMethodError' do
-          expect { collection_decorator.some_query_method }.to raise_exception(NoMethodError)
-        end
-      end
-    end
-
-    describe "#respond_to?" do
-      let(:collection) { [ Post.new, Post.new ] }
-      let(:collection_decorator) { PostDecorator.decorate_collection(collection) }
-
-      subject { collection_decorator.respond_to?(:some_query_method) }
-
-      context 'when strategy allows collection to call the method' do
-        before do
-          allow(fake_strategy).to receive(:allowed?).with(:some_query_method).and_return(true)
-          allow(collection).to receive(:respond_to?).with(:some_query_method).and_return(true)
-        end
-
-        it { is_expected.to eq(true) }
-
-        context 'and collection does not implement the method' do
-          before do
-            allow(collection).to receive(:respond_to?).with(:some_query_method).and_return(false)
-          end
-
-          it { is_expected.to eq(false) }
-        end
-      end
-
-      context 'when strategy does not allow collection to call the method' do
-        before do
-          allow(fake_strategy).to receive(:allowed?).with(:some_query_method).and_return(false)
-          allow(collection).to receive(:respond_to?).with(:some_query_method).and_return(true)
-        end
-
-        it { is_expected.to eq(false) }
-      end
-    end
-  end
-end

data/spec/draper/undecorate_chain_spec.rb

@@ -1,20 +0,0 @@
-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/undecorate_spec.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-
-describe Draper, '.undecorate' do
-  it 'undecorates a decorated object' do
-    object = Model.new
-    decorator = Draper::Decorator.new(object)
-    expect(Draper.undecorate(decorator)).to equal object
-  end
-
-  it 'passes a non-decorated object through' do
-    object = Model.new
-    expect(Draper.undecorate(object)).to equal object
-  end
-
-  it 'passes a non-decorator object through' do
-    object = Object.new
-    expect(Draper.undecorate(object)).to equal object
-  end
-end