draper 0.18.0 → 1.0.0

data/spec/draper/collection_decorator_spec.rb

@@ -0,0 +1,286 @@
+require 'spec_helper'
+
+describe Draper::CollectionDecorator do
+  before { ApplicationController.new.view_context }
+  subject { Draper::CollectionDecorator.new(source, with: ProductDecorator) }
+  let(:source){ [Product.new, Product.new] }
+  let(:non_active_model_source){ NonActiveModelProduct.new }
+
+  it "decorates a collection's items" do
+    subject.each do |item|
+      item.should be_decorated_with ProductDecorator
+    end
+  end
+
+  it "sets the decorated items' source models" do
+    subject.map{|item| item.source}.should == source
+  end
+
+  context "with context" do
+    subject { Draper::CollectionDecorator.new(source, with: ProductDecorator, context: {some: 'context'}) }
+
+    its(:context) { should == {some: 'context'} }
+
+    it "passes context to the individual decorators" do
+      subject.each do |item|
+        item.context.should == {some: 'context'}
+      end
+    end
+
+    it "does not tie the individual decorators' contexts together" do
+      subject.each do |item|
+        item.context.should == {some: 'context'}
+        item.context = {alt: 'context'}
+        item.context.should == {alt: 'context'}
+      end
+    end
+
+    describe "#context=" do
+      it "updates the collection decorator's context" do
+        subject.context = {other: 'context'}
+        subject.context.should == {other: 'context'}
+      end
+
+      context "when the collection is already decorated" do
+        it "updates the items' context" do
+          subject.decorated_collection
+          subject.context = {other: 'context'}
+          subject.each do |item|
+            item.context.should == {other: 'context'}
+          end
+        end
+      end
+
+      context "when the collection has not yet been decorated" do
+        it "does not trigger decoration" do
+          subject.should_not_receive(:decorated_collection)
+          subject.context = {other: 'context'}
+        end
+
+        it "sets context after decoration is triggered" do
+          subject.context = {other: 'context'}
+          subject.each do |item|
+            item.context.should == {other: 'context'}
+          end
+        end
+      end
+    end
+  end
+
+  describe "#initialize" do
+    describe "options validation" do
+      let(:valid_options) { {with: ProductDecorator, context: {}} }
+
+      it "does not raise error on valid options" do
+        expect { Draper::CollectionDecorator.new(source, valid_options) }.to_not raise_error
+      end
+
+      it "raises error on invalid options" do
+        expect { Draper::CollectionDecorator.new(source, valid_options.merge(foo: 'bar')) }.to raise_error(ArgumentError, /Unknown key/)
+      end
+    end
+  end
+
+  describe "item decoration" do
+    subject { subject_class.new(source, options) }
+    let(:decorator_classes) { subject.decorated_collection.map(&:class) }
+    let(:source) { [Product.new, Widget.new] }
+
+    context "when the :with option was given" do
+      let(:options) { {with: SpecificProductDecorator} }
+
+      context "and the decorator can't be inferred from the class" do
+        let(:subject_class) { Draper::CollectionDecorator }
+
+        it "uses the :with option" do
+          decorator_classes.should == [SpecificProductDecorator, SpecificProductDecorator]
+        end
+      end
+
+      context "and the decorator is inferrable from the class" do
+        let(:subject_class) { ProductsDecorator }
+
+        it "uses the :with option" do
+          decorator_classes.should == [SpecificProductDecorator, SpecificProductDecorator]
+        end
+      end
+    end
+
+    context "when the :with option was not given" do
+      let(:options) { {} }
+
+      context "and the decorator can't be inferred from the class" do
+        let(:subject_class) { Draper::CollectionDecorator }
+
+        it "infers the decorator from each item" do
+          decorator_classes.should == [ProductDecorator, WidgetDecorator]
+        end
+      end
+
+      context "and the decorator is inferrable from the class" do
+        let(:subject_class) { ProductsDecorator}
+
+        it "infers the decorator" do
+          decorator_classes.should == [ProductDecorator, ProductDecorator]
+        end
+      end
+    end
+  end
+
+  describe ".delegate" do
+    subject { Class.new(Draper::CollectionDecorator) }
+
+    it "defaults the :to option to :source" do
+      Draper::CollectionDecorator.superclass.should_receive(:delegate).with(:foo, :bar, to: :source)
+      subject.delegate :foo, :bar
+    end
+
+    it "does not overwrite the :to option if supplied" do
+      Draper::CollectionDecorator.superclass.should_receive(:delegate).with(:foo, :bar, to: :baz)
+      subject.delegate :foo, :bar, to: :baz
+    end
+  end
+
+  describe "#find" do
+    context "with a block" do
+      it "decorates Enumerable#find" do
+        subject.decorated_collection.should_receive(:find)
+        subject.find {|p| p.title == "title" }
+      end
+    end
+
+    context "without a block" do
+      it "decorates Model.find" do
+        source.should_not_receive(:find)
+        Product.should_receive(:find).with(1).and_return(:product)
+        subject.find(1).should == ProductDecorator.new(:product)
+      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
+
+    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
+
+  describe "#localize" do
+    before { subject.helpers.should_receive(:localize).with(:an_object, {some: 'parameter'}) }
+
+    it "delegates to helpers" do
+      subject.localize(:an_object, some: 'parameter')
+    end
+
+    it "is aliased to #l" do
+      subject.l(:an_object, some: 'parameter')
+    end
+  end
+
+  describe ".helpers" do
+    it "returns a HelperProxy" do
+      subject.class.helpers.should be_a Draper::HelperProxy
+    end
+
+    it "is aliased to .h" do
+      subject.class.h.should be subject.class.helpers
+    end
+  end
+
+  describe "#to_ary" do
+    # required for `render @collection` in Rails
+    it "delegates to the decorated collection" do
+      subject.decorated_collection.stub to_ary: :an_array
+      subject.to_ary.should == :an_array
+    end
+  end
+
+  it "delegates array methods to the decorated collection" do
+    subject.decorated_collection.should_receive(:[]).with(42).and_return(:the_answer)
+    subject[42].should == :the_answer
+  end
+
+  describe "#==" do
+    context "when comparing to a collection decorator with the same source" do
+      it "returns true" do
+        a = Draper::CollectionDecorator.new(source, with: ProductDecorator)
+        b = ProductsDecorator.new(source)
+        a.should == b
+      end
+    end
+
+    context "when comparing to a collection decorator with a different source" do
+      it "returns false" do
+        a = Draper::CollectionDecorator.new(source, with: ProductDecorator)
+        b = ProductsDecorator.new([Product.new])
+        a.should_not == b
+      end
+    end
+
+    context "when comparing to a collection of the same items" do
+      it "returns true" do
+        a = Draper::CollectionDecorator.new(source, with: ProductDecorator)
+        b = source.dup
+        a.should == b
+      end
+    end
+
+    context "when comparing to a collection of different items" do
+      it "returns true" do
+        a = Draper::CollectionDecorator.new(source, with: ProductDecorator)
+        b = [Product.new]
+        a.should_not == b
+      end
+    end
+
+    context "when the decorated collection has been modified" do
+      it "is no longer equal to the source" do
+        a = Draper::CollectionDecorator.new(source, with: ProductDecorator)
+        b = source.dup
+
+        a << Product.new.decorate
+        a.should_not == b
+      end
+    end
+  end
+
+  describe "#to_s" do
+    subject { Draper::CollectionDecorator.new(source, options) }
+    let(:source) { ["a", "b", "c"] }
+
+    context "when :with option was given" do
+      let(:options) { {with: ProductDecorator} }
+
+      it "returns a string representation of the CollectionDecorator" do
+        subject.to_s.should == '#<Draper::CollectionDecorator of ProductDecorator for ["a", "b", "c"]>'
+      end
+    end
+
+    context "when :with option was not given" do
+      let(:options) { {} }
+
+      it "returns a string representation of the CollectionDecorator" do
+        subject.to_s.should == '#<Draper::CollectionDecorator of inferred decorators for ["a", "b", "c"]>'
+      end
+    end
+
+    context "for a custom subclass" do
+      subject { ProductsDecorator.new(source) }
+
+      it "uses the custom class name" do
+        subject.to_s.should =~ /ProductsDecorator/
+      end
+    end
+  end
+
+end

