draper 1.2.0 → 1.2.1

data/lib/draper/railtie.rb

@@ -6,7 +6,7 @@ module ActiveModel
       app ||= Rails.application # Rails 3.0.x does not yield `app`
 
       Rails::Generators.configure! app.config.generators
-      require 'generators/resource_override'
+      require_relative '../generators/resource_override'
     end
   end
 end

data/lib/draper/version.rb

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

data/lib/generators/decorator/decorator_generator.rb

@@ -27,8 +27,8 @@ module Rails
 
       # 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)
-          yield if block
+        def module_namespacing
+          yield if block_given?
         end
       end
     end

data/lib/generators/decorator/templates/decorator.rb

@@ -11,7 +11,7 @@ class <%= class_name %>
   #
   #   def created_at
   #     helpers.content_tag :span, class: 'time' do
-  #       source.created_at.strftime("%a %m/%d/%y")
+  #       object.created_at.strftime("%a %m/%d/%y")
   #     end
   #   end
 

data/spec/draper/collection_decorator_spec.rb

@@ -84,8 +84,8 @@ module Draper
         collection = [Product.new, Product.new]
         decorator = CollectionDecorator.new(collection)
 
-        decorator.zip collection do |item, source|
-          expect(item.source).to be source
+        decorator.zip collection do |item, object|
+          expect(item.object).to be object
         end
       end
 
@@ -109,8 +109,8 @@ module Draper
     describe ".delegate" do
       protect_class ProductsDecorator
 
-      it "defaults the :to option to :source" do
-        Object.should_receive(:delegate).with(:foo, :bar, to: :source)
+      it "defaults the :to option to :object" do
+        Object.should_receive(:delegate).with(:foo, :bar, to: :object)
         ProductsDecorator.delegate :foo, :bar
       end
 
@@ -131,12 +131,15 @@ module Draper
       end
 
       context "without a block" do
-        it "decorates Model.find" do
-          item_decorator = Class.new
-          decorator = CollectionDecorator.new([], with: item_decorator)
-
-          item_decorator.should_receive(:find).with(1).and_return(:delegated)
-          expect(decorator.find(1)).to be :delegated
+        it "decorates object.find" do
+          object = []
+          found = stub(decorate: :decorated)
+          decorator = CollectionDecorator.new(object)
+
+          object.should_receive(:find).and_return(found)
+          ActiveSupport::Deprecation.silence do
+            expect(decorator.find(1)).to be :decorated
+          end
         end
       end
     end
@@ -159,17 +162,17 @@ module Draper
     end
 
     describe "#==" do
-      context "when comparing to a collection decorator with the same source" do
+      context "when comparing to a collection decorator with the same object" do
         it "returns true" do
-          source = [Product.new, Product.new]
-          decorator = CollectionDecorator.new(source)
-          other = ProductsDecorator.new(source)
+          object = [Product.new, Product.new]
+          decorator = CollectionDecorator.new(object)
+          other = ProductsDecorator.new(object)
 
           expect(decorator == other).to be_true
         end
       end
 
-      context "when comparing to a collection decorator with a different source" do
+      context "when comparing to a collection decorator with a different object" do
         it "returns false" do
           decorator = CollectionDecorator.new([Product.new, Product.new])
           other = ProductsDecorator.new([Product.new, Product.new])
@@ -180,9 +183,9 @@ module Draper
 
       context "when comparing to a collection of the same items" do
         it "returns true" do
-          source = [Product.new, Product.new]
-          decorator = CollectionDecorator.new(source)
-          other = source.dup
+          object = [Product.new, Product.new]
+          decorator = CollectionDecorator.new(object)
+          other = object.dup
 
           expect(decorator == other).to be_true
         end
@@ -198,10 +201,10 @@ module Draper
       end
 
       context "when the decorated collection has been modified" do
-        it "is no longer equal to the source" do
-          source = [Product.new, Product.new]
-          decorator = CollectionDecorator.new(source)
-          other = source.dup
+        it "is no longer equal to the object" do
+          object = [Product.new, Product.new]
+          decorator = CollectionDecorator.new(object)
+          other = object.dup
 
           decorator << Product.new.decorate
           expect(decorator == other).to be_false
@@ -275,5 +278,21 @@ module Draper
       end
     end
 
