draper 1.0.0 → 1.1.0

data/spec/draper/decorator_spec.rb

@@ -1,624 +1,598 @@
 require 'spec_helper'
+require 'support/shared_examples/view_helpers'
 
-describe Draper::Decorator do
-  before { ApplicationController.new.view_context }
-  subject { decorator_class.new(source) }
-  let(:decorator_class) { Draper::Decorator }
-  let(:source) { Product.new }
+module Draper
+  describe Decorator do
+    it_behaves_like "view helpers", Decorator.new(Model.new)
 
-  describe "#initialize" do
-    describe "options validation" do
-      let(:valid_options) { {context: {}} }
+    describe "#initialize" do
+      describe "options validation" do
+        it "does not raise error on valid options" do
+          valid_options = {context: {}}
+          expect{Decorator.new(Model.new, valid_options)}.not_to raise_error
+        end
 
-      it "does not raise error on valid options" do
-        expect { decorator_class.new(source, valid_options) }.to_not raise_error
+        it "raises error on invalid options" do
+          expect{Decorator.new(Model.new, foo: "bar")}.to raise_error ArgumentError, /Unknown key/
+        end
       end
 
-      it "raises error on invalid options" do
-        expect { decorator_class.new(source, valid_options.merge(foo: 'bar')) }.to raise_error(ArgumentError, /Unknown key/)
-      end
-    end
+      it "sets the source" do
+        source = Model.new
+        decorator = Decorator.new(source)
 
-    it "sets the source" do
-      subject.source.should be source
-    end
+        expect(decorator.source).to be source
+      end
 
-    it "stores context" do
-      decorator = decorator_class.new(source, context: {some: 'context'})
-      decorator.context.should == {some: 'context'}
-    end
+      it "stores context" do
+        context = {some: "context"}
+        decorator = Decorator.new(Model.new, context: context)
 
-    context "when decorating an instance of itself" do
-      it "does not redecorate" do
-        decorator = ProductDecorator.new(source)
-        ProductDecorator.new(decorator).source.should be source
+        expect(decorator.context).to be context
       end
 
-      context "when options are supplied" do
-        it "overwrites existing context" do
-          decorator = ProductDecorator.new(source, context: {role: :admin})
-          ProductDecorator.new(decorator, context: {role: :user}).context.should == {role: :user}
+      context "when decorating an instance of itself" do
+        it "applies to the source instead" do
+          source = Model.new
+          decorated = Decorator.new(source)
+          redecorated = Decorator.new(decorated)
+
+          expect(redecorated.source).to be source
         end
-      end
 
-      context "when no options are supplied" do
-        it "preserves existing context" do
-          decorator = ProductDecorator.new(source, context: {role: :admin})
-          ProductDecorator.new(decorator).context.should == {role: :admin}
+        context "with context" do
+          it "overwrites existing context" do
+            decorated = Decorator.new(Model.new, context: {some: "context"})
+            new_context = {other: "context"}
+            redecorated = Decorator.new(decorated, context: new_context)
+
+            expect(redecorated.context).to be new_context
+          end
         end
-      end
-    end
 
-    context "when decorating other decorators" do
-      it "redecorates" do
-        decorator = ProductDecorator.new(source)
-        SpecificProductDecorator.new(decorator).source.should be decorator
+        context "without context" do
+          it "preserves existing context" do
+            old_context = {some: "context"}
+            decorated = Decorator.new(Model.new, context: old_context)
+            redecorated = Decorator.new(decorated)
+
+            expect(redecorated.context).to be old_context
+          end
+        end
       end
 
-      context "when the same decorator has been applied earlier in the chain" do
-        let(:decorator) { SpecificProductDecorator.new(ProductDecorator.new(Product.new)) }
+      it "decorates other decorators" do
+        decorated = OtherDecorator.new(Model.new)
+        redecorated = Decorator.new(decorated)
+
+        expect(redecorated.source).to be decorated
+      end
 
+      context "when it has been applied previously" do
         it "warns" do
+          decorated = OtherDecorator.new(Decorator.new(Model.new))
+
           warning_message = nil
           Object.any_instance.stub(:warn) {|message| warning_message = message }
 
-          expect{ProductDecorator.new(decorator)}.to change{warning_message}
-          warning_message.should =~ /ProductDecorator/
-          warning_message.should include caller(1).first
+          expect{Decorator.new(decorated)}.to change{warning_message}
+          expect(warning_message).to start_with "Reapplying Draper::Decorator"
+          expect(warning_message).to include caller(1).first
         end
 