data/spec/draper/decoratable_spec.rb

@@ -0,0 +1,192 @@
+require 'spec_helper'
+
+describe Draper::Decoratable do
+  subject { Product.new }
+
+  describe "#decorate" do
+    it "returns a decorator for self" do
+     subject.decorate.should be_a ProductDecorator
+     subject.decorate.source.should be subject
+   end
+
+    it "accepts context" do
+      decorator = subject.decorate(context: {some: 'context'})
+      decorator.context.should == {some: 'context'}
+    end
+
+    it "is not memoized" do
+      subject.decorate.should_not be subject.decorate
+    end
+  end
+
+  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
+
+  describe "#decorated?" do
+    it "returns false" do
+      subject.should_not be_decorated
+    end
+  end
+
+  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
+      end
+    end
+
+    context "with another instance" do
+      it "returns false" do
+        (subject == Product.new).should be_false
+      end
+    end
+
+    context "with a decorated version of itself" do
+      it "returns true" do
+        decorator = double(source: subject)
+        (subject == decorator).should 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
+      end
+    end
+  end
+
+  describe "#===" do
+    context "with itself" do
+      it "returns true" do
+        (subject === subject).should be_true
+      end
+    end
+
+    context "with another instance" do
+      it "returns false" do
+        (subject === Product.new).should be_false
+      end
+    end
+
+    context "with a decorated version of itself" do
+      it "returns true" do
+        decorator = double(source: subject)
+        (subject === decorator).should 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
+      end
+    end
+  end
+
+  describe ".====" do
+    context "with an instance" do
+      it "returns true" do
+        (Product === Product.new).should be_true
+      end
+    end
+
+    context "with a derived instance" do
+      it "returns true" do
+        (Product === Widget.new).should be_true
+      end
+    end
+
+    context "with an unrelated instance" do
+      it "returns false" do
+        (Product === Object.new).should be_false
+      end
+    end
+
+    context "with a decorated instance" do
+      it "returns true" do
+        decorator = double(source: Product.new)
+        (Product === decorator).should 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
+      end
+    end
+
+    context "with a decorated unrelated instance" do
+      it "returns false" do
+        decorator = double(source: Object.new)
+        (Product === decorator).should 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
+
+      decorator.should be_a Draper::CollectionDecorator
+      decorator.decorator_class.should be WidgetDecorator
+      decorator.should == Product.scoped
+    end
+
+    it "accepts context" do
+      decorator = Product.decorate(context: {some: 'context'})
+      decorator.context.should == {some: 'context'}
+    end
+
+    it "is not memoized" do
+      Product.decorate.should_not be Product.decorate
+    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
+      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
+      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
+      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
+      end
+    end
+  end
+end