+    describe "#replace" do
+      it "replaces the decorated collection" do
+        decorator = CollectionDecorator.new([Product.new])
+        replacement = [:foo, :bar]
+
+        decorator.replace replacement
+        expect(decorator).to match_array replacement
+      end
+
+      it "returns itself" do
+        decorator = CollectionDecorator.new([Product.new])
+
+        expect(decorator.replace([:foo, :bar])).to be decorator
+      end
+    end
+
   end
 end

data/spec/draper/decoratable_spec.rb

@@ -10,7 +10,7 @@ module Draper
         decorator = product.decorate
 
         expect(decorator).to be_a ProductDecorator
-        expect(decorator.source).to be product
+        expect(decorator.object).to be product
      end
 
       it "accepts context" do
@@ -89,19 +89,19 @@ module Draper
       end
 
       it "is true for a decorated instance" do
-        decorator = double(source: Product.new)
+        decorator = double(object: Product.new)
 
         expect(Product === decorator).to be_true
       end
 
       it "is true for a decorated derived instance" do
-        decorator = double(source: Class.new(Product).new)
+        decorator = double(object: Class.new(Product).new)
 
         expect(Product === decorator).to be_true
       end
 
       it "is false for a decorated unrelated instance" do
-        decorator = double(source: Model.new)
+        decorator = double(object: Model.new)
 
         expect(Product === decorator).to be_false
       end

data/spec/draper/decorated_association_spec.rb

@@ -43,8 +43,8 @@ module Draper
         Factory.stub new: factory
         associated = double
         owner_context = {foo: "bar"}
-        source = double(association: associated)
-        owner = double(source: source, context: owner_context)
+        object = double(association: associated)
+        owner = double(object: object, context: owner_context)
         decorated_association = DecoratedAssociation.new(owner, :association, {})
         decorated = double
 
@@ -55,7 +55,7 @@ module Draper
       it "memoizes" do
         factory = double
         Factory.stub new: factory
-        owner = double(source: double(association: double), context: {})
+        owner = double(object: double(association: double), context: {})
         decorated_association = DecoratedAssociation.new(owner, :association, {})
         decorated = double
 
@@ -69,8 +69,8 @@ module Draper
           factory = double
           Factory.stub new: factory
           scoped = double
-          source = double(association: double(applied_scope: scoped))
-          owner = double(source: source, context: {})
+          object = double(association: double(applied_scope: scoped))
+          owner = double(object: object, context: {})
           decorated_association = DecoratedAssociation.new(owner, :association, scope: :applied_scope)
           decorated = double
 

data/spec/draper/decorates_assigned_spec.rb

@@ -41,15 +41,15 @@ module Draper
 
       describe "the generated method" do
         it "decorates the instance variable" do
-          source = double
+          object = double
           factory = double
           Factory.stub new: factory
 
           controller_class.decorates_assigned :article
           controller = controller_class.new
-          controller.instance_variable_set "@article", source
+          controller.instance_variable_set "@article", object
 
-          factory.should_receive(:decorate).with(source, context_args: controller).and_return(:decorated)
+          factory.should_receive(:decorate).with(object, context_args: controller).and_return(:decorated)
           expect(controller.article).to be :decorated
         end
 

data/spec/draper/decorator_spec.rb

@@ -17,11 +17,11 @@ module Draper
         end
       end
 
-      it "sets the source" do
-        source = Model.new
-        decorator = Decorator.new(source)
+      it "sets the object" do
+        object = Model.new
+        decorator = Decorator.new(object)
 
-        expect(decorator.source).to be source
+        expect(decorator.object).to be object
       end
 
       it "stores context" do
@@ -32,12 +32,12 @@ module Draper
       end
 
       context "when decorating an instance of itself" do
-        it "applies to the source instead" do
-          source = Model.new
-          decorated = Decorator.new(source)
+        it "applies to the object instead" do
+          object = Model.new
+          decorated = Decorator.new(object)
           redecorated = Decorator.new(decorated)
 
-          expect(redecorated.source).to be source
+          expect(redecorated.object).to be object
         end
 
         context "with context" do
@@ -65,7 +65,7 @@ module Draper
         decorated = OtherDecorator.new(Model.new)
         redecorated = Decorator.new(decorated)
 
-        expect(redecorated.source).to be decorated
+        expect(redecorated.object).to be decorated
       end
 
       context "when it has been applied previously" do
