draper 1.1.0 → 1.2.0

data/spec/draper/factory_spec.rb

@@ -0,0 +1,238 @@
+require 'spec_helper'
+
+module Draper
+  describe Factory do
+
+    describe "#initialize" do
+      it "accepts valid options" do
+        valid_options = {with: Decorator, context: {foo: "bar"}}
+        expect{Factory.new(valid_options)}.not_to raise_error
+      end
+
+      it "rejects invalid options" do
+        expect{Factory.new(foo: "bar")}.to raise_error ArgumentError, /Unknown key/
+      end
+    end
+
+    describe "#decorate" do
+      context "when source is nil" do
+        it "returns nil" do
+          factory = Factory.new
+
+          expect(factory.decorate(nil)).to be_nil
+        end
+      end
+
+      it "calls a worker" do
+        factory = Factory.new
+        worker = ->(*){ :decorated }
+
+        Factory::Worker.should_receive(:new).and_return(worker)
+        expect(factory.decorate(double)).to be :decorated
+      end
+
+      it "passes the source to the worker" do
+        factory = Factory.new
+        source = double
+
+        Factory::Worker.should_receive(:new).with(anything(), source).and_return(->(*){})
+        factory.decorate(source)
+      end
+
+      context "when the :with option was given" do
+        it "passes the decorator class to the worker" do
+          decorator_class = double
+          factory = Factory.new(with: decorator_class)
+
+          Factory::Worker.should_receive(:new).with(decorator_class, anything()).and_return(->(*){})
+          factory.decorate(double)
+        end
+      end
+
+      context "when the :with option was omitted" do
+        it "passes nil to the worker" do
+          factory = Factory.new
+
+          Factory::Worker.should_receive(:new).with(nil, anything()).and_return(->(*){})
+          factory.decorate(double)
+        end
+      end
+
+      it "passes options to the call" do
+        factory = Factory.new
+        worker = ->(*){}
+        Factory::Worker.stub new: worker
+        options = {foo: "bar"}
+
+        worker.should_receive(:call).with(options)
+        factory.decorate(double, options)
+      end
+
+      context "when the :context option was given" do
+        it "sets the passed context" do
+          factory = Factory.new(context: {foo: "bar"})
+          worker = ->(*){}
+          Factory::Worker.stub new: worker
+
+          worker.should_receive(:call).with(baz: "qux", context: {foo: "bar"})
+          factory.decorate(double, {baz: "qux"})
+        end
+
+        it "is overridden by explicitly-specified context" do
+          factory = Factory.new(context: {foo: "bar"})
+          worker = ->(*){}
+          Factory::Worker.stub new: worker
+
+          worker.should_receive(:call).with(context: {baz: "qux"})
+          factory.decorate(double, context: {baz: "qux"})
+        end
+      end
+    end
+
+  end
+
+  describe Factory::Worker do
+
+    describe "#call" do
+      it "calls the decorator method" do
+        source = double
+        options = {foo: "bar"}
+        worker = Factory::Worker.new(double, source)
+        decorator = ->(*){}
+        worker.stub decorator: decorator
+
+        decorator.should_receive(:call).with(source, options).and_return(:decorated)
+        expect(worker.call(options)).to be :decorated
+      end
+
+      context "when the :context option is callable" do
+        it "calls it" do
+          worker = Factory::Worker.new(double, double)
+          decorator = ->(*){}
+          worker.stub decorator: decorator
+          context = {foo: "bar"}
+
+          decorator.should_receive(:call).with(anything(), context: context)
+          worker.call(context: ->{ context })
+        end
+
+        it "receives arguments from the :context_args option" do
+          worker = Factory::Worker.new(double, double)
+          worker.stub decorator: ->(*){}
+          context = ->{}
+
+          context.should_receive(:call).with(:foo, :bar)
+          worker.call(context: context, context_args: [:foo, :bar])
+        end
+
+        it "wraps non-arrays passed to :context_args" do
+          worker = Factory::Worker.new(double, double)
+          worker.stub decorator: ->(*){}
+          context = ->{}
+          hash = {foo: "bar"}
+
+          context.should_receive(:call).with(hash)
+          worker.call(context: context, context_args: hash)
+        end
+      end
+
+      context "when the :context option is not callable" do
+        it "doesn't call it" do
+          worker = Factory::Worker.new(double, double)
+          decorator = ->(*){}
+          worker.stub decorator: decorator
+          context = {foo: "bar"}
+
+          decorator.should_receive(:call).with(anything(), context: context)
+          worker.call(context: context)
+        end
+      end
+
+      it "does not pass the :context_args option to the decorator" do
+        worker = Factory::Worker.new(double, double)
+        decorator = ->(*){}
+        worker.stub decorator: decorator
+
+        decorator.should_receive(:call).with(anything(), foo: "bar")
+        worker.call(foo: "bar", context_args: [])
+      end
+    end
+
+    describe "#decorator" do
+      context "for a singular source" do
+        context "when decorator_class is specified" do
+          it "returns the .decorate method from the decorator" do
+            decorator_class = Class.new(Decorator)
+            worker = Factory::Worker.new(decorator_class, double)
+
+            expect(worker.decorator).to eq decorator_class.method(:decorate)
+          end
+        end
+
+        context "when decorator_class is unspecified" do
+          context "and the source is decoratable" do
+            it "returns the source's #decorate method" do
+              source = double
+              options = {foo: "bar"}
+              worker = Factory::Worker.new(nil, source)
+
+              source.should_receive(:decorate).with(options).and_return(:decorated)
+              expect(worker.decorator.call(source, options)).to be :decorated
+            end
+          end
+
+          context "and the source is not decoratable" do
+            it "raises an error" do
+              source = double
+              worker = Factory::Worker.new(nil, source)
+
+              expect{worker.decorator}.to raise_error UninferrableDecoratorError
+            end
+          end
+        end
+      end
+
+      context "for a collection source" do
+        context "when decorator_class is a CollectionDecorator" do
+          it "returns the .decorate method from the collection decorator" do
+            decorator_class = Class.new(CollectionDecorator)
+            worker = Factory::Worker.new(decorator_class, [])
+
+            expect(worker.decorator).to eq decorator_class.method(:decorate)
+          end
+        end
+
+        context "when decorator_class is a Decorator" do
+          it "returns the .decorate_collection method from the decorator" do
+            decorator_class = Class.new(Decorator)
+            worker = Factory::Worker.new(decorator_class, [])
+
+            expect(worker.decorator).to eq decorator_class.method(:decorate_collection)
+          end
+        end
+
+        context "when decorator_class is unspecified" do
+          context "and the source is decoratable" do
+            it "returns the source's #decorate method" do
+              source = []
+              options = {foo: "bar"}
+              worker = Factory::Worker.new(nil, source)
+
+              source.should_receive(:decorate).with(options).and_return(:decorated)
+              expect(worker.decorator.call(source, options)).to be :decorated
+            end
+          end
+
+          context "and the source is not decoratable" do
+            it "returns the .decorate method from CollectionDecorator" do
+              worker = Factory::Worker.new(nil, [])
+
+              expect(worker.decorator).to eq CollectionDecorator.method(:decorate)
+            end
+          end
+        end
+      end
+    end
+
+  end
+end