-        it "redecorates" do
+        it "decorates anyway" do
+          decorated = OtherDecorator.new(Decorator.new(Model.new))
           Object.any_instance.stub(:warn)
-          ProductDecorator.new(decorator).source.should be decorator
+          redecorated = Decorator.decorate(decorated)
+
+          expect(redecorated.source).to be decorated
         end
       end
     end
-  end
-
-  describe "#context=" do
-    it "modifies the context" do
-      decorator = decorator_class.new(source, context: {some: 'context'})
-      decorator.context = {some: 'other_context'}
-      decorator.context.should == {some: 'other_context'}
-    end
-  end
-
-  describe ".decorate_collection" do
-    let(:source) { [Product.new, Widget.new] }
-
-    describe "options validation" do
-      let(:valid_options) { {with: :infer, context: {}} }
-      before(:each) { Draper::CollectionDecorator.stub(:new) }
 
-      it "does not raise error on valid options" do
-        expect { ProductDecorator.decorate_collection(source, valid_options) }.to_not raise_error
-      end
+    describe "#context=" do
+      it "modifies the context" do
+        decorator = Decorator.new(Model.new, context: {some: "context"})
+        new_context = {other: "context"}
 
-      it "raises error on invalid options" do
-        expect { ProductDecorator.decorate_collection(source, valid_options.merge(foo: 'bar')) }.to raise_error(ArgumentError, /Unknown key/)
+        decorator.context = new_context
+        expect(decorator.context).to be new_context
       end
     end
 
-    context "when a custom collection decorator does not exist" do
-      subject { WidgetDecorator.decorate_collection(source) }
+    describe ".decorate_collection" do
+      describe "options validation" do
+        before { CollectionDecorator.stub(:new) }
 
-      it "returns a regular collection decorator" do
-        subject.should be_a Draper::CollectionDecorator
-        subject.should == source
-      end
+        it "does not raise error on valid options" do
+          valid_options = {with: OtherDecorator, context: {}}
+          expect{Decorator.decorate_collection([], valid_options)}.not_to raise_error
+        end
 
-      it "uses itself as the item decorator by default" do
-        subject.each {|item| item.should be_a WidgetDecorator}
+        it "raises error on invalid options" do
+          expect{Decorator.decorate_collection([], foo: "bar")}.to raise_error ArgumentError, /Unknown key/
+        end
       end
-    end
-
-    context "when a custom collection decorator exists" do
-      subject { ProductDecorator.decorate_collection(source) }
 
-      it "returns the custom collection decorator" do
-        subject.should be_a ProductsDecorator
-        subject.should == source
-      end
+      context "without a custom collection decorator" do
+        it "creates a CollectionDecorator using itself for each item" do
+          source = [Model.new]
 
-      it "uses itself as the item decorator by default" do
-        subject.each {|item| item.should be_a ProductDecorator}
-      end
-    end
+          CollectionDecorator.should_receive(:new).with(source, with: Decorator)
+          Decorator.decorate_collection(source)
+        end
 
-    context "with context" do
-      subject { ProductDecorator.decorate_collection(source, with: :infer, context: {some: 'context'}) }
+        it "passes options to the collection decorator" do
+          options = {with: OtherDecorator, context: {some: "context"}}
 
-      it "passes the context to the collection decorator" do
-        subject.context.should == {some: 'context'}
+          CollectionDecorator.should_receive(:new).with([], options)
+          Decorator.decorate_collection([], options)
+        end
       end
-    end
-  end
-
-  describe "#helpers" do
-    it "returns a HelperProxy" do
-      subject.helpers.should be_a Draper::HelperProxy
-    end
 
-    it "is aliased to #h" do
-      subject.h.should be subject.helpers
-    end
+      context "with a custom collection decorator" do
+        it "creates a custom collection decorator using itself for each item" do
+          source = [Model.new]
 
-    it "initializes the wrapper only once" do
-      helper_proxy = subject.helpers
-      helper_proxy.stub(:test_method) { "test_method" }
-      subject.helpers.test_method.should == "test_method"
-      subject.helpers.test_method.should == "test_method"
-    end
-  end
+          ProductsDecorator.should_receive(:new).with(source, with: ProductDecorator)
+          ProductDecorator.decorate_collection(source)
+        end
 
