draper 0.18.0 → 1.1.0

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

@@ -1,34 +1,19 @@
-<% module_namespacing do -%>
+<%- module_namespacing do -%>
+  <%- if parent_class_name.present? -%>
 class <%= class_name %>Decorator < <%= parent_class_name %>
-  decorates :<%= singular_name %>
+  <%- else -%>
+class <%= class_name %>
+  <%- end -%>
+  delegate_all
 
-  # Accessing Helpers
-  #   You can access any helper via a proxy
-  #
-  #   Normal Usage: helpers.number_to_currency(2)
-  #   Abbreviated : h.number_to_currency(2)
-  #
-  #   Or, optionally enable "lazy helpers" by including this module:
-  #     include Draper::LazyHelpers
-  #   Then use the helpers with no proxy:
-  #     number_to_currency(2)
-
-  # Defining an Interface
-  #   Control access to the wrapped subject's methods using one of the following:
-  #
-  #   To allow only the listed methods (whitelist):
-  #     allows :method1, :method2
-  #
-  #   To allow everything except the listed methods (blacklist):
-  #     denies :method1, :method2
-
-  # Presentation Methods
-  #   Define your own instance methods, even overriding accessors
-  #   generated by ActiveRecord:
+  # Define presentation-specific methods here. Helpers are accessed through
+  # `helpers` (aka `h`). You can override attributes, for example:
   #
   #   def created_at
-  #     h.content_tag :span, attributes["created_at"].strftime("%a %m/%d/%y"),
-  #                   :class => 'timestamp'
+  #     helpers.content_tag :span, class: 'time' do
+  #       source.created_at.strftime("%a %m/%d/%y")
+  #     end
   #   end
+
 end
 <% end -%>

data/lib/generators/mini_test/decorator_generator.rb

@@ -0,0 +1,20 @@
+require 'generators/mini_test'
+
+module MiniTest
+  module Generators
+    class DecoratorGenerator < Base
+      def self.source_root
+        File.expand_path('../templates', __FILE__)
+      end
+
+      class_option :spec, :type => :boolean, :default => false, :desc => "Use MiniTest::Spec DSL"
+
+      check_class_collision suffix: "DecoratorTest"
+
+      def create_test_file
+        template_type = options[:spec] ? "spec" : "test"
+        template "decorator_#{template_type}.rb", File.join("test/decorators", class_path, "#{singular_name}_decorator_test.rb")
+      end
+    end
+  end
+end

data/lib/generators/mini_test/templates/decorator_spec.rb

@@ -0,0 +1,4 @@
+require 'minitest_helper'
+
+describe <%= class_name %>Decorator do
+end

data/lib/generators/mini_test/templates/decorator_test.rb

@@ -0,0 +1,4 @@
+require 'minitest_helper'
+
+class <%= class_name %>DecoratorTest < Draper::TestCase
+end

data/lib/generators/test_unit/templates/decorator_test.rb

@@ -1,4 +1,4 @@
 require 'test_helper'
 
-class <%= class_name %>DecoratorTest < ActiveSupport::TestCase
+class <%= class_name %>DecoratorTest < Draper::TestCase
 end

data/spec/draper/collection_decorator_spec.rb

