drape 1.0.0.beta1

data/lib/drape/finders.rb

@@ -0,0 +1,36 @@
+module Drape
+  # Provides automatically-decorated finder methods for your decorators. You
+  # do not have to extend this module directly; it is extended by
+  # {Decorator.decorates_finders}.
+  module Finders
+    def find(id, options = {})
+      decorate(object_class.find(id), options)
+    end
+
+    def all(options = {})
+      decorate_collection(object_class.all, options)
+    end
+
+    def first(options = {})
+      decorate(object_class.first, options)
+    end
+
+    def last(options = {})
+      decorate(object_class.last, options)
+    end
+
+    # Decorates dynamic finder methods (`find_all_by_` and friends).
+    def method_missing(method, *args, &block)
+      return super unless method =~ /^find_(all_|last_|or_(initialize_|create_))?by_/
+
+      result = object_class.send(method, *args, &block)
+      options = args.extract_options!
+
+      if method =~ /^find_all/
+        decorate_collection(result, options)
+      else
+        decorate(result, options)
+      end
+    end
+  end
+end

data/lib/drape/helper_proxy.rb

@@ -0,0 +1,43 @@
+module Drape
+  # Provides access to helper methods - both Rails built-in helpers, and those
+  # defined in your application.
+  class HelperProxy
+    # @overload initialize(view_context)
+    def initialize(view_context = nil)
+      view_context ||= current_view_context # backwards compatibility
+
+      @view_context = view_context
+    end
+
+    # Sends helper methods to the view context.
+    def method_missing(method, *args, &block)
+      self.class.define_proxy method
+      send(method, *args, &block)
+    end
+
+    # Checks if the context responds to an instance method, or is able to
+    # proxy it to the view context.
+    def respond_to_missing?(method, include_private = false)
+      super || view_context.respond_to?(method)
+    end
+
+    delegate :capture, to: :view_context
+
+    def self.define_proxy(name)
+      define_method name do |*args, &block|
+        view_context.send(name, *args, &block)
+      end
+    end
+
+    protected
+
+    attr_reader :view_context
+
+    private
+
+    def current_view_context
+      ActiveSupport::Deprecation.warn('wrong number of arguments (0 for 1) passed to Drape::HelperProxy.new', caller[1..-1])
+      Drape::ViewContext.current.view_context
+    end
+  end
+end

data/lib/drape/helper_support.rb

@@ -0,0 +1,5 @@
+module Drape::HelperSupport
+  def decorate(input, &block)
+    capture { block.call(input.decorate) }
+  end
+end

data/lib/drape/lazy_helpers.rb

@@ -0,0 +1,13 @@
+module Drape
+  # Include this module in your decorators to get direct access to the helpers
+  # so that you can stop typing `h.` everywhere, at the cost of mixing in a
+  # bazillion methods.
+  module LazyHelpers
+    # Sends missing methods to the {HelperProxy}.
+    def method_missing(method, *args, &block)
+      helpers.send(method, *args, &block)
+    rescue NoMethodError
+      super
+    end
+  end
+end

data/lib/drape/railtie.rb

@@ -0,0 +1,69 @@
+require 'rails/railtie'
+
+module ActiveModel
+  class Railtie < Rails::Railtie
+    generators do |app|
+      app ||= Rails.application # Rails 3.0.x does not yield `app`
+
+      Rails::Generators.configure! app.config.generators
+      require_relative '../generators/controller_override'
+    end
+  end
+end
+
+module Drape
+  class Railtie < Rails::Railtie
+    config.after_initialize do |app|
+      app.config.paths.add 'app/decorators', eager_load: true
+
+      if Rails.env.test?
+        require 'drape/test_case'
+        require 'drape/test/rspec_integration' if defined?(RSpec) && RSpec.respond_to?(:configure)
+      end
+    end
+
+    initializer 'drape.setup_action_controller' do |_app|
+      ActiveSupport.on_load :action_controller do
+        Drape.setup_action_controller self
+      end
+    end
+
+    initializer 'drape.setup_action_mailer' do |_app|
+      ActiveSupport.on_load :action_mailer do
+        Drape.setup_action_mailer self
+      end
+    end
+
+    initializer 'drape.setup_orm' do |_app|
+      [:active_record, :mongoid].each do |orm|
+        ActiveSupport.on_load orm do
+          Drape.setup_orm self
+        end
+      end
+    end
+
+    initializer 'drape.setup_active_model_serializers' do |_app|
+      ActiveSupport.on_load :active_model_serializers do
+        if defined?(ActiveModel::ArraySerializerSupport)
+          Drape::CollectionDecorator.send :include, ActiveModel::ArraySerializerSupport
+        end
+      end
+    end
+
+    initializer 'drape.minitest-rails_integration' do |_app|
+      ActiveSupport.on_load :minitest do
+        require 'drape/test/minitest_integration'
+      end
+    end
+
+    console do
+      require 'action_controller/test_case'
+      ApplicationController.new.view_context
+      Drape::ViewContext.build
+    end
+
+    rake_tasks do
+      Dir[File.join(File.dirname(__FILE__), 'tasks/*.rake')].each { |f| load f }
+    end
+  end
+end