-  describe "#localize" do
-    before { subject.helpers.should_receive(:localize).with(:an_object, {some: 'parameter'}) }
+        it "passes options to the collection decorator" do
+          options = {with: OtherDecorator, context: {some: "context"}}
 
-    it "delegates to #helpers" do
-      subject.localize(:an_object, some: 'parameter')
+          ProductsDecorator.should_receive(:new).with([], options)
+          ProductDecorator.decorate_collection([], options)
+        end
+      end
     end
 
-    it "is aliased to #l" do
-      subject.l(:an_object, some: 'parameter')
-    end
-  end
+    describe ".decorates" do
+      protect_class Decorator
 
-  describe ".helpers" do
-    it "returns a HelperProxy" do
-      subject.class.helpers.should be_a Draper::HelperProxy
-    end
+      it "sets .source_class with a symbol" do
+        Decorator.decorates :product
 
-    it "is aliased to .h" do
-      subject.class.h.should be subject.class.helpers
-    end
-  end
+        expect(Decorator.source_class).to be Product
+      end
 
-  describe ".decorates" do
-    subject { Class.new(Draper::Decorator) }
+      it "sets .source_class with a string" do
+        Decorator.decorates "product"
 
-    context "with a symbol" do
-      it "sets .source_class" do
-        subject.decorates :product
-        subject.source_class.should be Product
+        expect(Decorator.source_class).to be Product
       end
-    end
 
-    context "with a string" do
-      it "sets .source_class" do
-        subject.decorates "product"
-        subject.source_class.should be Product
-      end
-    end
+      it "sets .source_class with a class" do
+        Decorator.decorates Product
 
-    context "with a class" do
-      it "sets .source_class" do
-        subject.decorates Product
-        subject.source_class.should be Product
+        expect(Decorator.source_class).to be Product
       end
     end
-  end
-
-  describe ".source_class" do
-    context "when not set by .decorates" do
-      context "for an anonymous decorator" do
-        subject { Class.new(Draper::Decorator) }
 
-        it "raises an UninferrableSourceError" do
-          expect{subject.source_class}.to raise_error Draper::UninferrableSourceError
+    describe ".source_class" do
+      context "when not set by .decorates" do
+        it "raises an error for a so-named 'Decorator'" do
+          expect{Decorator.source_class}.to raise_error UninferrableSourceError
         end
-      end
 
-      context "for a decorator without a corresponding source" do
-        subject { SpecificProductDecorator }
-
-        it "raises an UninferrableSourceError" do
-          expect{subject.source_class}.to raise_error Draper::UninferrableSourceError
+        it "raises an error for anonymous decorators" do
+          expect{Class.new(Decorator).source_class}.to raise_error UninferrableSourceError
         end
-      end
-
-      context "for a decorator called Decorator" do
-        subject { Draper::Decorator }
 
-        it "raises an UninferrableSourceError" do
-          expect{subject.source_class}.to raise_error Draper::UninferrableSourceError
+        it "raises an error for a decorator without a model" do
+          expect{OtherDecorator.source_class}.to raise_error UninferrableSourceError
         end
-      end
-
-      context "for a decorator with a name not ending in Decorator" do
-        subject { DecoratorWithApplicationHelper }
 
-        it "raises an UninferrableSourceError" do
-          expect{subject.source_class}.to raise_error Draper::UninferrableSourceError
+        it "raises an error for other naming conventions" do
+          expect{ProductPresenter.source_class}.to raise_error UninferrableSourceError
         end
-      end
 
-      context "for an inferrable source" do
-        subject { ProductDecorator }
-
-        it "infers the source" do
-          subject.source_class.should be Product
+        it "infers the source for '<Model>Decorator'" do
+          expect(ProductDecorator.source_class).to be Product
         end
-      end
-
-      context "for a namespaced inferrable source" do
-        subject { Namespace::ProductDecorator }
 
-        it "infers the namespaced source" do
-          subject.source_class.should be Namespace::Product
+        it "infers namespaced sources" do
+          expect(Namespaced::ProductDecorator.source_class).to be Namespaced::Product
         end
       end
     end
-  end
 
-  describe ".source_class?" do
-    subject { Class.new(Draper::Decorator) }
+    describe ".source_class?" do
+      it "returns truthy when .source_class is set" do
+        Decorator.stub(:source_class).and_return(Model)
 