@@ -85,7 +85,7 @@ module Draper
           Object.any_instance.stub(:warn)
           redecorated = Decorator.decorate(decorated)
 
-          expect(redecorated.source).to be decorated
+          expect(redecorated.object).to be decorated
         end
       end
     end
@@ -116,10 +116,10 @@ module Draper
 
       context "without a custom collection decorator" do
         it "creates a CollectionDecorator using itself for each item" do
-          source = [Model.new]
+          object = [Model.new]
 
-          CollectionDecorator.should_receive(:new).with(source, with: Decorator)
-          Decorator.decorate_collection(source)
+          CollectionDecorator.should_receive(:new).with(object, with: Decorator)
+          Decorator.decorate_collection(object)
         end
 
         it "passes options to the collection decorator" do
@@ -132,10 +132,10 @@ module Draper
 
       context "with a custom collection decorator" do
         it "creates a custom collection decorator using itself for each item" do
-          source = [Model.new]
+          object = [Model.new]
 
-          ProductsDecorator.should_receive(:new).with(source, with: ProductDecorator)
-          ProductDecorator.decorate_collection(source)
+          ProductsDecorator.should_receive(:new).with(object, with: ProductDecorator)
+          ProductDecorator.decorate_collection(object)
         end
 
         it "passes options to the collection decorator" do
@@ -157,74 +157,84 @@ module Draper
     describe ".decorates" do
       protect_class Decorator
 
-      it "sets .source_class with a symbol" do
+      it "sets .object_class with a symbol" do
         Decorator.decorates :product
 
-        expect(Decorator.source_class).to be Product
+        expect(Decorator.object_class).to be Product
       end
 
-      it "sets .source_class with a string" do
+      it "sets .object_class with a string" do
         Decorator.decorates "product"
 
-        expect(Decorator.source_class).to be Product
+        expect(Decorator.object_class).to be Product
       end
 
-      it "sets .source_class with a class" do
+      it "sets .object_class with a class" do
         Decorator.decorates Product
 
-        expect(Decorator.source_class).to be Product
+        expect(Decorator.object_class).to be Product
       end
     end
 
-    describe ".source_class" do
+    describe ".object_class" do
       protect_class ProductDecorator
       protect_class Namespaced::ProductDecorator
 
       context "when not set by .decorates" do
         it "raises an UninferrableSourceError for a so-named 'Decorator'" do
-          expect{Decorator.source_class}.to raise_error UninferrableSourceError
+          expect{Decorator.object_class}.to raise_error UninferrableSourceError
         end
 
         it "raises an UninferrableSourceError for anonymous decorators" do
-          expect{Class.new(Decorator).source_class}.to raise_error UninferrableSourceError
+          expect{Class.new(Decorator).object_class}.to raise_error UninferrableSourceError
         end
 
         it "raises an UninferrableSourceError for a decorator without a model" do
-          expect{OtherDecorator.source_class}.to raise_error UninferrableSourceError
+          expect{OtherDecorator.object_class}.to raise_error UninferrableSourceError
         end
 
         it "raises an UninferrableSourceError for other naming conventions" do
-          expect{ProductPresenter.source_class}.to raise_error UninferrableSourceError
+          expect{ProductPresenter.object_class}.to raise_error UninferrableSourceError
         end
 
         it "infers the source for '<Model>Decorator'" do
-          expect(ProductDecorator.source_class).to be Product
+          expect(ProductDecorator.object_class).to be Product
         end
 
         it "infers namespaced sources" do
