drape 1.0.0.beta1

data/spec/draper/lazy_helpers_spec.rb

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

data/spec/draper/undecorate_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Drape, '.undecorate' do
+  it 'undecorates a decorated object' do
+    object = Model.new
+    decorator = Drape::Decorator.new(object)
+    expect(Drape.undecorate(decorator)).to equal object
+  end
+
+  it 'passes a non-decorated object through' do
+    object = Model.new
+    expect(Drape.undecorate(object)).to equal object
+  end
+
+  it 'passes a non-decorator object through' do
+    object = Object.new
+    expect(Drape.undecorate(object)).to equal object
+  end
+end

data/spec/draper/view_context/build_strategy_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+def fake_view_context
+  double('ViewContext')
+end
+
+def fake_controller(view_context = fake_view_context)
+  double('Controller', view_context: view_context, request: double('Request'))
+end
+
+module Drape
+  describe ViewContext::BuildStrategy::Full do
+    describe '#call' do
+      context 'when a current controller is set' do
+        it "returns the controller's view context" do
+          view_context = fake_view_context
+          ViewContext.stub controller: fake_controller(view_context)
+          strategy = ViewContext::BuildStrategy::Full.new
+
+          expect(strategy.call).to be view_context
+        end
+      end
+
+      context 'when a current controller is not set' do
+        it 'uses ApplicationController' do
+          view_context = fake_view_context
+          stub_const 'ApplicationController', double(new: fake_controller(view_context))
+          strategy = ViewContext::BuildStrategy::Full.new
+
+          expect(strategy.call).to be view_context
+        end
+      end
+
+      it 'adds a request if one is not defined' do
+        controller = Class.new(ActionController::Base).new
+        ViewContext.stub controller: controller
+        strategy = ViewContext::BuildStrategy::Full.new
+
+        expect(controller.request).to be_nil
+        strategy.call
+        expect(controller.request).to be_an ActionController::TestRequest
+        expect(controller.params).to eq({})
+
+        # sanity checks
+        expect(controller.view_context.request).to be controller.request
+        expect(controller.view_context.params).to be controller.params
+      end
+
+      it 'adds methods to the view context from the constructor block' do
+        ViewContext.stub controller: fake_controller
+        strategy = ViewContext::BuildStrategy::Full.new do
+          def a_helper_method; end
+        end
+
+        expect(strategy.call).to respond_to :a_helper_method
+      end
+
+      it 'includes modules into the view context from the constructor block' do
+        view_context = Object.new
+        ViewContext.stub controller: fake_controller(view_context)
+        helpers = Module.new do
+          def a_helper_method; end
+        end
+        strategy = ViewContext::BuildStrategy::Full.new do
+          include helpers
+        end
+
+        expect(strategy.call).to respond_to :a_helper_method
+      end
+    end
+  end
+
+  describe ViewContext::BuildStrategy::Fast do
+    describe '#call' do
+      it 'returns an instance of a subclass of ActionView::Base' do
+        strategy = ViewContext::BuildStrategy::Fast.new
+
+        returned = strategy.call
+
+        expect(returned).to be_an ActionView::Base
+        expect(returned.class).not_to be ActionView::Base
+      end
+
+      it 'returns different instances each time' do
+        strategy = ViewContext::BuildStrategy::Fast.new
+
+        expect(strategy.call).not_to be strategy.call
+      end
+
+      it 'returns the same subclass each time' do
+        strategy = ViewContext::BuildStrategy::Fast.new
+
+        expect(strategy.call.class).to be strategy.call.class
+      end
+
+      it 'adds methods to the view context from the constructor block' do
+        strategy = ViewContext::BuildStrategy::Fast.new do
+          def a_helper_method; end
+        end
+
+        expect(strategy.call).to respond_to :a_helper_method
+      end
+
+      it 'includes modules into the view context from the constructor block' do
+        helpers = Module.new do
+          def a_helper_method; end
+        end
+        strategy = ViewContext::BuildStrategy::Fast.new do
+          include helpers
+        end
+
+        expect(strategy.call).to respond_to :a_helper_method
+      end
+    end
+  end
+end

data/spec/draper/view_context_spec.rb