-    it "returns truthy when .source_class is set" do
-      subject.stub(:source_class).and_return(Product)
-      subject.source_class?.should be_true
-    end
+        expect(Decorator.source_class?).to be_true
+      end
 
-    it "returns false when .source_class is not inferrable" do
-      subject.stub(:source_class).and_raise(Draper::UninferrableSourceError.new(subject))
-      subject.source_class?.should be_false
-    end
-  end
+      it "returns false when .source_class is not inferrable" do
+        Decorator.stub(:source_class).and_raise(UninferrableSourceError.new(Decorator))
 
-  describe ".decorates_association" do
-    let(:decorator_class) { Class.new(ProductDecorator) }
-    before { decorator_class.decorates_association :similar_products, with: ProductDecorator }
+        expect(Decorator.source_class?).to be_false
+      end
+    end
 
-    describe "overridden association method" do
-      let(:decorated_association) { ->{} }
+    describe ".decorates_association" do
+      protect_class Decorator
 
       describe "options validation" do
-        let(:valid_options) { {with: ProductDecorator, scope: :foo, context: {}} }
-        before(:each) { Draper::DecoratedAssociation.stub(:new).and_return(decorated_association) }
+        before { DecoratedAssociation.stub(:new).and_return(->{}) }
 
         it "does not raise error on valid options" do
-          expect { decorator_class.decorates_association :similar_products, valid_options }.to_not raise_error
+          valid_options = {with: Class, scope: :sorted, context: {}}
+          expect{Decorator.decorates_association(:children, valid_options)}.not_to raise_error
         end
 
         it "raises error on invalid options" do
-          expect { decorator_class.decorates_association :similar_products, valid_options.merge(foo: 'bar') }.to raise_error(ArgumentError, /Unknown key/)
+          expect{Decorator.decorates_association(:children, foo: "bar")}.to raise_error ArgumentError, /Unknown key/
         end
       end
 
-      it "creates a DecoratedAssociation" do
-        Draper::DecoratedAssociation.should_receive(:new).with(subject, :similar_products, {with: ProductDecorator}).and_return(decorated_association)
-        subject.similar_products
-      end
-
-      it "receives the Decorator" do
-        Draper::DecoratedAssociation.should_receive(:new).with(kind_of(decorator_class), :similar_products, {with: ProductDecorator}).and_return(decorated_association)
-        subject.similar_products
-      end
-
-      it "memoizes the DecoratedAssociation" do
-        Draper::DecoratedAssociation.should_receive(:new).once.and_return(decorated_association)
-        subject.similar_products
-        subject.similar_products
-      end
+      describe "defines an association method" do
+        it "creates a DecoratedAssociation" do
+          options = {with: Class.new, scope: :foo, context: {}}
+          Decorator.decorates_association :children, options
+          decorator = Decorator.new(Model.new)
 
-      it "calls the DecoratedAssociation" do
-        Draper::DecoratedAssociation.stub(:new).and_return(decorated_association)
-        decorated_association.should_receive(:call).and_return(:decorated)
-        subject.similar_products.should be :decorated
-      end
-    end
-  end
-
-  describe ".decorates_associations" do
-    subject { decorator_class }
+          DecoratedAssociation.should_receive(:new).with(decorator, :children, options).and_return(->{})
+          decorator.children
+        end
 
-    it "decorates each of the associations" do
-      subject.should_receive(:decorates_association).with(:similar_products, {})
-      subject.should_receive(:decorates_association).with(:previous_version, {})
+        it "memoizes the DecoratedAssociation" do
+          Decorator.decorates_association :children
+          decorator = Decorator.new(Model.new)
 
-      subject.decorates_associations :similar_products, :previous_version
-    end
+          DecoratedAssociation.should_receive(:new).once.and_return(->{})
+          decorator.children
+          decorator.children
+        end
 
-    it "dispatches options" do
-      subject.should_receive(:decorates_association).with(:similar_products, {with: ProductDecorator})
-      subject.should_receive(:decorates_association).with(:previous_version, {with: ProductDecorator})
+        it "calls the DecoratedAssociation" do
+          Decorator.decorates_association :children
+          decorator = Decorator.new(Model.new)
+          decorated_association = ->{}
+          DecoratedAssociation.stub(:new).and_return(decorated_association)
 
