draper 1.1.0 → 1.2.0

data/lib/draper/version.rb

@@ -1,3 +1,3 @@
 module Draper
-  VERSION = "1.1.0"
+  VERSION = "1.2.0"
 end

data/lib/generators/decorator/decorator_generator.rb

@@ -2,9 +2,9 @@ module Rails
   module Generators
    class DecoratorGenerator < NamedBase
       source_root File.expand_path("../templates", __FILE__)
-      check_class_collision :suffix => "Decorator"
+      check_class_collision suffix: "Decorator"
 
-      class_option :parent, :type => :string, :desc => "The parent class for the generated decorator"
+      class_option :parent, type: :string, desc: "The parent class for the generated decorator"
 
       def create_decorator_file
         template 'decorator.rb', File.join('app/decorators', class_path, "#{file_name}_decorator.rb")
@@ -15,16 +15,16 @@ module Rails
       private
 
       def parent_class_name
-        if options[:parent]
-          options[:parent]
-        elsif defined?(ApplicationDecorator)
-          "ApplicationDecorator"
-        else
-          "Draper::Decorator"
+        options.fetch("parent") do
+          begin
+            require 'application_decorator'
+            ApplicationDecorator
+          rescue LoadError
+            "Draper::Decorator"
+          end
         end
       end
 
-      	
       # Rails 3.0.X compatibility, stolen from https://github.com/jnunemaker/mongomapper/pull/385/files#L1R32
       unless methods.include?(:module_namespacing)
         def module_namespacing(&block)

data/spec/draper/collection_decorator_spec.rb

@@ -89,39 +89,19 @@ module Draper
         end
       end
 
-      context "when the item decorator is inferrable from the collection decorator" do
-        context "when the :with option was given" do
-          it "uses the :with option" do
-            decorator = ProductsDecorator.new([Product.new], with: OtherDecorator)
+      context "when the :with option was given" do
+        it "uses the :with option" do
+          decorator = CollectionDecorator.new([Product.new], with: OtherDecorator).first
 
-            expect(*decorator).to be_decorated_with OtherDecorator
-          end
-        end
-
-        context "when the :with option was not given" do
-          it "infers the item decorator from the collection decorator" do
-            decorator = ProductsDecorator.new([Product.new])
-
-            expect(*decorator).to be_decorated_with ProductDecorator
-          end
+          expect(decorator).to be_decorated_with OtherDecorator
         end
       end
 
-      context "when the item decorator is not inferrable from the collection decorator" do
-        context "when the :with option was given" do
-          it "uses the :with option" do
-            decorator = CollectionDecorator.new([Product.new], with: OtherDecorator)
-
-            expect(*decorator).to be_decorated_with OtherDecorator
-          end
-        end
-
-        context "when the :with option was not given" do
-          it "infers the item decorator from each item" do
-            decorator = CollectionDecorator.new([double(decorate: :inferred_decorator)])
+      context "when the :with option was not given" do
+        it "infers the item decorator from each item" do
+          decorator = CollectionDecorator.new([double(decorate: :inferred_decorator)]).first
 
-            expect(*decorator).to be :inferred_decorator
-          end
+          expect(decorator).to be :inferred_decorator
         end
       end
     end
@@ -255,5 +235,45 @@ module Draper
       end
     end
 
+    describe '#decorated?' do
+      it 'returns true' do
+        decorator = ProductsDecorator.new([Product.new])
+
+        expect(decorator).to be_decorated
+      end
+    end
+
+    describe '#decorated_with?' do
+      it "checks if a decorator has been applied to a collection" do
+        decorator = ProductsDecorator.new([Product.new])
+
+        expect(decorator).to be_decorated_with ProductsDecorator
+        expect(decorator).not_to be_decorated_with OtherDecorator
+      end
+    end
+
+    describe '#kind_of?' do
+      it 'asks the kind of its decorated collection' do
+        decorator = ProductsDecorator.new([])
+        decorator.decorated_collection.should_receive(:kind_of?).with(Array).and_return("true")
+        expect(decorator.kind_of?(Array)).to eq "true"
+      end
+
+      context 'when asking the underlying collection returns false' do
+        it 'asks the CollectionDecorator instance itself' do
+          decorator = ProductsDecorator.new([])
+          decorator.decorated_collection.stub(:kind_of?).with(::Draper::CollectionDecorator).and_return(false)
+          expect(decorator.kind_of?(::Draper::CollectionDecorator)).to be true
+        end
+      end
+    end
+
+    describe '#is_a?' do
+      it 'aliases to #kind_of?' do
+        decorator = ProductsDecorator.new([])
+        expect(decorator.method(:kind_of?)).to eq decorator.method(:is_a?)
+      end
+    end
+
   end
 end

