draper 0.18.0 → 1.0.0.beta1

data/lib/draper/tasks/tu.rake

@@ -0,0 +1,5 @@
+if Rake::Task.task_defined?('test:run')
+  Rake::Task['test:run'].enhance do
+    Rake::Task['test:decorators'].invoke
+  end
+end

data/lib/draper/test/minitest_integration.rb

@@ -1,7 +1,7 @@
 class MiniTest::Rails::ActiveSupport::TestCase
   # Use AS::TestCase for the base class when describing a decorator
   register_spec_type(self) do |desc|
-    desc < Draper::Base if desc.is_a?(Class)
+    desc < Draper::Decorator if desc.is_a?(Class)
   end
   register_spec_type(/Decorator( ?Test)?\z/i, self)
 end

data/lib/draper/test/test_unit_integration.rb

@@ -0,0 +1,9 @@
+require "rake/testtask"
+require "rails/test_unit/sub_test_task"
+
+namespace :test do
+  Rails::SubTestTask.new(:decorators => "test:prepare") do |t|
+    t.libs << "test"
+    t.pattern = "test/decorators/**/*_test.rb"
+  end
+end

data/lib/draper/version.rb

@@ -1,3 +1,3 @@
 module Draper
-  VERSION = "0.18.0"
+  VERSION = "1.0.0.beta1"
 end

data/lib/draper/view_context.rb

@@ -1,5 +1,11 @@
 module Draper
   module ViewContext
+    def view_context
+      super.tap do |context|
+        Draper::ViewContext.current = context
+      end
+    end
+
     def self.current_controller
       Thread.current[:current_controller] || ApplicationController.new
     end
@@ -16,21 +22,8 @@ module Draper
       Thread.current[:current_view_context] = context
     end
 
-    def view_context
-      super.tap do |context|
-        Draper::ViewContext.current = context
-      end
-    end
-
-    private
-
     def self.build_view_context
       current_controller.view_context.tap do |context|
-        context.instance_eval do
-          def url_options
-            ActionMailer::Base.default_url_options
-          end
-        end unless context.request
         if defined?(ActionController::TestRequest)
           context.controller.request ||= ActionController::TestRequest.new
           context.request            ||= context.controller.request

data/lib/draper/view_helpers.rb

@@ -0,0 +1,36 @@
+module Draper
+  module ViewHelpers
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      # Access the helpers proxy to call built-in and user-defined
+      # Rails helpers from a class context.
+      #
+      # @return [HelperProxy] the helpers proxy
+      def helpers
+        @helpers ||= Draper::HelperProxy.new
+      end
+      alias_method :h, :helpers
+
+    end
+
+    # Access the helpers proxy to call built-in and user-defined
+    # Rails helpers. Aliased to `h` for convenience.
+    #
+    # @return [HelperProxy] the helpers proxy
+    def helpers
+      self.class.helpers
+    end
+    alias_method :h, :helpers
+
+    # Localize is something that's used quite often. Even though
+    # it's available through helpers, that's annoying. Aliased
+    # to `l` for convenience.
+    def localize(*args)
+      helpers.localize(*args)
+    end
+    alias_method :l, :localize
+
+  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/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