-      subject.decorates_associations :similar_products, :previous_version, with: ProductDecorator
-    end
-  end
-
-  describe "#applied_decorators" do
-    it "returns a list of decorators applied to a model" do
-      decorator = ProductDecorator.new(SpecificProductDecorator.new(Product.new))
-      decorator.applied_decorators.should == [SpecificProductDecorator, ProductDecorator]
+          decorated_association.should_receive(:call).and_return(:decorated)
+          expect(decorator.children).to be :decorated
+        end
+      end
     end
-  end
 
-  describe "#decorated_with?" do
-    it "checks if a decorator has been applied to a model" do
-      decorator = ProductDecorator.new(SpecificProductDecorator.new(Product.new))
-      decorator.should be_decorated_with ProductDecorator
-      decorator.should be_decorated_with SpecificProductDecorator
-      decorator.should_not be_decorated_with WidgetDecorator
-    end
-  end
+    describe ".decorates_associations" do
+      protect_class Decorator
 
-  describe "#decorated?" do
-    it "returns true" do
-      subject.should be_decorated
-    end
-  end
+      it "decorates each of the associations" do
+        Decorator.should_receive(:decorates_association).with(:friends, {})
+        Decorator.should_receive(:decorates_association).with(:enemies, {})
+        Decorator.decorates_associations :friends, :enemies
+      end
 
-  describe "#source" do
-    it "returns the wrapped object" do
-      subject.source.should be source
-    end
+      it "dispatches options" do
+        options = {with: Class.new, scope: :foo, context: {}}
 
-    it "is aliased to #to_source" do
-      subject.to_source.should be source
+        Decorator.should_receive(:decorates_association).with(:friends, options)
+        Decorator.should_receive(:decorates_association).with(:enemies, options)
+        Decorator.decorates_associations :friends, :enemies, options
+      end
     end
 
-    it "is aliased to #model" do
-      subject.model.should be source
-    end
-  end
+    describe "#applied_decorators" do
+      it "returns a list of decorators applied to a model" do
+        decorator = ProductDecorator.new(OtherDecorator.new(Decorator.new(Model.new)))
 
-  describe "#to_model" do
-    it "returns the decorator" do
-      subject.to_model.should be subject
+        expect(decorator.applied_decorators).to eq [Decorator, OtherDecorator, ProductDecorator]
+      end
     end
-  end
 
-  describe "#to_param" do
-    it "proxies to the source" do
-      source.stub(:to_param).and_return(42)
-      subject.to_param.should == 42
-    end
-  end
+    describe "#decorated_with?" do
+      it "checks if a decorator has been applied to a model" do
+        decorator = ProductDecorator.new(Decorator.new(Model.new))
 
-  describe "#==" do
-    context "with itself" do
-      it "returns true" do
-        (subject == subject).should be_true
+        expect(decorator).to be_decorated_with Decorator
+        expect(decorator).to be_decorated_with ProductDecorator
+        expect(decorator).not_to be_decorated_with OtherDecorator
       end
     end
 
-    context "with another decorator having the same source" do
+    describe "#decorated?" do
       it "returns true" do
-        (subject == ProductDecorator.new(source)).should be_true
+        decorator = Decorator.new(Model.new)
+
+        expect(decorator).to be_decorated
       end
     end
 
-    context "with another decorator having a different source" do
-      it "returns false" do
-        (subject == ProductDecorator.new(Object.new)).should be_false
+    describe "#source" do
+      it "returns the wrapped object" do
+        source = Model.new
+        decorator = Decorator.new(source)
+
+        expect(decorator.source).to be source
+        expect(decorator.model).to be source
+        expect(decorator.to_source).to be source
       end
     end
 
-    context "with the source object" do
-      it "returns true" do
-        (subject == source).should be_true
+    describe "#to_model" do
+      it "returns the decorator" do
+        decorator = Decorator.new(Model.new)
+
+        expect(decorator.to_model).to be decorator
       end
     end
 
-    context "with another object" do
-      it "returns false" do
-        (subject == Object.new).should be_false
+    describe "#to_param" do
+      it "delegates to the source" do
+        decorator = Decorator.new(double(to_param: :delegated))
+
+        expect(decorator.to_param).to be :delegated
       end
     end
-  end
 