data/spec/draper/decoratable_spec.rb

@@ -108,17 +108,19 @@ module Draper
     end
 
     describe ".decorate" do
+      let(:scoping_method) { Rails::VERSION::MAJOR >= 4 ? :all : :scoped }
+
       it "calls #decorate_collection on .decorator_class" do
         scoped = [Product.new]
-        Product.stub scoped: scoped
+        Product.stub scoping_method => scoped
 
-        Product.decorator_class.should_receive(:decorate_collection).with(scoped, {}).and_return(:decorated_collection)
+        Product.decorator_class.should_receive(:decorate_collection).with(scoped, with: nil).and_return(:decorated_collection)
         expect(Product.decorate).to be :decorated_collection
       end
 
       it "accepts options" do
-        options = {context: {some: "context"}}
-        Product.stub scoped: []
+        options = {with: ProductDecorator, context: {some: "context"}}
+        Product.stub scoping_method => []
 
         Product.decorator_class.should_receive(:decorate_collection).with([], options)
         Product.decorate(options)
@@ -161,6 +163,13 @@ module Draper
           expect{Model.decorator_class}.to raise_error UninferrableDecoratorError
         end
       end
+
+      context "when an unrelated NameError is thrown" do
+        it "re-raises that error" do
+          String.any_instance.stub(:constantize).and_return{Draper::Base}
+          expect{Product.decorator_class}.to raise_error NameError, /Draper::Base/
+        end
+      end
     end
 
   end

data/spec/draper/decorated_association_spec.rb

@@ -4,139 +4,78 @@ 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{DecoratedAssociation.new(Decorator.new(Model.new), :association, foo: "bar")}.to raise_error ArgumentError, /Unknown key/
-        end
+      it "accepts 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
-    end
-
-    describe "#call" do
-      let(:context) { {some: "context"} }
-      let(:options) { {} }
 
-      let(:decorated_association) do
-        owner = double(context: nil, source: double(association: associated))
-
-        DecoratedAssociation.new(owner, :association, options).tap do |decorated_association|
-          decorated_association.stub context: context
-        end
+      it "rejects invalid options" do
+        expect{DecoratedAssociation.new(Decorator.new(Model.new), :association, foo: "bar")}.to raise_error ArgumentError, /Unknown key/
       end
 
-      context "for a singular association" do
-        let(:associated) { Model.new }
-
-        context "when :with option was given" do
-          let(:options) { {with: Decorator} }
+      it "creates a factory" do
+        options = {with: Decorator, context: {foo: "bar"}}
 
-          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
-
-        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
+        Factory.should_receive(:new).with(options)
+        DecoratedAssociation.new(double, :association, options)
       end
 
-      context "for a collection association" do
-        let(:associated) { [] }
-
-        context "when :with option is a collection decorator" do
-          let(:options) { {with: ProductsDecorator} }
-
-          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
-
-        context "when :with option is a singular decorator" do
-          let(:options) { {with: ProductDecorator} }
-
-          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
-
-        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
-
-          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
+      describe ":with option" do
+        it "defaults to nil" do
+          Factory.should_receive(:new).with(with: nil, context: anything())
+          DecoratedAssociation.new(double, :association, {})
         end
       end
 