@@ -0,0 +1,259 @@
+require 'spec_helper'
+require 'support/shared_examples/view_helpers'
+
+module Draper
+  describe CollectionDecorator do
+    it_behaves_like "view helpers", CollectionDecorator.new([])
+
+    describe "#initialize" do
+      describe "options validation" do
+
+        it "does not raise error on valid options" do
+          valid_options = {with: Decorator, context: {}}
+          expect{CollectionDecorator.new([], valid_options)}.not_to raise_error
+        end
+
+        it "raises error on invalid options" do
+          expect{CollectionDecorator.new([], foo: "bar")}.to raise_error ArgumentError, /Unknown key/
+        end
+      end
+    end
+
+    context "with context" do
+      it "stores the context itself" do
+        context = {some: "context"}
+        decorator = CollectionDecorator.new([], context: context)
+
+        expect(decorator.context).to be context
+      end
+
+      it "passes context to the individual decorators" do
+        context = {some: "context"}
+        decorator = CollectionDecorator.new([Product.new, Product.new], context: context)
+
+        decorator.each do |item|
+          expect(item.context).to be context
+        end
+      end
+    end
+
+    describe "#context=" do
+      it "updates the stored context" do
+        decorator = CollectionDecorator.new([], context: {some: "context"})
+        new_context = {other: "context"}
+
+        decorator.context = new_context
+        expect(decorator.context).to be new_context
+      end
+
+      context "when the collection is already decorated" do
+        it "updates the items' context" do
+          decorator = CollectionDecorator.new([Product.new, Product.new], context: {some: "context"})
+          decorator.decorated_collection # trigger decoration
+          new_context = {other: "context"}
+
+          decorator.context = new_context
+          decorator.each do |item|
+            expect(item.context).to be new_context
+          end
+        end
+      end
+
+      context "when the collection has not yet been decorated" do
+        it "does not trigger decoration" do
+          decorator = CollectionDecorator.new([])
+
+          decorator.should_not_receive(:decorated_collection)
+          decorator.context = {other: "context"}
+        end
+
+        it "sets context after decoration is triggered" do
+          decorator = CollectionDecorator.new([Product.new, Product.new], context: {some: "context"})
+          new_context = {other: "context"}
+
+          decorator.context = new_context
+          decorator.each do |item|
+            expect(item.context).to be new_context
+          end
+        end
+      end
+    end
+
+    describe "item decoration" do
+      it "sets decorated items' source models" do
+        collection = [Product.new, Product.new]
+        decorator = CollectionDecorator.new(collection)
+
+        decorator.zip collection do |item, source|
+          expect(item.source).to be source
+        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)
+
+            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
+        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)])
+
+            expect(*decorator).to be :inferred_decorator
+          end
+        end
+      end
+    end
+
+    describe ".delegate" do
+      protect_class ProductsDecorator
+
+      it "defaults the :to option to :source" do
+        Object.should_receive(:delegate).with(:foo, :bar, to: :source)
+        ProductsDecorator.delegate :foo, :bar
+      end
+
+      it "does not overwrite the :to option if supplied" do
+        Object.should_receive(:delegate).with(:foo, :bar, to: :baz)
+        ProductsDecorator.delegate :foo, :bar, to: :baz
+      end
+    end
+
+    describe "#find" do
+      context "with a block" do
+        it "decorates Enumerable#find" do
+          decorator = CollectionDecorator.new([])
+
+          decorator.decorated_collection.should_receive(:find).and_return(:delegated)
+          expect(decorator.find{|p| p.title == "title"}).to be :delegated
+        end
+      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
+        end
+      end
+    end
+
+    describe "#to_ary" do
+      # required for `render @collection` in Rails
+      it "delegates to the decorated collection" do
+        decorator = CollectionDecorator.new([])
+
+        decorator.decorated_collection.should_receive(:to_ary).and_return(:delegated)
+        expect(decorator.to_ary).to be :delegated
+      end
+    end
+
+    it "delegates array methods to the decorated collection" do
+      decorator = CollectionDecorator.new([])
+
+      decorator.decorated_collection.should_receive(:[]).with(42).and_return(:delegated)
+      expect(decorator[42]).to be :delegated
+    end
+
+    describe "#==" do
+      context "when comparing to a collection decorator with the same source" do
+        it "returns true" do
+          source = [Product.new, Product.new]
+          decorator = CollectionDecorator.new(source)
+          other = ProductsDecorator.new(source)
+
+          expect(decorator == other).to be_true
+        end
+      end
+
+      context "when comparing to a collection decorator with a different source" do
+        it "returns false" do
+          decorator = CollectionDecorator.new([Product.new, Product.new])
+          other = ProductsDecorator.new([Product.new, Product.new])
+
+          expect(decorator == other).to be_false
+        end
+      end
+
+      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
+
+          expect(decorator == other).to be_true
+        end
+      end
+
+      context "when comparing to a collection of different items" do
+        it "returns false" do
+          decorator = CollectionDecorator.new([Product.new, Product.new])
+          other = [Product.new, Product.new]
+
+          expect(decorator == other).to be_false
+        end
+      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
+
+          decorator << Product.new.decorate
+          expect(decorator == other).to be_false
+        end
+      end
+    end
+
+    describe "#to_s" do
+      context "when :with option was given" do
+        it "returns a string representation of the collection decorator" do
+          decorator = CollectionDecorator.new(["a", "b", "c"], with: ProductDecorator)
+
+          expect(decorator.to_s).to eq '#<Draper::CollectionDecorator of ProductDecorator for ["a", "b", "c"]>'
+        end
+      end
+
+      context "when :with option was not given" do
+        it "returns a string representation of the collection decorator" do
+          decorator = CollectionDecorator.new(["a", "b", "c"])
+
+          expect(decorator.to_s).to eq '#<Draper::CollectionDecorator of inferred decorators for ["a", "b", "c"]>'
+        end
+      end
+
+      context "for a custom subclass" do
+        it "uses the custom class name" do
+          decorator = ProductsDecorator.new([])
+
+          expect(decorator.to_s).to match /ProductsDecorator/
+        end
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,167 @@
+require 'spec_helper'
+require 'support/shared_examples/decoratable_equality'
+
+module Draper
+  describe Decoratable do
+
+    describe "#decorate" do
+      it "returns a decorator for self" do
+        product = Product.new
+        decorator = product.decorate
+
+        expect(decorator).to be_a ProductDecorator
+        expect(decorator.source).to be product
+     end
+
+      it "accepts context" do
+        context = {some: "context"}
+        decorator = Product.new.decorate(context: context)
+
+        expect(decorator.context).to be context
+      end
+
+      it "uses the #decorator_class" do
+        product = Product.new
+        product.stub decorator_class: OtherDecorator
+
+        expect(product.decorate).to be_an_instance_of OtherDecorator
+      end
+    end
+
+    describe "#applied_decorators" do
+      it "returns an empty list" do
+        expect(Product.new.applied_decorators).to eq []
+      end
+    end
+
+    describe "#decorated_with?" do
+      it "returns false" do
+        expect(Product.new).not_to be_decorated_with Decorator
+      end
+    end
+
+    describe "#decorated?" do
+      it "returns false" do
+        expect(Product.new).not_to be_decorated
+      end
+    end
+
+    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
+
+    describe "#==" do
+      it_behaves_like "decoration-aware #==", Product.new
+    end
+
+    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
+
+      it "is false when #== is false" do
+        product = Product.new
+
+        product.should_receive(:==).and_return(false)
+        expect(product === :anything).to be_false
+      end
+    end
+
+    describe ".====" do
+      it "is true for an instance" do
+        expect(Product === Product.new).to be_true
+      end
+
+      it "is true for a derived instance" do
+        expect(Product === Class.new(Product).new).to be_true
+      end
+
+      it "is false for an unrelated instance" do
+        expect(Product === Model.new).to be_false
+      end
+
+      it "is true for a decorated instance" do
+        decorator = double(source: 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)
+
+        expect(Product === decorator).to be_true
+      end
+
+      it "is false for a decorated unrelated instance" do
+        decorator = double(source: Model.new)
+
+        expect(Product === decorator).to be_false
+      end
+    end
+
+    describe ".decorate" do
+      it "calls #decorate_collection on .decorator_class" do
+        scoped = [Product.new]
+        Product.stub scoped: scoped
+
+        Product.decorator_class.should_receive(:decorate_collection).with(scoped, {}).and_return(:decorated_collection)
+        expect(Product.decorate).to be :decorated_collection
+      end
+
+      it "accepts options" do
+        options = {context: {some: "context"}}
+        Product.stub scoped: []
+
+        Product.decorator_class.should_receive(:decorate_collection).with([], options)
+        Product.decorate(options)
+      end
+    end
+
+    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
+
+      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
+
+      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
+
+      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

@@ -0,0 +1,145 @@
+require 'spec_helper'
+
+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
+      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
+      end
+
+      context "for a singular association" do
+        let(:associated) { Model.new }
+
+        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
+
+        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
+
+      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
+        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
+        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)
+      end
+
+      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
+            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
+      end
+
+      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