-  describe "#===" do
-    context "with itself" do
-      it "returns true" do
-        (subject === subject).should be_true
+    describe "#present?" do
+      it "delegates to the source" do
+        decorator = Decorator.new(double(present?: :delegated))
+
+        expect(decorator.present?).to be :delegated
       end
     end
 
-    context "with another decorator having the same source" do
-      it "returns true" do
-        (subject === ProductDecorator.new(source)).should be_true
+    describe "#to_partial_path" do
+      it "delegates to the source" do
+        decorator = Decorator.new(double(to_partial_path: :delegated))
+
+        expect(decorator.to_partial_path).to be :delegated
       end
     end
 
-    context "with another decorator having a different source" do
-      it "returns false" do
-        (subject === ProductDecorator.new(Object.new)).should be_false
+    describe ".model_name" do
+      it "delegates to the source class" do
+        Decorator.stub source_class: double(model_name: :delegated)
+
+        expect(Decorator.model_name).to be :delegated
       end
     end
 
-    context "with the source object" do
-      it "returns true" do
-        (subject === source).should be_true
+    describe "#==" do
+      it "ensures the source has a decoration-aware #==" do
+        source = Object.new
+        decorator = Decorator.new(source)
+
+        expect(source).not_to be_a_kind_of Draper::Decoratable::Equality
+        decorator == :something
+        expect(source).to be_a_kind_of Draper::Decoratable::Equality
       end
-    end
 
-    context "with another object" do
-      it "returns false" do
-        (subject === Object.new).should be_false
+      it "is true when source #== is true" do
+        source = Model.new
+        decorator = Decorator.new(source)
+        other = double(source: Model.new)
+
+        source.should_receive(:==).with(other).and_return(true)
+        expect(decorator == other).to be_true
       end
-    end
-  end
 
-  describe ".delegate" do
-    subject { Class.new(Draper::Decorator) }
+      it "is false when source #== is false" do
+        source = Model.new
+        decorator = Decorator.new(source)
+        other = double(source: Model.new)
 
-    it "defaults the :to option to :source" do
-      Draper::Decorator.superclass.should_receive(:delegate).with(:foo, :bar, to: :source)
-      subject.delegate :foo, :bar
-    end
+        source.should_receive(:==).with(other).and_return(false)
+        expect(decorator == other).to be_false
+      end
 
-    it "does not overwrite the :to option if supplied" do
-      Draper::Decorator.superclass.should_receive(:delegate).with(:foo, :bar, to: :baz)
-      subject.delegate :foo, :bar, to: :baz
     end
-  end
 
-  describe ".delegate_all" do
-    let(:decorator_class) { Class.new(ProductDecorator) }
-    before { decorator_class.delegate_all }
+    describe "#===" do
+      it "is true when #== is true" do
+        decorator = Decorator.new(Model.new)
+        decorator.stub(:==).with(:anything).and_return(true)
 
-    describe "#method_missing" do
-      it "does not delegate methods that are defined on the decorator" do
-        subject.overridable.should be :overridden
+        expect(decorator === :anything).to be_true
       end
 
-      it "does not delegate methods inherited from Object" do
-        subject.inspect.should_not be source.inspect
-      end
+      it "is false when #== is false" do
+        decorator = Decorator.new(Model.new)
+        decorator.stub(:==).with(:anything).and_return(false)
 
-      it "delegates missing methods that exist on the source" do
-        source.stub(:hello_world).and_return(:delegated)
-        subject.hello_world.should be :delegated
+        expect(decorator === :anything).to be_false
       end
+    end
 
-      it "adds delegated methods to the decorator when they are used" do
-        subject.methods.should_not include :hello_world
-        subject.hello_world
-        subject.methods.should include :hello_world
-      end
+    describe ".delegate" do
+      protect_class Decorator
 
-      it "passes blocks to delegated methods" do
-        subject.block{"marker"}.should == "marker"
+      it "defaults the :to option to :source" do
+        Object.should_receive(:delegate).with(:foo, :bar, to: :source)
+        Decorator.delegate :foo, :bar
       end
 
-      it "does not confuse Kernel#Array" do
-        Array(subject).should be_a Array
+      it "does not overwrite the :to option if supplied" do
+        Object.should_receive(:delegate).with(:foo, :bar, to: :baz)
+        Decorator.delegate :foo, :bar, to: :baz
       end
+    end
 
-      it "delegates already-delegated methods" do
-        subject.delegated_method.should == "Yay, delegation"
-      end
+    context "with .delegate_all" do
+      protect_class Decorator
 
