draper 1.0.0 → 1.1.0

data/spec/draper/decoratable/equality_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require 'support/shared_examples/decoratable_equality'
+
+module Draper
+  describe Decoratable::Equality do
+    describe "#==" do
+      it_behaves_like "decoration-aware #==", Object.new.extend(Decoratable::Equality)
+    end
+  end
+end

data/spec/draper/decoratable_spec.rb

@@ -1,192 +1,167 @@
 require 'spec_helper'
+require 'support/shared_examples/decoratable_equality'
 
-describe Draper::Decoratable do
-  subject { Product.new }
+module Draper
+  describe Decoratable do
 
-  describe "#decorate" do
-    it "returns a decorator for self" do
-     subject.decorate.should be_a ProductDecorator
-     subject.decorate.source.should be subject
-   end
+    describe "#decorate" do
+      it "returns a decorator for self" do
+        product = Product.new
+        decorator = product.decorate
 
-    it "accepts context" do
-      decorator = subject.decorate(context: {some: 'context'})
-      decorator.context.should == {some: 'context'}
-    end
+        expect(decorator).to be_a ProductDecorator
+        expect(decorator.source).to be product
+     end
 
-    it "is not memoized" do
-      subject.decorate.should_not be subject.decorate
-    end
-  end
+      it "accepts context" do
+        context = {some: "context"}
+        decorator = Product.new.decorate(context: context)
 
-  describe "#applied_decorators" do
-    it "returns an empty list" do
-      subject.applied_decorators.should be_empty
-    end
-  end
-
-  describe "#decorated_with?" do
-    it "returns false" do
-      subject.should_not be_decorated_with ProductDecorator
-    end
-  end
+        expect(decorator.context).to be context
+      end
 
-  describe "#decorated?" do
-    it "returns false" do
-      subject.should_not be_decorated
-    end
-  end
+      it "uses the #decorator_class" do
+        product = Product.new
+        product.stub decorator_class: OtherDecorator
 
-  describe "#decorator_class" do
-    it "delegates to .decorator_class" do
-      Product.stub(:decorator_class).and_return(WidgetDecorator)
-      product = Product.new
-      product.decorator_class.should be WidgetDecorator
-    end
-  end
-
-  describe "#==" do
-    context "with itself" do
-      it "returns true" do
-        (subject == subject).should be_true
+        expect(product.decorate).to be_an_instance_of OtherDecorator
       end
     end
 
-    context "with another instance" do
-      it "returns false" do
-        (subject == Product.new).should be_false
+    describe "#applied_decorators" do
+      it "returns an empty list" do
+        expect(Product.new.applied_decorators).to eq []
       end
     end
 
-    context "with a decorated version of itself" do
-      it "returns true" do
-        decorator = double(source: subject)
-        (subject == decorator).should be_true
+    describe "#decorated_with?" do
+      it "returns false" do
+        expect(Product.new).not_to be_decorated_with Decorator
       end
     end
 
-    context "with a decorated other instance" do
+    describe "#decorated?" do
       it "returns false" do
-        decorator = double(source: Product.new)
-        (subject == decorator).should be_false
+        expect(Product.new).not_to be_decorated
       end
     end
-  end
 
-  describe "#===" do
-    context "with itself" do
-      it "returns true" do
-        (subject === subject).should be_true
+    describe "#decorator_class" do
+      it "delegates to .decorator_class" do
+        product = Product.new
+
+        Product.should_receive(:decorator_class).and_return(:some_decorator)
+        expect(product.decorator_class).to be :some_decorator
       end
     end
 
-    context "with another instance" do
-      it "returns false" do
-        (subject === Product.new).should be_false
-      end
+    describe "#==" do
+      it_behaves_like "decoration-aware #==", Product.new
     end
 
-    context "with a decorated version of itself" do
-      it "returns true" do
-        decorator = double(source: subject)
-        (subject === decorator).should be_true
+    describe "#===" do
+      it "is true when #== is true" do
+        product = Product.new
+
+        product.should_receive(:==).and_return(true)
+        expect(product === :anything).to be_true
       end
-    end
 
-    context "with a decorated other instance" do
-      it "returns false" do
-        decorator = double(source: Product.new)
-        (subject === decorator).should be_false
+      it "is false when #== is false" do
+        product = Product.new
+
+        product.should_receive(:==).and_return(false)
+        expect(product === :anything).to be_false
       end
     end
-  end
 
