draper 0.17.0 → 1.0.0.beta2

data/lib/draper.rb

@@ -1,16 +1,57 @@
 require 'action_view'
 
 require 'draper/version'
-require 'draper/system'
-require 'draper/active_model_support'
-require 'draper/base'
+require 'draper/view_helpers'
+require 'draper/finders'
+require 'draper/decorator'
+require 'draper/helper_proxy'
 require 'draper/lazy_helpers'
-require 'draper/model_support'
+require 'draper/decoratable'
+require 'draper/decorated_association'
+require 'draper/security'
 require 'draper/helper_support'
 require 'draper/view_context'
-require 'draper/decorated_enumerable_proxy'
+require 'draper/collection_decorator'
 require 'draper/railtie' if defined?(Rails)
 
 # Test Support
-require 'draper/test/rspec_integration'    if defined?(RSpec) and RSpec.respond_to?(:configure)
-require 'draper/test/minitest_integration' if defined?(MiniTest::Spec)
+require 'draper/test/rspec_integration'     if defined?(RSpec) and RSpec.respond_to?(:configure)
+require 'draper/test/minitest_integration'  if defined?(MiniTest::Rails)
+require 'draper/test/test_unit_integration'
+
+module Draper
+  def self.setup_action_controller(base)
+    base.class_eval do
+      include Draper::ViewContext
+      extend  Draper::HelperSupport
+      before_filter ->(controller) {
+        Draper::ViewContext.current = nil
+        Draper::ViewContext.current_controller = controller
+      }
+    end
+  end
+
+  def self.setup_action_mailer(base)
+    base.class_eval do
+      include Draper::ViewContext
+    end
+  end
+
+  def self.setup_active_record(base)
+    base.class_eval do
+      include Draper::Decoratable
+    end
+  end
+
+  class UninferrableDecoratorError < NameError
+    def initialize(klass)
+      super("Could not infer a decorator for #{klass}.")
+    end
+  end
+
+  class UninferrableSourceError < NameError
+    def initialize(klass)
+      super("Could not infer a source for #{klass}.")
+    end
+  end
+end

data/lib/generators/decorator/decorator_generator.rb

@@ -20,7 +20,7 @@ module Rails
         elsif defined?(ApplicationDecorator)
           "ApplicationDecorator"
         else
-          "Draper::Base"
+          "Draper::Decorator"
         end
       end
    end

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

@@ -1,6 +1,5 @@
 <% module_namespacing do -%>
 class <%= class_name %>Decorator < <%= parent_class_name %>
-  decorates :<%= singular_name %>
 
   # Accessing Helpers
   #   You can access any helper via a proxy

data/lib/generators/rspec/decorator_generator.rb

@@ -3,7 +3,7 @@ module Rspec
     source_root File.expand_path('../templates', __FILE__)
 
     def create_spec_file
-      template 'decorator_spec.rb', File.join('spec/decorators', "#{singular_name}_decorator_spec.rb")
+      template 'decorator_spec.rb', File.join('spec/decorators', class_path, "#{singular_name}_decorator_spec.rb")
     end
   end
 end

data/lib/generators/test_unit/decorator_generator.rb

@@ -3,7 +3,7 @@ module TestUnit
     source_root File.expand_path('../templates', __FILE__)
 
     def create_test_file
-      template 'decorator_test.rb', File.join('test/decorators', "#{singular_name}_decorator_test.rb")
+      template 'decorator_test.rb', File.join('test/decorators', class_path, "#{singular_name}_decorator_test.rb")
     end
   end
 end

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

@@ -1,7 +1,4 @@
 require 'test_helper'
 
 class <%= class_name %>DecoratorTest < ActiveSupport::TestCase
-  def setup
-    ApplicationController.new.view_context
-  end
 end

data/spec/draper/collection_decorator_spec.rb

@@ -0,0 +1,240 @@
+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 options" do
+    subject { Draper::CollectionDecorator.new(source, with: ProductDecorator, some: "options") }
+
+    its(:options) { should == {some: "options"} }
+
+    it "passes options to the individual decorators" do
+      subject.each do |item|
+        item.options.should == {some: "options"}
+      end
+    end
+
+    describe "#options=" do
+      it "updates the options on the collection decorator" do
+        subject.options = {other: "options"}
+        subject.options.should == {other: "options"}
+      end
+
+      it "updates the options on the individual decorators" do
+        subject.options = {other: "options"}
+        subject.each do |item|
+          item.options.should == {other: "options"}
+        end
+      end
+    end
+  end
+
+  describe "#initialize" do
+    context "when the :with option is given" do
+      context "and the decorator can't be inferred from the class" do
+        subject { Draper::CollectionDecorator.new(source, with: ProductDecorator) }
+
+        it "uses the :with option" do
+          subject.decorator_class.should be ProductDecorator
+        end
+      end
+
+      context "and the decorator is inferrable from the class" do
+        subject { ProductsDecorator.new(source, with: SpecificProductDecorator) }
+
+        it "uses the :with option" do
+          subject.decorator_class.should be SpecificProductDecorator
+        end
+      end
+    end
+
+    context "when the :with option is not given" do
+      context "and the decorator can't be inferred from the class" do
+        it "raises an UninferrableDecoratorError" do
+          expect{Draper::CollectionDecorator.new(source)}.to raise_error Draper::UninferrableDecoratorError
+        end
+      end
+
+      context "and the decorator is inferrable from the class" do
+        subject { ProductsDecorator.new(source) }
+
+        it "infers the decorator" do
+          subject.decorator_class.should be ProductDecorator
+        end
+      end
+    end
+  end
+
+  describe "#source" do
+    it "returns the source collection" do
+      subject.source.should be source
+    end
+
+    it "is aliased to #to_source" do
+      subject.to_source.should be source
+    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: "options"}) }
+
+    it "delegates to helpers" do
+      subject.localize(:an_object, some: "options")
+    end
+
+    it "is aliased to #l" do
+      subject.l(:an_object, some: "options")
+    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.should_receive(:to_ary).and_return(:an_array)
+      subject.to_ary.should == :an_array
+    end
+  end
+
+  describe "#respond_to?" do
+    it "returns true for its own methods" do
+      subject.should respond_to :decorated_collection
+    end
+
+    it "returns true for the wrapped collection's methods" do
+      source.stub(:respond_to?).with(:whatever, true).and_return(true)
+      subject.respond_to?(:whatever, true).should be_true
+    end
+  end
+
+  context "Array methods" do
+    describe "#include?" do
+      it "delegates to the decorated collection" do
+        subject.decorated_collection.should_receive(:include?).with(:something).and_return(true)
+        subject.should include :something
+      end
+    end
+
+    describe "#[]" do
+      it "delegates to the decorated collection" do
+        subject.decorated_collection.should_receive(:[]).with(42).and_return(:something)
+        subject[42].should == :something
+      end
+    end
+  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
+  end
+
+  it "pretends to be the source class" do
+    subject.kind_of?(source.class).should be_true
+    subject.is_a?(source.class).should be_true
+  end
+
+  it "is still its own class" do
+    subject.kind_of?(subject.class).should be_true
+    subject.is_a?(subject.class).should be_true
+  end
+
+  describe "#method_missing" do
+    before do
+      class << source
+        def page_number
+          42
+        end
+      end
+    end
+
+    it "proxies unknown methods to the source collection" do
+      subject.page_number.should == 42
+    end
+  end
+
+end