data/spec/draper/helper_proxy_spec.rb

@@ -38,5 +38,16 @@ module Draper
         expect(HelperProxy.instance_methods).to include :foo
       end
     end
+
+    describe "proxying methods which are overriding" do
+      it "proxies :capture" do
+        view_context = double
+        helper_proxy = HelperProxy.new(view_context)
+
+        view_context.stub(:capture).and_return{|*args, &block| [*args, block.call] }
+        expect(helper_proxy.capture(:first_arg, :second_arg){:yielded}).to \
+          be_eql [:first_arg, :second_arg, :yielded]
+      end
+    end
   end
 end

data/spec/draper/lazy_helpers_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+module Draper
+  describe LazyHelpers do
+    describe "#method_missing" do
+      let(:decorator) do
+        Struct.new(:helpers){include Draper::LazyHelpers}.new(double)
+      end
+
+      it "proxies methods to #helpers" do
+        decorator.helpers.stub(:foo).and_return{|arg| arg}
+        expect(decorator.foo(:passed)).to be :passed
+      end
+
+      it "passes blocks" do
+        decorator.helpers.stub(:foo).and_return{|&block| block.call}
+        expect(decorator.foo{:yielded}).to be :yielded
+      end
+    end
+  end
+end

data/spec/dummy/app/controllers/posts_controller.rb