@@ -0,0 +1,160 @@
+require 'spec_helper'
+
+module Drape
+  describe ViewContext do
+    describe '#view_context' do
+      let(:base) do
+        Class.new do
+          def view_context
+            :controller_view_context
+                    end
+        end
+      end
+      let(:controller) { Class.new(base) { include ViewContext } }
+
+      it "saves the superclass's view context" do
+        ViewContext.should_receive(:current=).with(:controller_view_context)
+        controller.new.view_context
+      end
+
+      it "returns the superclass's view context" do
+        expect(controller.new.view_context).to be :controller_view_context
+      end
+    end
+
+    describe '.controller' do
+      it 'returns the stored controller from RequestStore' do
+        RequestStore.stub store: { current_controller: :stored_controller }
+
+        expect(ViewContext.controller).to be :stored_controller
+      end
+    end
+
+    describe '.controller=' do
+      it 'stores a controller in RequestStore' do
+        store = {}
+        RequestStore.stub store: store
+
+        ViewContext.controller = :stored_controller
+        expect(store[:current_controller]).to be :stored_controller
+      end
+    end
+
+    describe '.current' do
+      it 'returns the stored view context from RequestStore' do
+        RequestStore.stub store: { current_view_context: :stored_view_context }
+
+        expect(ViewContext.current).to be :stored_view_context
+      end
+
+      context 'when no view context is stored' do
+        it 'builds a view context' do
+          RequestStore.stub store: {}
+          ViewContext.stub build_strategy: -> { :new_view_context }
+          HelperProxy.stub(:new).with(:new_view_context).and_return(:new_helper_proxy)
+
+          expect(ViewContext.current).to be :new_helper_proxy
+        end
+
+        it 'stores the built view context' do
+          store = {}
+          RequestStore.stub store: store
+          ViewContext.stub build_strategy: -> { :new_view_context }
+          HelperProxy.stub(:new).with(:new_view_context).and_return(:new_helper_proxy)
+
+          ViewContext.current
+          expect(store[:current_view_context]).to be :new_helper_proxy
+        end
+      end
+    end
+
+    describe '.current=' do
+      it 'stores a helper proxy for the view context in RequestStore' do
+        store = {}
+        RequestStore.stub store: store
+        HelperProxy.stub(:new).with(:stored_view_context).and_return(:stored_helper_proxy)
+
+        ViewContext.current = :stored_view_context
+        expect(store[:current_view_context]).to be :stored_helper_proxy
+      end
+    end
+
+    describe '.clear!' do
+      it 'clears the stored controller and view controller' do
+        store = { current_controller: :stored_controller, current_view_context: :stored_view_context }
+        RequestStore.stub store: store
+
+        ViewContext.clear!
+        expect(store).not_to have_key :current_controller
+        expect(store).not_to have_key :current_view_context
+      end
+    end
+
+    describe '.build' do
+      it 'returns a new view context using the build strategy' do
+        ViewContext.stub build_strategy: -> { :new_view_context }
+
+        expect(ViewContext.build).to be :new_view_context
+      end
+    end
+
+    describe '.build!' do
+      it 'returns a helper proxy for the new view context' do
+        ViewContext.stub build_strategy: -> { :new_view_context }
+        HelperProxy.stub(:new).with(:new_view_context).and_return(:new_helper_proxy)
+
+        expect(ViewContext.build!).to be :new_helper_proxy
+      end
+
+      it 'stores the helper proxy' do
+        store = {}
+        RequestStore.stub store: store
+        ViewContext.stub build_strategy: -> { :new_view_context }
+        HelperProxy.stub(:new).with(:new_view_context).and_return(:new_helper_proxy)
+
+        ViewContext.build!
+        expect(store[:current_view_context]).to be :new_helper_proxy
+      end
+    end
+
+    describe '.build_strategy' do
+      it 'defaults to full' do
+        expect(ViewContext.build_strategy).to be_a ViewContext::BuildStrategy::Full
+      end
+
+      it 'memoizes' do
+        expect(ViewContext.build_strategy).to be ViewContext.build_strategy
+      end
+    end
+
+    describe '.test_strategy' do
+      protect_module ViewContext
+
+      context 'with :fast' do
+        it 'creates a fast strategy' do
+          ViewContext.test_strategy :fast
+          expect(ViewContext.build_strategy).to be_a ViewContext::BuildStrategy::Fast
+        end
+
+        it 'passes a block to the strategy' do
+          ViewContext::BuildStrategy::Fast.stub(:new) { |&block| block.call }
+
+          expect(ViewContext.test_strategy(:fast) { :passed }).to be :passed
+        end
+      end
+
+      context 'with :full' do
+        it 'creates a full strategy' do
+          ViewContext.test_strategy :full
+          expect(ViewContext.build_strategy).to be_a ViewContext::BuildStrategy::Full
+        end
+
+        it 'passes a block to the strategy' do
+          ViewContext::BuildStrategy::Full.stub(:new) { |&block| block.call }
+
+          expect(ViewContext.test_strategy(:full) { :passed }).to be :passed
+        end
+      end
+    end
+  end
+end