-      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
-          expect(decorated_association.call.source).to be scoped
+      describe ":context option" do
+        it "defaults to the identity function" do
+          Factory.should_receive(:new).with do |options|
+            options[:context].call(:anything) == :anything
+          end
+          DecoratedAssociation.new(double, :association, {})
         end
       end
     end
 
-    describe "#context" do
-      let(:owner_context) { {some: "context"} }
-      let(:options) { {} }
-      let(:decorated_association) do
-        owner = double(context: owner_context)
-        DecoratedAssociation.new(owner, :association, options)
+    describe "#call" do
+      it "calls the factory" do
+        factory = double
+        Factory.stub new: factory
+        associated = double
+        owner_context = {foo: "bar"}
+        source = double(association: associated)
+        owner = double(source: source, context: owner_context)
+        decorated_association = DecoratedAssociation.new(owner, :association, {})
+        decorated = double
+
+        factory.should_receive(:decorate).with(associated, context_args: owner_context).and_return(decorated)
+        expect(decorated_association.call).to be decorated
       end
 
-      context "when :context option was given" do
-        let(:options) { {context: context} }
+      it "memoizes" do
+        factory = double
+        Factory.stub new: factory
+        owner = double(source: double(association: double), context: {})
+        decorated_association = DecoratedAssociation.new(owner, :association, {})
+        decorated = double
 
-        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
-            expect(decorated_association.context).to be :dynamic_context
-          end
-        end
-
-        context "and is not callable" do
-          let(:context) { {other: "context"} }
-
-          it "returns the specified value" do
-            expect(decorated_association.context).to be context
-          end
-        end
+        factory.should_receive(:decorate).once.and_return(decorated)
+        expect(decorated_association.call).to be decorated
+        expect(decorated_association.call).to be decorated
       end
 
-      context "when :context option was not given" do
-        it "returns the owner's context" do
-          expect(decorated_association.context).to be owner_context
+      context "when the :scope option was given" do
+        it "applies the scope before decoration" do
+          factory = double
+          Factory.stub new: factory
+          scoped = double
+          source = double(association: double(applied_scope: scoped))
+          owner = double(source: source, context: {})
+          decorated_association = DecoratedAssociation.new(owner, :association, scope: :applied_scope)
+          decorated = double
+
+          factory.should_receive(:decorate).with(scoped, anything()).and_return(decorated)
+          expect(decorated_association.call).to be decorated
         end
       end
     end

data/spec/draper/decorates_assigned_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+module Draper
+  describe DecoratesAssigned do
+    let(:controller_class) do
+      Class.new do
+        extend DecoratesAssigned
+
+        def self.helper_method(method)
+          helper_methods << method
+        end
+
+        def self.helper_methods
+          @helper_methods ||= []
+        end
+      end
+    end
+
+    describe ".decorates_assigned" do
+      it "adds helper methods" do
+        controller_class.decorates_assigned :article, :author
+
+        expect(controller_class.instance_methods).to include :article
+        expect(controller_class.instance_methods).to include :author
+
+        expect(controller_class.helper_methods).to include :article
+        expect(controller_class.helper_methods).to include :author
+      end
+
+      it "creates a factory" do
+        Factory.should_receive(:new).once
+        controller_class.decorates_assigned :article, :author
+      end
+
+      it "passes options to the factory" do
+        options = {foo: "bar"}
+
+        Factory.should_receive(:new).with(options)
+        controller_class.decorates_assigned :article, :author, options
+      end
+
+      describe "the generated method" do
+        it "decorates the instance variable" do
+          source = double
+          factory = double
+          Factory.stub new: factory
+
+          controller_class.decorates_assigned :article
+          controller = controller_class.new
+          controller.instance_variable_set "@article", source
+
+          factory.should_receive(:decorate).with(source, context_args: controller).and_return(:decorated)
+          expect(controller.article).to be :decorated
+        end
+
+        it "memoizes" do
+          factory = double
+          Factory.stub new: factory
+
+          controller_class.decorates_assigned :article
+          controller = controller_class.new
+
+          factory.should_receive(:decorate).once
+          controller.article
+          controller.article
+        end
+      end
+    end
+
+  end
+end