-      it "does not delegate private methods" do
-        expect{subject.private_title}.to raise_error NoMethodError
-      end
-    end
+      before { Decorator.delegate_all }
 
-    context ".method_missing" do
-      subject { decorator_class }
+      describe "#method_missing" do
+        it "delegates missing methods that exist on the source" do
+          decorator = Decorator.new(double(hello_world: :delegated))
 
-      context "without a source class" do
-        it "raises a NoMethodError on missing methods" do
-          expect{subject.hello_world}.to raise_error NoMethodError
+          expect(decorator.hello_world).to be :delegated
         end
-      end
 
-      context "with a source class" do
-        let(:source_class) { Product }
-        before { subject.decorates source_class }
+        it "adds delegated methods to the decorator when they are used" do
+          decorator = Decorator.new(double(hello_world: :delegated))
 
-        it "does not delegate methods that are defined on the decorator" do
-          subject.overridable.should be :overridden
+          expect(decorator.methods).not_to include :hello_world
+          decorator.hello_world
+          expect(decorator.methods).to include :hello_world
         end
 
-        it "delegates missing methods that exist on the source" do
-          source_class.stub(:hello_world).and_return(:delegated)
-          subject.hello_world.should be :delegated
+        it "passes blocks to delegated methods" do
+          source = Model.new
+          source.stub(:hello_world).and_return{|*args, &block| block.call}
+          decorator = Decorator.new(source)
+
+          expect(decorator.hello_world{:yielded}).to be :yielded
         end
-      end
-    end
 
-    describe "#respond_to?" do
-      it "returns true for its own methods" do
-        subject.should respond_to :awesome_title
-      end
+        it "does not confuse Kernel#Array" do
+          decorator = Decorator.new(Model.new)
 
-      it "returns true for the source's methods" do
-        subject.should respond_to :title
-      end
+          expect(Array(decorator)).to be_an Array
+        end
+
+        it "delegates already-delegated methods" do
+          source = Class.new{ delegate :bar, to: :foo }.new
+          source.stub foo: double(bar: :delegated)
+          decorator = Decorator.new(source)
 
-      context "with include_private" do
-        it "returns true for its own private methods" do
-          subject.respond_to?(:awesome_private_title, true).should be_true
+          expect(decorator.bar).to be :delegated
         end
 
-        it "returns false for the source's private methods" do
-          subject.respond_to?(:private_title, true).should be_false
+        it "does not delegate private methods" do
+          source = Class.new{ private; def hello_world; end }.new
+          decorator = Decorator.new(source)
+
+          expect{decorator.hello_world}.to raise_error NoMethodError
         end
-      end
-    end
 
-    describe ".respond_to?" do
-      subject { decorator_class }
+        it "does not delegate methods that do not exist on the source" do
+          decorator = Decorator.new(Model.new)
+
+          expect(decorator.methods).not_to include :hello_world
+          expect{decorator.hello_world}.to raise_error NoMethodError
+          expect(decorator.methods).not_to include :hello_world
+        end
+      end
 
-      context "without a source class" do
-        it "returns true for its own class methods" do
-          subject.should respond_to :my_class_method
+      context ".method_missing" do
+        context "without a source class" do
+          it "raises a NoMethodError on missing methods" do
+            expect{Decorator.hello_world}.to raise_error NoMethodError
+          end
         end
 
-        it "returns false for other class methods" do
-          subject.should_not respond_to :sample_class_method
+        context "with a source class" do
+          it "delegates methods that exist on the source class" do
+            source_class = Class.new
+            source_class.stub hello_world: :delegated
+            Decorator.stub source_class: source_class
+
+            expect(Decorator.hello_world).to be :delegated
+          end
+
+          it "does not delegate methods that do not exist on the source class" do
+            Decorator.stub source_class: Class.new
+
+            expect{Decorator.hello_world}.to raise_error NoMethodError
+          end
         end
       end
 
-      context "with a source_class" do
-        before { subject.decorates :product }
+      describe "#respond_to?" do
+        it "returns true for its own methods" do
+          Decorator.class_eval{def hello_world; end}
+          decorator = Decorator.new(Model.new)
+
+          expect(decorator).to respond_to :hello_world
+        end
+
+        it "returns true for the source's methods" do
+          decorator = Decorator.new(double(hello_world: :delegated))
 