@@ -1,6 +1,8 @@
 class PostsController < ApplicationController
+  decorates_assigned :post
+
   def show
-    @post = Post.find(params[:id]).decorate
+    @post = Post.find(params[:id])
   end
 
   def mail

data/spec/dummy/app/decorators/mongoid_post_decorator.rb

@@ -0,0 +1,2 @@
+class MongoidPostDecorator < Draper::Decorator
+end

data/spec/dummy/app/views/posts/show.html.erb

@@ -1 +1 @@
-<%= render @post %>
+<%= render post %>

data/spec/dummy/config/application.rb

@@ -9,6 +9,7 @@ require 'rails/all'
 require 'draper'
 attempt_require 'mongoid'
 attempt_require 'devise'
+require 'active_model_serializers'
 
 module Dummy
   class Application < Rails::Application

data/spec/dummy/spec/decorators/active_model_serializers_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Draper::CollectionDecorator do
+  describe "#active_model_serializer" do
+    it "returns ActiveModel::ArraySerializer" do
+      collection_decorator = Draper::CollectionDecorator.new([])
+
+      expect(collection_decorator.active_model_serializer).to be ActiveModel::ArraySerializer
+    end
+  end
+end

data/spec/dummy/spec/decorators/post_decorator_spec.rb

@@ -40,6 +40,18 @@ describe PostDecorator do
     expect(decorator.serializable_hash["updated_at"]).to be :overridden
   end
 
+  it "serializes to JSON" do
+    json = decorator.to_json
+    expect(json).to match /"updated_at":"overridden"/
+  end
+
+  it "serializes to XML" do
+    pending("Rails < 3.2 does not use `serializable_hash` in `to_xml`") if Rails.version.to_f < 3.2
+
+    xml = Capybara.string(decorator.to_xml)
+    expect(xml).to have_css "post > updated-at", text: "overridden"
+  end
+
   it "uses a test view context from ApplicationController" do
     expect(Draper::ViewContext.current.controller).to be_an ApplicationController
   end

data/spec/dummy/spec/models/mongoid_post_spec.rb

@@ -1,10 +1,8 @@
 require 'spec_helper'
+require 'shared_examples/decoratable'
 
 if defined?(Mongoid)
   describe MongoidPost do
-    it "is decoratable" do
-      expect(MongoidPost).to respond_to :decorator_class
-      expect(MongoidPost.new).to respond_to :decorate
-    end
+    it_behaves_like "a decoratable model"
   end
 end

data/spec/dummy/spec/models/post_spec.rb

@@ -1,14 +1,6 @@
 require 'spec_helper'
+require 'shared_examples/decoratable'
 
 describe Post do
-  describe "#==" do
-    it "is true for other instances' decorators" do
-      Post.create
-      one = Post.first
-      other = Post.first
-
-      expect(one).not_to be other
-      expect(one == other.decorate).to be_true
-    end
-  end
+  it_behaves_like "a decoratable model"
 end

data/spec/dummy/spec/shared_examples/decoratable.rb

@@ -0,0 +1,24 @@
+shared_examples_for "a decoratable model" do
+  describe ".decorate" do
+    it "applies a collection decorator to a scope" do
+      described_class.create
+      decorated = described_class.limit(1).decorate
+
+      expect(decorated).to have(1).items
+      expect(decorated).to be_decorated
+    end
+  end
+
+  describe "#==" do
+    it "is true for other instances' decorators" do
+      pending "Mongoid < 3.1 overrides `#==`" if defined?(Mongoid) && Mongoid::VERSION.to_f < 3.1 && described_class < Mongoid::Document
+
+      described_class.create
+      one = described_class.first
+      other = described_class.first
+
+      expect(one).not_to be other
+      expect(one == other.decorate).to be_true
+    end
+  end
+end

data/spec/generators/decorator/decorator_generator_spec.rb

@@ -1,137 +1,129 @@
 require 'spec_helper'
 require 'ammeter/init'
-
-# Generators are not automatically loaded by Rails
 require 'generators/decorator/decorator_generator'
 
 describe Rails::Generators::DecoratorGenerator do