data/spec/draper/decoratable_spec.rb

@@ -0,0 +1,164 @@
+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 options" do
+      decorator = subject.decorate(some: "options")
+      decorator.options.should == {some: "options"}
+    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 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.source.should be Product.scoped
+    end
+
+    it "accepts options" do
+      decorator = Product.decorate(some: "options")
+      decorator.options.should == {some: "options"}
+    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,130 @@
+require 'spec_helper'
+
+describe Draper::DecoratedAssociation do
+  let(:decorated_association) { Draper::DecoratedAssociation.new(source, association, options) }
+  let(:source) { Product.new }
+  let(:options) { {} }
+
+  describe "#call" do
+    subject { decorated_association.call }
+
+    context "for an ActiveModel collection association" do
+      let(:association) { :similar_products }
+
+      context "when the association is not empty" do
+        it "decorates the collection" do
+          subject.should be_a Draper::CollectionDecorator
+        end
+
+        it "infers the decorator" do
+          subject.decorator_class.should be :infer
+        end
+      end
+
+      context "when the association is empty" do
+        it "doesn't decorate the collection" do
+          source.stub(:similar_products).and_return([])
+          subject.should_not be_a Draper::CollectionDecorator
+          subject.should be_empty
+        end
+      end
+    end
+
+    context "for non-ActiveModel collection associations" do
+      let(:association) { :poro_similar_products }
+
+      context "when the association is not empty" do
+        it "decorates the collection" do
+          subject.should be_a Draper::CollectionDecorator
+        end
+
+        it "infers the decorator" do
+          subject.decorator_class.should be :infer
+        end
+      end
+
+      context "when the association is empty" do
+        it "doesn't decorate the collection" do
+          source.stub(:poro_similar_products).and_return([])
+          subject.should_not be_a Draper::CollectionDecorator
+          subject.should be_empty
+        end
+      end
+    end
+
+    context "for an ActiveModel singular association" do
+      let(:association) { :previous_version }
+
+      context "when the association is present" do
+        it "decorates the association" do
+          subject.should be_decorated_with ProductDecorator
+        end
+      end
+
+      context "when the association is absent" do
+        it "doesn't decorate the association" do
+          source.stub(:previous_version).and_return(nil)
+          subject.should be_nil
+        end
+      end
+    end
+
+    context "for a non-ActiveModel singular association" do
+      let(:association) { :poro_previous_version }
+
+      context "when the association is present" do
+        it "decorates the association" do
+          subject.should be_decorated_with ProductDecorator
+        end
+      end
+
+      context "when the association is absent" do
+        it "doesn't decorate the association" do
+          source.stub(:poro_previous_version).and_return(nil)
+          subject.should be_nil
+        end
+      end
+    end
+
+    context "when a decorator is specified" do
+      let(:options) { {with: SpecificProductDecorator} }
+
+      context "for a singular association" do
+        let(:association) { :previous_version }
+
+        it "decorates with the specified decorator" do
+          subject.should be_decorated_with SpecificProductDecorator
+        end
+      end
+
+      context "for a collection association" do
+        let(:association) { :similar_products}
+
+        it "decorates with a collection of the specifed decorators" do
+          subject.should be_a Draper::CollectionDecorator
+          subject.decorator_class.should be SpecificProductDecorator
+        end
+      end
+    end
+
+    context "when a collection decorator is specified" do
+      let(:association) { :similar_products }
+      let(:options) { {with: ProductsDecorator} }
+
+      it "decorates with the specified decorator" do
+        subject.should be_a ProductsDecorator
+      end
+    end
+
+    context "with a scope" do
+      let(:association) { :thing }
+      let(:options) { {scope: :foo} }
+
+      it "applies the scope before decoration" do
+        scoped = [SomeThing.new]
+        SomeThing.any_instance.should_receive(:foo).and_return(scoped)
+        subject.source.should be scoped
+      end
+    end
+  end
+end