-          expect(Namespaced::ProductDecorator.source_class).to be Namespaced::Product
+          expect(Namespaced::ProductDecorator.object_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/
+            expect{ProductDecorator.object_class}.to raise_error NameError, /SomethingThatDoesntExist/
           end
         end
       end
+
+      it "is aliased to .source_class" do
+        expect(ProductDecorator.source_class).to be Product
+      end
     end
 
-    describe ".source_class?" do
-      it "returns truthy when .source_class is set" do
-        Decorator.stub(:source_class).and_return(Model)
+    describe ".object_class?" do
+      it "returns truthy when .object_class is set" do
+        Decorator.stub(:object_class).and_return(Model)
 
-        expect(Decorator.source_class?).to be_true
+        expect(Decorator.object_class?).to be_true
+      end
+
+      it "returns false when .object_class is not inferrable" do
+        Decorator.stub(:object_class).and_raise(UninferrableSourceError.new(Decorator))
+
+        expect(Decorator.object_class?).to be_false
       end
 
-      it "returns false when .source_class is not inferrable" do
-        Decorator.stub(:source_class).and_raise(UninferrableSourceError.new(Decorator))
+      it "is aliased to .source_class?" do
+        Decorator.stub(:object_class).and_return(Model)
 
-        expect(Decorator.source_class?).to be_false
+        expect(Decorator.source_class?).to be_true
       end
     end
 
@@ -319,14 +329,35 @@ module Draper
       end
     end
 
-    describe "#source" do
+    describe "#object" do
       it "returns the wrapped object" do
-        source = Model.new
-        decorator = Decorator.new(source)
+        object = Model.new
+        decorator = Decorator.new(object)
+
+        expect(decorator.object).to be object
+        expect(decorator.model).to be object
+        expect(decorator.to_source).to be object
+      end
+
+      it "is aliased to #model" do
+        object = Model.new
+        decorator = Decorator.new(object)
 
-        expect(decorator.source).to be source
-        expect(decorator.model).to be source
-        expect(decorator.to_source).to be source
+        expect(decorator.model).to be object
+      end
+
+      it "is aliased to #source" do
+        object = Model.new
+        decorator = Decorator.new(object)
+
+        expect(decorator.source).to be object
+      end
+
+      it "is aliased to #to_source" do
+        object = Model.new
+        decorator = Decorator.new(object)
+
+        expect(decorator.to_source).to be object
       end
     end
 
@@ -339,7 +370,7 @@ module Draper
     end
 
     describe "#to_param" do
-      it "delegates to the source" do
+      it "delegates to the object" do
         decorator = Decorator.new(double(to_param: :delegated))
 
         expect(decorator.to_param).to be :delegated
@@ -347,15 +378,23 @@ module Draper
     end
 
     describe "#present?" do
-      it "delegates to the source" do
+      it "delegates to the object" do
         decorator = Decorator.new(double(present?: :delegated))
 
         expect(decorator.present?).to be :delegated
       end
     end
 
+    describe "#blank?" do
+      it "delegates to the object" do
+        decorator = Decorator.new(double(blank?: :delegated))
+
+        expect(decorator.blank?).to be :delegated
+      end
+    end
+
     describe "#to_partial_path" do
-      it "delegates to the source" do
+      it "delegates to the object" do
         decorator = Decorator.new(double(to_partial_path: :delegated))
 
         expect(decorator.to_partial_path).to be :delegated
@@ -363,7 +402,7 @@ module Draper
     end
 
     describe "#attributes" do
-      it "returns only the source's attributes that are implemented by the decorator" do
+      it "returns only the object's attributes that are implemented by the decorator" do
         decorator = Decorator.new(double(attributes: {foo: "bar", baz: "qux"}))
         decorator.stub(:foo)
 
@@ -373,42 +412,42 @@ module Draper
 
     describe ".model_name" do
       it "delegates to the source class" do
-        Decorator.stub source_class: double(model_name: :delegated)
+        Decorator.stub object_class: double(model_name: :delegated)
 
         expect(Decorator.model_name).to be :delegated
       end
     end
 
     describe "#==" do
-      it "works for a source that does not include Decoratable" do
-        source = Object.new
-        decorator = Decorator.new(source)
+      it "works for a object that does not include Decoratable" do
+        object = Object.new
+        decorator = Decorator.new(object)
 
-        expect(decorator).to eq Decorator.new(source)
+        expect(decorator).to eq Decorator.new(object)
       end
 
-      it "works for a multiply-decorated source that does not include Decoratable" do
-        source = Object.new
-        decorator = Decorator.new(source)
+      it "works for a multiply-decorated object that does not include Decoratable" do
+        object = Object.new
+        decorator = Decorator.new(object)
 
-        expect(decorator).to eq ProductDecorator.new(Decorator.new(source))
+        expect(decorator).to eq ProductDecorator.new(Decorator.new(object))
       end
 
-      it "is true when source #== is true" do
-        source = Model.new
-        decorator = Decorator.new(source)
-        other = double(source: Model.new)
+      it "is true when object #== is true" do
+        object = Model.new
+        decorator = Decorator.new(object)
+        other = double(object: Model.new)
 
-        source.should_receive(:==).with(other).and_return(true)
+        object.should_receive(:==).with(other).and_return(true)
         expect(decorator == other).to be_true
       end
 
-      it "is false when source #== is false" do
-        source = Model.new
-        decorator = Decorator.new(source)
-        other = double(source: Model.new)
+      it "is false when object #== is false" do
+        object = Model.new
+        decorator = Decorator.new(object)
+        other = double(object: Model.new)
 
-        source.should_receive(:==).with(other).and_return(false)
+        object.should_receive(:==).with(other).and_return(false)
         expect(decorator == other).to be_false
       end
 
@@ -433,8 +472,8 @@ module Draper
     describe ".delegate" do
       protect_class Decorator
 
-      it "defaults the :to option to :source" do
-        Object.should_receive(:delegate).with(:foo, :bar, to: :source)
+      it "defaults the :to option to :object" do
+        Object.should_receive(:delegate).with(:foo, :bar, to: :object)
         Decorator.delegate :foo, :bar
       end
 
@@ -450,7 +489,7 @@ module Draper
       before { Decorator.delegate_all }
 
       describe "#method_missing" do
-        it "delegates missing methods that exist on the source" do
+        it "delegates missing methods that exist on the object" do
           decorator = Decorator.new(double(hello_world: :delegated))
 
           expect(decorator.hello_world).to be :delegated
@@ -465,9 +504,9 @@ module Draper
         end
 
         it "passes blocks to delegated methods" do
-          source = Model.new
-          source.stub(:hello_world).and_return{|*args, &block| block.call}
-          decorator = Decorator.new(source)
+          object = Model.new
+          object.stub(:hello_world).and_return{|*args, &block| block.call}
+          decorator = Decorator.new(object)
 
           expect(decorator.hello_world{:yielded}).to be :yielded
         end
@@ -479,21 +518,21 @@ module Draper
         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)