data/spec/draper/decorated_association_spec.rb

@@ -0,0 +1,142 @@
+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
+
+      it "raises error on invalid options" do
+        expect { Draper::DecoratedAssociation.new(owner, :association, valid_options.merge(foo: 'bar')) }.to raise_error(ArgumentError, /Unknown key/)
+      end
+    end
+  end
+
+  describe "#call" do
+    let(:context) { {foo: "bar"} }
+    let(:expected_options) { {context: context} }
+
+    before do
+      source.stub association: associated
+      decorated_association.stub context: context
+    end
+
+    context "for a singular association" do
+      let(:associated) { Product.new }
+      let(:decorator) { SpecificProductDecorator }
+
+      context "when :with option was given" do
+        let(:options) { {with: decorator} }
+
+        it "uses the specified decorator" do
+          decorator.should_receive(:decorate).with(associated, expected_options).and_return(:decorated)
+          decorated_association.call.should be :decorated
+        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
+        end
+      end
+    end
+
+    context "for a collection association" do
+      let(:associated) { [Product.new, Widget.new] }
+      let(:collection_decorator) { ProductsDecorator }
+
+      context "when :with option is a collection decorator" do
+        let(:options) { {with: collection_decorator} }
+
+        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
+        end
+      end
+
+      context "when :with option is a singular decorator" do
+        let(:options) { {with: decorator} }
+        let(:decorator) { SpecificProductDecorator }
+
+        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
+        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
+          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
+          end
+        end
+      end
+    end
+
+    context "with a scope" do
+      let(:associated) { [] }
+      let(:options) { {scope: :foo} }
+
+      it "applies the scope before decoration" do
+        scoped = [Product.new]
+        associated.should_receive(:foo).and_return(scoped)
+        decorated_association.call.should == scoped
+      end
+    end
+  end
+
+  describe "#context" do
+    before { owner.stub context: :owner_context }
+
+    context "when :context option was given" do
+      let(:options) { {context: 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 "returns the lambda's return value" do
+          decorated_association.context.should be :dynamic_context
+        end
+      end
+
+      context "and is not callable" do
+        let(:context) { :static_context }
+
+        it "returns the specified value" do
+          decorated_association.context.should be :static_context
+        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
+      end
+    end
+  end
+
+end