data/spec/draper/view_helpers_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+require 'support/shared_examples/view_helpers'
+
+module Drape
+  describe ViewHelpers do
+    it_behaves_like 'view helpers', Class.new { include ViewHelpers }.new
+  end
+end

data/spec/dummy/.gitignore

@@ -0,0 +1,21 @@
+# See https://help.github.com/articles/ignoring-files for more about ignoring files.
+#
+# If you find yourself ignoring temporary files generated by your text editor
+# or operating system, you probably want to add a global ignore instead:
+#   git config --global core.excludesfile '~/.gitignore_global'
+
+# Ignore bundler config.
+/.bundle
+
+# Ignore the default SQLite database.
+/db/*.sqlite3
+/db/*.sqlite3-journal
+
+# Ignore all logfiles and tempfiles.
+/log/*
+/tmp/*
+!/log/.keep
+!/tmp/.keep
+
+# Ignore Byebug command history file.
+.byebug_history

data/spec/dummy/Rakefile

@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require_relative 'config/application'
+
+Rails.application.load_tasks

data/spec/dummy/app/assets/config/manifest.js

@@ -0,0 +1,3 @@
+//= link_tree ../images
+//= link_directory ../javascripts .js
+//= link_directory ../stylesheets .css

data/spec/dummy/app/assets/javascripts/application.js

@@ -0,0 +1,16 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or any plugin's vendor/assets/javascripts directory can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file. JavaScript code in this file should be added after the last require_* statement.
+//
+// Read Sprockets README (https://github.com/rails/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require jquery
+//= require jquery_ujs
+//= require turbolinks
+//= require_tree .

data/spec/dummy/app/assets/javascripts/cable.js

@@ -0,0 +1,13 @@
+// Action Cable provides the framework to deal with WebSockets in Rails.
+// You can generate new channels where WebSocket features live using the rails generate channel command.
+//
+//= require action_cable
+//= require_self
+//= require_tree ./channels
+
+(function() {
+  this.App || (this.App = {});
+
+  App.cable = ActionCable.createConsumer();
+
+}).call(this);

data/spec/dummy/app/assets/stylesheets/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any other CSS/SCSS
+ * files in this directory. Styles in this file should be added after the last require_* statement.
+ * It is generally better to create a new file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/spec/dummy/app/channels/application_cable/channel.rb

@@ -0,0 +1,4 @@
+module ApplicationCable
+  class Channel < ActionCable::Channel::Base
+  end
+end

data/spec/dummy/app/channels/application_cable/connection.rb

@@ -0,0 +1,5 @@
+# Be sure to restart your server when you modify this file. Action Cable runs in a loop that does not support auto reloading.
+module ApplicationCable
+  class Connection < ActionCable::Connection::Base
+  end
+end

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

@@ -0,0 +1,5 @@
+class ApplicationController < ActionController::Base
+  # Prevent CSRF attacks by raising an exception.
+  # For APIs, you may want to use :null_session instead.
+  protect_from_forgery with: :exception
+end

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

@@ -0,0 +1,21 @@
+class PostsController < ApplicationController
+  decorates_assigned :post
+
+  def show
+    @post = Post.find(params[:id])
+  end
+
+  def mail
+    post = Post.find(params[:id])
+    email = PostMailer.decorated_email(post).deliver
+    render text: email.body
+  end
+
+  private
+
+  def goodnight_moon
+    'Goodnight, moon!'
+  end
+
+  helper_method :goodnight_moon
+end