+          object = Class.new{ delegate :bar, to: :foo }.new
+          object.stub foo: double(bar: :delegated)
+          decorator = Decorator.new(object)
 
           expect(decorator.bar).to be :delegated
         end
 
         it "does not delegate private methods" do
-          source = Class.new{ private; def hello_world; end }.new
-          decorator = Decorator.new(source)
+          object = Class.new{ private; def hello_world; end }.new
+          decorator = Decorator.new(object)
 
           expect{decorator.hello_world}.to raise_error NoMethodError
         end
 
-        it "does not delegate methods that do not exist on the source" do
+        it "does not delegate methods that do not exist on the object" do
           decorator = Decorator.new(Model.new)
 
           expect(decorator.methods).not_to include :hello_world
@@ -511,15 +550,15 @@ module Draper
 
         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
+            object_class = Class.new
+            object_class.stub hello_world: :delegated
+            Decorator.stub object_class: object_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
+            Decorator.stub object_class: Class.new
 
             expect{Decorator.hello_world}.to raise_error NoMethodError
           end
@@ -534,7 +573,7 @@ module Draper
           expect(decorator).to respond_to :hello_world
         end
 
-        it "returns true for the source's methods" do
+        it "returns true for the object's methods" do
           decorator = Decorator.new(double(hello_world: :delegated))
 
           expect(decorator).to respond_to :hello_world
@@ -548,9 +587,9 @@ module Draper
             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)
+          it "returns false for the object's private methods" do
+            object = Class.new{private; def hello_world; end}.new
+            decorator = Decorator.new(object)
 
             expect(decorator.respond_to?(:hello_world, true)).to be_false
           end
@@ -573,13 +612,13 @@ module Draper
         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
+            Decorator.stub object_class: Class.new
 
             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)
+            Decorator.stub object_class: double(hello_world: :delegated)
 
             expect(Decorator).to respond_to :hello_world
           end
@@ -588,8 +627,8 @@ module Draper
 
       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)
+          object = Class.new{def hello_world; end}.new
+          decorator = Decorator.new(object)
 
           expect { decorator.method(:hello_world) }.not_to raise_error NameError
           expect(decorator.method(:hello_world)).not_to be_nil
@@ -598,7 +637,7 @@ module Draper
 
       describe ".respond_to_missing?" do
         it "allows .method to be called on delegated class methods" do
-          Decorator.stub source_class: double(hello_world: :delegated)
+          Decorator.stub object_class: double(hello_world: :delegated)
 
           expect { Decorator.method(:hello_world) }.not_to raise_error NameError
           expect(Decorator.method(:hello_world)).not_to be_nil