-  describe ".====" do
-    context "with an instance" do
-      it "returns true" do
-        (Product === Product.new).should be_true
+    describe ".====" do
+      it "is true for an instance" do
+        expect(Product === Product.new).to be_true
       end
-    end
 
-    context "with a derived instance" do
-      it "returns true" do
-        (Product === Widget.new).should be_true
+      it "is true for a derived instance" do
+        expect(Product === Class.new(Product).new).to be_true
       end
-    end
 
-    context "with an unrelated instance" do
-      it "returns false" do
-        (Product === Object.new).should be_false
+      it "is false for an unrelated instance" do
+        expect(Product === Model.new).to be_false
       end
-    end
 
-    context "with a decorated instance" do
-      it "returns true" do
+      it "is true for a decorated instance" do
         decorator = double(source: Product.new)
-        (Product === decorator).should be_true
+
+        expect(Product === decorator).to be_true
       end
-    end
 
-    context "with a decorated derived instance" do
-      it "returns true" do
-        decorator = double(source: Widget.new)
-        (Product === decorator).should be_true
+      it "is true for a decorated derived instance" do
+        decorator = double(source: Class.new(Product).new)
+
+        expect(Product === decorator).to be_true
       end
-    end
 
-    context "with a decorated unrelated instance" do
-      it "returns false" do
-        decorator = double(source: Object.new)
-        (Product === decorator).should be_false
+      it "is false for a decorated unrelated instance" do
+        decorator = double(source: Model.new)
+
+        expect(Product === decorator).to be_false
       end
     end
-  end
 
-  describe ".decorate" do
-    it "returns a collection decorator" do
-      Product.stub(:scoped).and_return([Product.new])
-      Product.stub(:decorator_class).and_return(WidgetDecorator)
-      decorator = Product.decorate
+    describe ".decorate" do
+      it "calls #decorate_collection on .decorator_class" do
+        scoped = [Product.new]
+        Product.stub scoped: scoped
 
-      decorator.should be_a Draper::CollectionDecorator
-      decorator.decorator_class.should be WidgetDecorator
-      decorator.should == Product.scoped
-    end
+        Product.decorator_class.should_receive(:decorate_collection).with(scoped, {}).and_return(:decorated_collection)
+        expect(Product.decorate).to be :decorated_collection
+      end
 
-    it "accepts context" do
-      decorator = Product.decorate(context: {some: 'context'})
-      decorator.context.should == {some: 'context'}
-    end
+      it "accepts options" do
+        options = {context: {some: "context"}}
+        Product.stub scoped: []
 
-    it "is not memoized" do
-      Product.decorate.should_not be Product.decorate
+        Product.decorator_class.should_receive(:decorate_collection).with([], options)
+        Product.decorate(options)
+      end
     end
-  end
 
-  describe ".decorator_class" do
-    context "for non-ActiveModel classes" do
-      it "infers the decorator from the class" do
-        NonActiveModelProduct.decorator_class.should be NonActiveModelProductDecorator
+    describe ".decorator_class" do
+      context "for classes" do
+        it "infers the decorator from the class" do
+          expect(Product.decorator_class).to be ProductDecorator
+        end
       end
-    end
 
-    context "for ActiveModel classes" do
-      it "infers the decorator from the model name" do
-        Product.stub(:model_name).and_return("Widget")
-        Product.decorator_class.should be WidgetDecorator
+      context "for ActiveModel classes" do
+        it "infers the decorator from the model name" do
+          Product.stub(:model_name).and_return("Other")
+
+          expect(Product.decorator_class).to be OtherDecorator
+        end
       end
-    end
 
-    context "for namespaced ActiveModel classes" do
-      it "infers the decorator from the model name" do
-        Namespace::Product.decorator_class.should be Namespace::ProductDecorator
+      context "in a namespace" do
+        context "for classes" do
+          it "infers the decorator from the class" do
+            expect(Namespaced::Product.decorator_class).to be Namespaced::ProductDecorator
+          end
+        end
+
+        context "for ActiveModel classes" do
+          it "infers the decorator from the model name" do
+            Namespaced::Product.stub(:model_name).and_return("Namespaced::Other")
+
+            expect(Namespaced::Product.decorator_class).to be Namespaced::OtherDecorator
+          end
+        end
       end
-    end
 