-        it "returns true for its own class methods" do
-          subject.should respond_to :my_class_method
+          expect(decorator).to respond_to :hello_world
         end
 
-        it "returns true for the source's class methods" do
-          subject.should respond_to :sample_class_method
+        context "with include_private" do
+          it "returns true for its own private methods" do
+            Decorator.class_eval{private; def hello_world; end}
+            decorator = Decorator.new(Model.new)
+
+            expect(decorator.respond_to?(:hello_world, true)).to be_true
+          end
+
+          it "returns false for the source's private methods" do
+            source = Class.new{private; def hello_world; end}.new
+            decorator = Decorator.new(source)
+
+            expect(decorator.respond_to?(:hello_world, true)).to be_false
+          end
         end
       end
-    end
-  end
 
-  context "in a Rails application" do
-    let(:decorator_class) { DecoratorWithApplicationHelper }
+      describe ".respond_to?" do
+        context "without a source class" do
+          it "returns true for its own class methods" do
+            Decorator.class_eval{def self.hello_world; end}
 
-    it "has access to ApplicationHelper helpers" do
-      subject.uses_hello_world.should == "Hello, World!"
-    end
+            expect(Decorator).to respond_to :hello_world
+          end
 
-    it "is able to use the content_tag helper" do
-      subject.sample_content.to_s.should == "<span>Hello, World!</span>"
-    end
+          it "returns false for other class methods" do
+            expect(Decorator).not_to respond_to :goodnight_moon
+          end
+        end
 
-    it "is able to use the link_to helper" do
-      subject.sample_link.should == %{<a href="/World">Hello</a>}
-    end
+        context "with a source class" do
+          it "returns true for its own class methods" do
+            Decorator.class_eval{def self.hello_world; end}
+            Decorator.stub source_class: Class.new
 
-    it "is able to use the truncate helper" do
-      subject.sample_truncate.should == "Once..."
-    end
+            expect(Decorator).to respond_to :hello_world
+          end
+
+          it "returns true for the source's class methods" do
+            Decorator.stub source_class: double(hello_world: :delegated)
 
-    it "is able to access html_escape, a private method" do
-      subject.sample_html_escaped_text.should == '&lt;script&gt;danger&lt;/script&gt;'
+            expect(Decorator).to respond_to :hello_world
+          end
+        end
+      end
     end
-  end
 
-  it "pretends to be the source class" do
-    subject.kind_of?(source.class).should be_true
-    subject.is_a?(source.class).should be_true
-  end
+    describe "class spoofing" do
+      it "pretends to be a kind of the source class" do
+        decorator = Decorator.new(Model.new)
 
-  it "is still its own class" do
-    subject.kind_of?(subject.class).should be_true
-    subject.is_a?(subject.class).should be_true
-  end
+        expect(decorator.kind_of?(Model)).to be_true
+        expect(decorator.is_a?(Model)).to be_true
+      end
 
-  it "pretends to be an instance of the source class" do
-    subject.instance_of?(source.class).should be_true
-  end
+      it "is still a kind of its own class" do
+        decorator = Decorator.new(Model.new)
 
-  it "is still an instance of its own class" do
-    subject.instance_of?(subject.class).should be_true
-  end
+        expect(decorator.kind_of?(Decorator)).to be_true
+        expect(decorator.is_a?(Decorator)).to be_true
+      end
+
+      it "pretends to be an instance of the source class" do
+        decorator = Decorator.new(Model.new)
+
+        expect(decorator.instance_of?(Model)).to be_true
+      end
+
+      it "is still an instance of its own class" do
+        decorator = Decorator.new(Model.new)
 
-  describe ".decorates_finders" do
-    it "extends the Finders module" do
-      ProductDecorator.should be_a_kind_of Draper::Finders
+        expect(decorator.instance_of?(Decorator)).to be_true
+      end
     end
-  end
 
-  describe "#serializable_hash" do
-    let(:decorator_class) { ProductDecorator }
+    describe ".decorates_finders" do
+      protect_class Decorator
 
-    it "serializes overridden attributes" do
-      subject.serializable_hash[:overridable].should be :overridden
+      it "extends the Finders module" do
+        expect(Decorator).not_to be_a_kind_of Finders
+        Decorator.decorates_finders
+        expect(Decorator).to be_a_kind_of Finders
+      end
     end
-  end
 
+  end
 end