-  # Tell the generator where to put its output (what it thinks of as Rails.root)
-  destination File.expand_path("../../../../../tmp", __FILE__)
+  destination File.expand_path("../tmp", __FILE__)
 
   before { prepare_destination }
+  after(:all) { FileUtils.rm_rf destination_root }
 
-  context 'decorator context' do
-    before { run_generator ["YourModel"]  }
-
-    describe 'app/decorators/your_model_decorator.rb' do
-      subject { file('app/decorators/your_model_decorator.rb') }
-      it { should exist }
-      it { should contain "class YourModelDecorator < Draper::Decorator" }
-    end
-  end
+  describe "the generated decorator" do
+    subject { file("app/decorators/your_model_decorator.rb") }
 
-  context 'decorator name' do
-    before { run_generator ["YourModel", '-t=rspec']  }
+    describe "naming" do
+      before { run_generator %w(YourModel) }
 
-    describe 'spec/decorators/your_model_decorator_spec.rb' do
-      subject { file('spec/decorators/your_model_decorator_spec.rb') }
-      it { should exist }
-      it { should contain "describe YourModelDecorator" }
+      it { should contain "class YourModelDecorator" }
     end
-  end
 
-  context 'parent decorator' do
-    describe 'decorator inherited from Draper::Decorator' do
-      before { run_generator ["YourModel"] }
+    describe "namespacing" do
+      subject { file("app/decorators/namespace/your_model_decorator.rb") }
+      before { run_generator %w(Namespace::YourModel) }
 
-      subject { file('app/decorators/your_model_decorator.rb') }
-      it { should exist }
-      it { should contain "class YourModelDecorator < Draper::Decorator" }
+      it { should contain "class Namespace::YourModelDecorator" }
     end
 
-    describe "decorator inherited from ApplicationDecorator if it's present" do
-      before do
-       class ApplicationDecorator; end
-       run_generator ["YourModel"]
+    describe "inheritance" do
+      context "by default" do
+        before { run_generator %w(YourModel) }
+
+        it { should contain "class YourModelDecorator < Draper::Decorator" }
       end
 
-      after do
-        Object.send(:remove_const, :ApplicationDecorator)
+      context "with the --parent option" do
+        before { run_generator %w(YourModel --parent=FooDecorator) }
+
+        it { should contain "class YourModelDecorator < FooDecorator" }
       end
 
-      subject { file('app/decorators/your_model_decorator.rb') }
-      it { should exist }
-      it { should contain "class YourModelDecorator < ApplicationDecorator" }
-    end
-  end
+      context "with an ApplicationDecorator" do
+        before do
+          Object.any_instance.stub(:require).with("application_decorator").and_return do
+            stub_const "ApplicationDecorator", Class.new
+          end
+        end
 
-  context 'using rspec' do
-    before { run_generator ["YourModel", "-t=rspec"]  }
+        before { run_generator %w(YourModel) }
 
-    describe 'spec/decorators/your_model_decorator_spec.rb' do
-      subject { file('spec/decorators/your_model_decorator_spec.rb') }
-      it { should exist }
-      it { should contain "describe YourModelDecorator" }
+        it { should contain "class YourModelDecorator < ApplicationDecorator" }
+      end
     end
   end
 
-  context 'using rspec with namespaced model' do
-    before { run_generator ["Namespace::YourModel", "-t=rspec"]  }
+  context "with -t=rspec" do
+    describe "the generated spec" do
+      subject { file("spec/decorators/your_model_decorator_spec.rb") }
 
-    describe 'spec/decorators/your_model_decorator_spec.rb' do
-      subject { file('spec/decorators/namespace/your_model_decorator_spec.rb') }
-      it { should exist }
-      it { should contain "describe Namespace::YourModelDecorator" }
-    end
-  end
+      describe "naming" do
+        before { run_generator %w(YourModel -t=rspec) }
 
-  context 'using test-unit' do
-    before { run_generator ["YourModel", "-t=test_unit"]  }
+        it { should contain "describe YourModelDecorator" }
+      end
+
+      describe "namespacing" do
+        subject { file("spec/decorators/namespace/your_model_decorator_spec.rb") }
+        before { run_generator %w(Namespace::YourModel -t=rspec) }
 