-    context "when the decorator can't be inferred" do
-      it "throws an UninferrableDecoratorError" do
-        expect{UninferrableDecoratorModel.decorator_class}.to raise_error Draper::UninferrableDecoratorError
+      context "when the decorator can't be inferred" do
+        it "throws an UninferrableDecoratorError" do
+          expect{Model.decorator_class}.to raise_error UninferrableDecoratorError
+        end
       end
     end
+
   end
 end

data/spec/draper/decorated_association_spec.rb

@@ -1,142 +1,145 @@
 require 'spec_helper'
 
-describe Draper::DecoratedAssociation do
-  let(:decorated_association) { Draper::DecoratedAssociation.new(owner, :association, options) }
-  let(:source) { Product.new }
-  let(:owner) { source.decorate }
-  let(:options) { {} }
-
-  describe "#initialize" do
-    describe "options validation" do
-      let(:valid_options) { {with: ProductDecorator, scope: :foo, context: {}} }
-
-      it "does not raise error on valid options" do
-        expect { Draper::DecoratedAssociation.new(owner, :association, valid_options) }.to_not raise_error
-      end
+module Draper
+  describe DecoratedAssociation do
+
+    describe "#initialize" do
+      describe "options validation" do
+        it "does not raise error on valid options" do
+          valid_options = {with: Decorator, scope: :foo, context: {}}
+          expect{DecoratedAssociation.new(Decorator.new(Model.new), :association, valid_options)}.not_to raise_error
+        end
 
-      it "raises error on invalid options" do
-        expect { Draper::DecoratedAssociation.new(owner, :association, valid_options.merge(foo: 'bar')) }.to raise_error(ArgumentError, /Unknown key/)
+        it "raises error on invalid options" do
+          expect{DecoratedAssociation.new(Decorator.new(Model.new), :association, foo: "bar")}.to raise_error ArgumentError, /Unknown key/
+        end
       end
     end
-  end
 
-  describe "#call" do
-    let(:context) { {foo: "bar"} }
-    let(:expected_options) { {context: context} }
+    describe "#call" do
+      let(:context) { {some: "context"} }
+      let(:options) { {} }
 
-    before do
-      source.stub association: associated
-      decorated_association.stub context: context
-    end
+      let(:decorated_association) do
+        owner = double(context: nil, source: double(association: associated))
 
-    context "for a singular association" do
-      let(:associated) { Product.new }
-      let(:decorator) { SpecificProductDecorator }
+        DecoratedAssociation.new(owner, :association, options).tap do |decorated_association|
+          decorated_association.stub context: context
+        end
+      end
 
-      context "when :with option was given" do
-        let(:options) { {with: decorator} }
+      context "for a singular association" do
+        let(:associated) { Model.new }
 
-        it "uses the specified decorator" do
-          decorator.should_receive(:decorate).with(associated, expected_options).and_return(:decorated)
-          decorated_association.call.should be :decorated
+        context "when :with option was given" do
+          let(:options) { {with: Decorator} }
+
+          it "uses the specified decorator" do
+            Decorator.should_receive(:decorate).with(associated, context: context).and_return(:decorated)
+            expect(decorated_association.call).to be :decorated
+          end
         end
-      end
 
-      context "when :with option was not given" do
-        it "infers the decorator" do
-          associated.stub(:decorator_class).and_return(decorator)
-          decorator.should_receive(:decorate).with(associated, expected_options).and_return(:decorated)
-          decorated_association.call.should be :decorated
+        context "when :with option was not given" do
+          it "infers the decorator" do
+            associated.stub decorator_class: OtherDecorator
+
+            OtherDecorator.should_receive(:decorate).with(associated, context: context).and_return(:decorated)
+            expect(decorated_association.call).to be :decorated
+          end
         end
       end
-    end
 
-    context "for a collection association" do
-      let(:associated) { [Product.new, Widget.new] }
-      let(:collection_decorator) { ProductsDecorator }
+      context "for a collection association" do
+        let(:associated) { [] }
 
-      context "when :with option is a collection decorator" do
-        let(:options) { {with: collection_decorator} }
+        context "when :with option is a collection decorator" do
+          let(:options) { {with: ProductsDecorator} }
 
-        it "uses the specified decorator" do
-          collection_decorator.should_receive(:decorate).with(associated, expected_options).and_return(:decorated_collection)
-          decorated_association.call.should be :decorated_collection
+          it "uses the specified decorator" do
+            ProductsDecorator.should_receive(:decorate).with(associated, context: context).and_return(:decorated_collection)
+            expect(decorated_association.call).to be :decorated_collection
+          end
         end