data/lib/drape/tasks/test.rake

@@ -0,0 +1,9 @@
+require 'rake/testtask'
+require 'rails/test_unit/railtie'
+
+namespace :test do
+  Rake::TestTask.new(decorators: 'test:prepare') do |t|
+    t.libs << 'test'
+    t.pattern = 'test/decorators/**/*_test.rb'
+  end
+end

data/lib/drape/test/devise_helper.rb

@@ -0,0 +1,30 @@
+module Drape
+  module DeviseHelper
+    def sign_in(resource_or_scope, resource = nil)
+      scope = begin
+        Devise::Mapping.find_scope!(resource_or_scope)
+      rescue RuntimeError => e
+        # Drape 1.0 didn't require the mapping to exist
+        ActiveSupport::Deprecation.warn("#{e.message}.\nUse `sign_in :user, mock_user` instead.", caller)
+        :user
+      end
+
+      _stub_current_scope scope, resource || resource_or_scope
+    end
+
+    def sign_out(resource_or_scope)
+      scope = Devise::Mapping.find_scope!(resource_or_scope)
+      _stub_current_scope scope, nil
+    end
+
+    private
+
+    def _stub_current_scope(scope, resource)
+      Drape::ViewContext.current.controller.singleton_class.class_eval do
+        define_method "current_#{scope}" do
+          resource
+        end
+      end
+    end
+  end
+end

data/lib/drape/test/minitest_integration.rb

@@ -0,0 +1,6 @@
+class Drape::TestCase
+  register_spec_type(self) do |desc|
+    desc < Drape::Decorator || desc < Drape::CollectionDecorator if desc.is_a?(Class)
+  end
+  register_spec_type(/Decorator( ?Test)?\z/i, self)
+end

data/lib/drape/test/rspec_integration.rb

@@ -0,0 +1,20 @@
+module Drape
+  module DecoratorExampleGroup
+    include Drape::TestCase::Behavior
+    extend ActiveSupport::Concern
+
+    included { metadata[:type] = :decorator }
+  end
+
+  RSpec.configure do |config|
+    if RSpec::Core::Version::STRING.starts_with?('3')
+      config.include DecoratorExampleGroup, file_path: %r{spec/decorators}, type: :decorator
+    else
+      config.include DecoratorExampleGroup, example_group: { file_path: %r{spec/decorators} }, type: :decorator
+    end
+
+    [:decorator, :controller, :mailer].each do |type|
+      config.before(:each, type: type) { Drape::ViewContext.clear! }
+    end
+  end
+end

data/lib/drape/test_case.rb

@@ -0,0 +1,42 @@
+module Drape
+  require 'active_support/test_case'
+
+  class TestCase < ::ActiveSupport::TestCase
+    module ViewContextTeardown
+      def teardown
+        super
+        Drape::ViewContext.clear!
+      end
+    end
+
+    module Behavior
+      if defined?(::Devise)
+        require 'drape/test/devise_helper'
+        include Drape::DeviseHelper
+      end
+
+      if defined?(::Capybara) && (defined?(::RSpec) || defined?(::MiniTest::Matchers))
+        require 'capybara/rspec/matchers'
+        include ::Capybara::RSpecMatchers
+      end
+
+      include Drape::ViewHelpers::ClassMethods
+      alias helper helpers
+    end
+
+    include Behavior
+    include ViewContextTeardown
+  end
+end
+
+if defined?(ActionController::TestCase)
+  class ActionController::TestCase
+    include Drape::TestCase::ViewContextTeardown
+  end
+end
+
+if defined?(ActionMailer::TestCase)
+  class ActionMailer::TestCase
+    include Drape::TestCase::ViewContextTeardown
+  end
+end

data/lib/drape/undecorate.rb

@@ -0,0 +1,9 @@
+module Drape
+  def self.undecorate(object)
+    if object.respond_to?(:decorated?) && object.decorated?
+      object.object
+    else
+      object
+    end
+  end
+end