-    describe 'test/decorators/YourModel_decorator_test.rb' do
-      subject { file('test/decorators/your_model_decorator_test.rb') }
-      it { should exist }
-      it { should contain "class YourModelDecoratorTest < Draper::TestCase" }
+        it { should contain "describe Namespace::YourModelDecorator" }
+      end
     end
   end
 
-  context 'using test-unit with namespaced model' do
-    before { run_generator ["Namespace::YourModel", "-t=test_unit"]  }
+  context "with -t=test_unit" do
+    describe "the generated test" do
+      subject { file("test/decorators/your_model_decorator_test.rb") }
 
-    describe 'test/decorators/your_model_decorator_test.rb' do
-      subject { file('test/decorators/namespace/your_model_decorator_test.rb') }
-      it { should exist }
-      it { should contain "class Namespace::YourModelDecoratorTest < Draper::TestCase" }
-    end
-  end
+      describe "naming" do
+        before { run_generator %w(YourModel -t=test_unit) }
+
+        it { should contain "class YourModelDecoratorTest < Draper::TestCase" }
+      end
 
-  context 'using minitest-rails' do
-    before { run_generator ["YourModel", "-t=mini_test"] }
+      describe "namespacing" do
+        subject { file("test/decorators/namespace/your_model_decorator_test.rb") }
+        before { run_generator %w(Namespace::YourModel -t=test_unit) }
 
-    describe 'test/decorators/your_model_decorator_test.rb' do
-      subject { file('test/decorators/your_model_decorator_test.rb') }
-      it { should exist }
-      it { should contain "class YourModelDecoratorTest < Draper::TestCase" }
+        it { should contain "class Namespace::YourModelDecoratorTest < Draper::TestCase" }
+      end
     end
   end
 
-  context 'using minitest-rails with namespaced model' do
-    before { run_generator ["Namespace::YourModel", "-t=mini_test"] }
+  context "with -t=mini_test" do
+    describe "the generated test" do
+      subject { file("test/decorators/your_model_decorator_test.rb") }
 
-    describe 'test/decorators/your_model_decorator_test.rb' do
-      subject { file('test/decorators/namespace/your_model_decorator_test.rb') }
-      it { should exist }
-      it { should contain "class Namespace::YourModelDecoratorTest < Draper::TestCase" }
-    end
-  end
+      describe "naming" do
+        before { run_generator %w(YourModel -t=mini_test) }
 
-  context 'using minitest-rails with spec syntax' do
-    before { run_generator ["YourModel", "-t=mini_test", "--spec"] }
+        it { should contain "class YourModelDecoratorTest < Draper::TestCase" }
+      end
 
-    describe 'test/decorators/your_model_decorator_test.rb' do
-      subject { file('test/decorators/your_model_decorator_test.rb') }
-      it { should exist }
-      it { should contain "describe YourModelDecorator" }
+      describe "namespacing" do
+        subject { file("test/decorators/namespace/your_model_decorator_test.rb") }
+        before { run_generator %w(Namespace::YourModel -t=mini_test) }
+
+        it { should contain "class Namespace::YourModelDecoratorTest < Draper::TestCase" }
+      end
     end
   end
 
-  context 'using minitest-rails with spec syntax with namespaced model' do
-    before { run_generator ["Namespace::YourModel", "-t=mini_test", "--spec"] }
+  context "with -t=mini_test --spec" do
+    describe "the generated test" do
+      subject { file("test/decorators/your_model_decorator_test.rb") }
 
-    describe 'test/decorators/your_model_decorator_test.rb' do
-      subject { file('test/decorators/namespace/your_model_decorator_test.rb') }
-      it { should exist }
-      it { should contain "describe Namespace::YourModelDecorator" }
+      describe "naming" do
+        before { run_generator %w(YourModel -t=mini_test --spec) }
+
+        it { should contain "describe YourModelDecorator" }
+      end
+
+      describe "namespacing" do
+        subject { file("test/decorators/namespace/your_model_decorator_test.rb") }
+        before { run_generator %w(Namespace::YourModel -t=mini_test --spec) }
+
+        it { should contain "describe Namespace::YourModelDecorator" }
+      end
     end
   end