data/spec/draper/decorator_spec.rb

@@ -145,6 +145,13 @@ module Draper
           ProductDecorator.decorate_collection([], options)
         end
       end
+
+      context "when a NameError is thrown" do
+        it "re-raises that error" do
+          String.any_instance.stub(:constantize).and_return{Draper::DecoratedEnumerableProxy}
+          expect{ProductDecorator.decorate_collection([])}.to raise_error NameError, /Draper::DecoratedEnumerableProxy/
+        end
+      end
     end
 
     describe ".decorates" do
@@ -170,20 +177,23 @@ module Draper
     end
 
     describe ".source_class" do
+      protect_class ProductDecorator
+      protect_class Namespaced::ProductDecorator
+
       context "when not set by .decorates" do
-        it "raises an error for a so-named 'Decorator'" do
+        it "raises an UninferrableSourceError for a so-named 'Decorator'" do
           expect{Decorator.source_class}.to raise_error UninferrableSourceError
         end
 
-        it "raises an error for anonymous decorators" do
+        it "raises an UninferrableSourceError for anonymous decorators" do
           expect{Class.new(Decorator).source_class}.to raise_error UninferrableSourceError
         end
 
-        it "raises an error for a decorator without a model" do
+        it "raises an UninferrableSourceError for a decorator without a model" do
           expect{OtherDecorator.source_class}.to raise_error UninferrableSourceError
         end
 
-        it "raises an error for other naming conventions" do
+        it "raises an UninferrableSourceError for other naming conventions" do
           expect{ProductPresenter.source_class}.to raise_error UninferrableSourceError
         end
 
@@ -194,6 +204,13 @@ module Draper
         it "infers namespaced sources" do
           expect(Namespaced::ProductDecorator.source_class).to be Namespaced::Product
         end
+
+        context "when an unrelated NameError is thrown" do
+          it "re-raises that error" do
+            String.any_instance.stub(:constantize).and_return{SomethingThatDoesntExist}
+            expect{ProductDecorator.source_class}.to raise_error NameError, /SomethingThatDoesntExist/
+          end
+        end
       end
     end
 
@@ -345,6 +362,15 @@ module Draper
       end
     end
 
+    describe "#attributes" do
+      it "returns only the source's attributes that are implemented by the decorator" do
+        decorator = Decorator.new(double(attributes: {foo: "bar", baz: "qux"}))
+        decorator.stub(:foo)
+
+        expect(decorator.attributes).to eq({foo: "bar"})
+      end
+    end
+
     describe ".model_name" do
       it "delegates to the source class" do
         Decorator.stub source_class: double(model_name: :delegated)
@@ -354,13 +380,18 @@ module Draper
     end
 
     describe "#==" do
-      it "ensures the source has a decoration-aware #==" do
+      it "works for a source that does not include Decoratable" 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
+        expect(decorator).to eq Decorator.new(source)
+      end
+
+      it "works for a multiply-decorated source that does not include Decoratable" do
+        source = Object.new
+        decorator = Decorator.new(source)
+
+        expect(decorator).to eq ProductDecorator.new(Decorator.new(source))
       end
 
       it "is true when source #== is true" do
@@ -554,6 +585,25 @@ module Draper
           end
         end
       end
+
+      describe "#respond_to_missing?" do
+        it "allows #method to be called on delegated methods" do
+          source = Class.new{def hello_world; end}.new
+          decorator = Decorator.new(source)
+
+          expect { decorator.method(:hello_world) }.not_to raise_error NameError
+          expect(decorator.method(:hello_world)).not_to be_nil
+        end
+      end
+
+      describe ".respond_to_missing?" do
+        it "allows .method to be called on delegated class methods" do
+          Decorator.stub source_class: double(hello_world: :delegated)
+
+          expect { Decorator.method(:hello_world) }.not_to raise_error NameError
+          expect(Decorator.method(:hello_world)).not_to be_nil
+        end
+      end
     end
 
     describe "class spoofing" do