data/lib/drape/version.rb

@@ -0,0 +1,3 @@
+module Drape
+  VERSION = '1.0.0.beta1'
+end

data/lib/drape/view_context.rb

@@ -0,0 +1,104 @@
+require 'drape/view_context/build_strategy'
+require 'request_store'
+
+module Drape
+  module ViewContext
+    # Hooks into a controller or mailer to save the view context in {current}.
+    def view_context
+      super.tap do |context|
+        Drape::ViewContext.current = context
+      end
+    end
+
+    # Set the current controller
+    def activate_drape
+      Drape::ViewContext.controller = self
+    end
+
+    # Returns the current controller.
+    def self.controller
+      RequestStore.store[:current_controller]
+    end
+
+    # Sets the current controller.
+    def self.controller=(controller)
+      RequestStore.store[:current_controller] = controller
+    end
+
+    # Returns the current view context, or builds one if none is saved.
+    #
+    # @return [HelperProxy]
+    def self.current
+      RequestStore.store.fetch(:current_view_context) { build! }
+    end
+
+    # Sets the current view context.
+    def self.current=(view_context)
+      RequestStore.store[:current_view_context] = Drape::HelperProxy.new(view_context)
+    end
+
+    # Clears the saved controller and view context.
+    def self.clear!
+      RequestStore.store.delete :current_controller
+      RequestStore.store.delete :current_view_context
+    end
+
+    # Builds a new view context for usage in tests. See {test_strategy} for
+    # details of how the view context is built.
+    def self.build
+      build_strategy.call
+    end
+
+    # Builds a new view context and sets it as the current view context.
+    #
+    # @return [HelperProxy]
+    def self.build!
+      # send because we want to return the HelperProxy returned from #current=
+      send :current=, build
+    end
+
+    # Configures the strategy used to build view contexts in tests, which
+    # defaults to `:full` if `test_strategy` has not been called. Evaluates
+    # the block, if given, in the context of the view context's class.
+    #
+    # @example Pass a block to add helper methods to the view context:
+    #   Drape::ViewContext.test_strategy :fast do
+    #     include ApplicationHelper
+    #   end
+    #
+    # @param [:full, :fast] name
+    #   the strategy to use:
+    #
+    #   `:full` - build a fully-working view context. Your Rails environment
+    #   must be loaded, including your `ApplicationController`.
+    #
+    #   `:fast` - build a minimal view context in tests, with no dependencies
+    #   on other components of your application.
+    def self.test_strategy(name, &block)
+      @build_strategy = Drape::ViewContext::BuildStrategy.new(name, &block)
+    end
+
+    # @private
+    def self.build_strategy
+      @build_strategy ||= Drape::ViewContext::BuildStrategy.new(:full)
+    end
+
+    # @deprecated Use {controller} instead.
+    def self.current_controller
+      ActiveSupport::Deprecation.warn('Drape::ViewContext.current_controller is deprecated (use controller instead)', caller)
+      controller || ApplicationController.new
+    end
+
+    # @deprecated Use {controller=} instead.
+    def self.current_controller=(controller)
+      ActiveSupport::Deprecation.warn('Drape::ViewContext.current_controller= is deprecated (use controller instead)', caller)
+      self.controller = controller
+    end
+
+    # @deprecated Use {build} instead.
+    def self.build_view_context
+      ActiveSupport::Deprecation.warn('Drape::ViewContext.build_view_context is deprecated (use build instead)', caller)
+      build
+    end
+  end
+end

data/lib/drape/view_context/build_strategy.rb

@@ -0,0 +1,46 @@
+module Drape
+  module ViewContext
+    # @private
+    module BuildStrategy
+      def self.new(name, &block)
+        const_get(name.to_s.camelize).new(&block)
+      end
+
+      class Fast
+        def initialize(&block)
+          @view_context_class = Class.new(ActionView::Base, &block)
+        end
+
+        def call
+          view_context_class.new
+        end
+
+        private
+
+        attr_reader :view_context_class
+      end
+
+      class Full
+        def initialize(&block)
+          @block = block
+        end
+
+        def call
+          controller.view_context.tap do |context|
+            context.singleton_class.class_eval(&block) if block
+          end
+        end
+
+        private
+
+        attr_reader :block
+
+        def controller
+          (Drape::ViewContext.controller || ApplicationController.new).tap do |controller|
+            controller.request ||= ActionController::TestRequest.create if defined?(ActionController::TestRequest)
+          end
+        end
+      end
+    end
+  end
+end