-      end
 
-      context "when :with option is a singular decorator" do
-        let(:options) { {with: decorator} }
-        let(:decorator) { SpecificProductDecorator }
+        context "when :with option is a singular decorator" do
+          let(:options) { {with: ProductDecorator} }
 
-        it "uses a CollectionDecorator of the specified decorator" do
-          decorator.should_receive(:decorate_collection).with(associated, expected_options).and_return(:decorated_collection)
-          decorated_association.call.should be :decorated_collection
+          it "uses a CollectionDecorator of the specified decorator" do
+            ProductDecorator.should_receive(:decorate_collection).with(associated, context: context).and_return(:decorated_collection)
+            expect(decorated_association.call).to be :decorated_collection
+          end
         end
-      end
 
-      context "when :with option was not given" do
-        context "when the collection is decoratable" do
-          it "infers the decorator" do
-            associated.stub(:decorator_class).and_return(collection_decorator)
-            collection_decorator.should_receive(:decorate).with(associated, expected_options).and_return(:decorated_collection)
-            decorated_association.call.should be :decorated_collection
+        context "when :with option was not given" do
+          context "when the collection itself is decoratable" do
+            before { associated.stub decorator_class: ProductsDecorator }
+
+            it "infers the decorator" do
+              ProductsDecorator.should_receive(:decorate).with(associated, context: context).and_return(:decorated_collection)
+              expect(decorated_association.call).to be :decorated_collection
+            end
           end
-        end
 
-        context "when the collection is not decoratable" do
-          it "uses a CollectionDecorator of inferred decorators" do
-            Draper::CollectionDecorator.should_receive(:decorate).with(associated, expected_options).and_return(:decorated_collection)
-            decorated_association.call.should be :decorated_collection
+          context "when the collection is not decoratable" do
+            it "uses a CollectionDecorator of inferred decorators" do
+              CollectionDecorator.should_receive(:decorate).with(associated, context: context).and_return(:decorated_collection)
+              expect(decorated_association.call).to be :decorated_collection
+            end
           end
         end
       end
-    end
 
-    context "with a scope" do
-      let(:associated) { [] }
-      let(:options) { {scope: :foo} }
+      context "with a scope" do
+        let(:options) { {scope: :foo} }
+        let(:associated) { double(foo: scoped) }
+        let(:scoped) { Product.new }
 
-      it "applies the scope before decoration" do
-        scoped = [Product.new]
-        associated.should_receive(:foo).and_return(scoped)
-        decorated_association.call.should == scoped
+        it "applies the scope before decoration" do
+          expect(decorated_association.call.source).to be scoped
+        end
       end
     end
-  end
 
-  describe "#context" do
-    before { owner.stub context: :owner_context }
+    describe "#context" do
+      let(:owner_context) { {some: "context"} }
+      let(:options) { {} }
+      let(:decorated_association) do
+        owner = double(context: owner_context)
+        DecoratedAssociation.new(owner, :association, options)
+      end
 
-    context "when :context option was given" do
-      let(:options) { {context: context} }
+      context "when :context option was given" do
+        let(:options) { {context: context} }
 
-      context "and is callable" do
-        let(:context) { ->(*){ :dynamic_context } }
+        context "and is callable" do
+          let(:context) { ->(*){ :dynamic_context } }
 
-        it "calls it with the owner's context" do
-          context.should_receive(:call).with(:owner_context)
-          decorated_association.context
-        end
+          it "calls it with the owner's context" do
+            context.should_receive(:call).with(owner_context)
+            decorated_association.context
+          end
 
-        it "returns the lambda's return value" do
-          decorated_association.context.should be :dynamic_context
+          it "returns the lambda's return value" do
+            expect(decorated_association.context).to be :dynamic_context
+          end
         end
-      end
 
-      context "and is not callable" do
-        let(:context) { :static_context }
+        context "and is not callable" do
+          let(:context) { {other: "context"} }
 
-        it "returns the specified value" do
-          decorated_association.context.should be :static_context
+          it "returns the specified value" do
+            expect(decorated_association.context).to be context
+          end
         end
       end
-    end
 
-    context "when :context option was not given" do
-      it "returns the owner's context" do
-        decorated_association.context.should be :owner_context
+      context "when :context option was not given" do
+        it "returns the owner's context" do
+          expect(decorated_association.context).to be owner_context
+        end
       end
     end
-  end
 
+  end
 end