draper 0.17.0 → 1.0.0.beta1

data/lib/draper/decorator.rb

@@ -0,0 +1,208 @@
+require 'active_support/core_ext/array/extract_options'
+
+module Draper
+  class Decorator
+    include Draper::ViewHelpers
+    include ActiveModel::Serialization if defined?(ActiveModel::Serialization)
+
+    attr_accessor :source, :options
+
+    alias_method :model, :source
+    alias_method :to_source, :source
+
+    # Initialize a new decorator instance by passing in
+    # an instance of the source class. Pass in an optional
+    # context inside the options hash is stored for later use.
+    #
+    # A decorator cannot be applied to other instances of the
+    # same decorator and will instead result in a decorator
+    # with the same target as the original.
+    # You can, however, apply several decorators in a chain but
+    # you will get a warning if the same decorator appears at
+    # multiple places in the chain.
+    #
+    # @param [Object] source object to decorate
+    # @param [Hash] options (optional)
+    def initialize(source, options = {})
+      source.to_a if source.respond_to?(:to_a) # forces evaluation of a lazy query from AR
+      @source = source
+      @options = options
+      handle_multiple_decoration if source.is_a?(Draper::Decorator)
+    end
+
+    class << self
+      alias_method :decorate, :new
+    end
+
+    # Adds ActiveRecord finder methods to the decorator class. The
+    # methods return decorated models, so that you can use
+    # `ProductDecorator.find(id)` instead of
+    # `ProductDecorator.decorate(Product.find(id))`.
+    #
+    # If the `:for` option is not supplied, the model class will be
+    # inferred from the decorator class.
+    #
+    # @option options [Class, Symbol] :for The model class to find
+    def self.has_finders(options = {})
+      extend Draper::Finders
+      self.finder_class = options[:for] || name.chomp("Decorator")
+    end
+
+    # Typically called within a decorator definition, this method causes
+    # the assocation to be decorated when it is retrieved.
+    #
+    # @param [Symbol] association name of association to decorate, like `:products`
+    # @option options [Class] :with the decorator to apply to the association
+    # @option options [Symbol] :scope a scope to apply when fetching the association
+    def self.decorates_association(association, options = {})
+      define_method(association) do
+        decorated_associations[association] ||= Draper::DecoratedAssociation.new(source, association, options)
+        decorated_associations[association].call
+      end
+    end
+
+    # A convenience method for decorating multiple associations. Calls
+    # decorates_association on each of the given symbols.
+    #
+    # @param [Symbols*] associations name of associations to decorate
+    def self.decorates_associations(*associations)
+      options = associations.extract_options!
+      associations.each do |association|
+        decorates_association(association, options)
+      end
+    end
+
+    # Specifies a black list of methods which may *not* be proxied to
+    # the wrapped object.
+    #
+    # Do not use both `.allows` and `.denies` together, either write
+    # a whitelist with `.allows` or a blacklist with `.denies`
+    #
+    # @param [Symbols*] methods methods to deny like `:find, :find_by_name`
+    def self.denies(*methods)
+      security.denies(*methods)
+    end
+
+    # Specifies that all methods may *not* be proxied to the wrapped object.
+    #
+    # Do not use `.allows` and `.denies` in combination with '.denies_all'
+    def self.denies_all
+      security.denies_all
+    end
+
+    # Specifies a white list of methods which *may* be proxied to
+    # the wrapped object. When `allows` is used, only the listed
+    # methods and methods defined in the decorator itself will be
+    # available.
+    #
+    # Do not use both `.allows` and `.denies` together, either write
+    # a whitelist with `.allows` or a blacklist with `.denies`
+    #
+    # @param [Symbols*] methods methods to allow like `:find, :find_by_name`
+    def self.allows(*methods)
+      security.allows(*methods)
+    end
+
+    # Creates a new CollectionDecorator for the given collection.
+    #
+    # @param [Object] source collection to decorate
+    # @param [Hash] options passed to each item's decorator (except
+    #   for the keys listed below)
+    # @option options [Class,Symbol] :with (self) the class used to decorate
+    #   items, or `:infer` to call each item's `decorate` method instead
+    def self.decorate_collection(source, options = {})
+      Draper::CollectionDecorator.new(source, options.reverse_merge(with: self))
+    end
+
+    # Get the chain of decorators applied to the object.
+    #
+    # @return [Array] list of decorator classes
+    def applied_decorators
+      chain = source.respond_to?(:applied_decorators) ? source.applied_decorators : []
+      chain << self.class
+    end
+
+    # Checks if a given decorator has been applied.
+    #
+    # @param [Class] decorator_class
+    def decorated_with?(decorator_class)
+      applied_decorators.include?(decorator_class)
+    end
+
+    def decorated?
+      true
+    end
+
+    # Delegates == to the decorated models
+    #
+    # @return [Boolean] true if other's model == self's model
+    def ==(other)
+      source == (other.respond_to?(:source) ? other.source : other)
+    end
+
+    def kind_of?(klass)
+      super || source.kind_of?(klass)
+    end
+    alias_method :is_a?, :kind_of?
+
+    def respond_to?(method, include_private = false)
+      super || (allow?(method) && source.respond_to?(method, include_private))
+    end
+
+    # We always want to delegate present, in case we decorate a nil object.
+    #
+    # I don't like the idea of decorating a nil object, but we'll deal with
+    # that later.
+    def present?
+      source.present?
+    end
+
+    def method_missing(method, *args, &block)
+      if allow?(method) && source.respond_to?(method)
+        self.class.define_proxy(method)
+        send(method, *args, &block)
+      else
+        super
+      end
+    end
+
+    # For ActiveModel compatibilty
+    def to_model
+      self
+    end
+
+    # For ActiveModel compatibility
+    def to_param
+      source.to_param
+    end
+
+    private
+
+    def self.define_proxy(method)
+      define_method(method) do |*args, &block|
+        source.send(method, *args, &block)
+      end
+    end
+
+    def self.security
+      @security ||= Security.new
+    end
+
+    def allow?(method)
+      self.class.security.allow?(method)
+    end
+
+    def handle_multiple_decoration
+      if source.instance_of?(self.class)
+        self.options = source.options if options.empty?
+        self.source = source.source
+      elsif source.decorated_with?(self.class)
+        warn "Reapplying #{self.class} decorator to target that is already decorated with it. Call stack:\n#{caller(1).join("\n")}"
+      end
+    end
+
+    def decorated_associations
+      @decorated_associations ||= {}
+    end
+  end
+end

data/lib/draper/finders.rb

@@ -0,0 +1,44 @@
+module Draper
+  module Finders
+
+    attr_reader :finder_class
+    def finder_class=(klass)
+      @finder_class = klass.to_s.camelize.constantize
+    end
+
+    def find(id, options = {})
+      decorate(finder_class.find(id), options)
+    end
+
+    def all(options = {})
+      decorate_collection(finder_class.all, options)
+    end
+
+    def first(options = {})
+      decorate(finder_class.first, options)
+    end
+
+    def last(options = {})
+      decorate(finder_class.last, options)
+    end
+
+    def method_missing(method, *args, &block)
+      result = finder_class.send(method, *args, &block)
+      options = args.extract_options!
+
+      case method.to_s
+      when /^find_((last_)?by_|or_(initialize|create)_by_)/
+        decorate(result, options)
+      when /^find_all_by_/
+        decorate_collection(result, options)
+      else
+        result
+      end
+    end
+
+    def respond_to?(method, include_private = false)
+      super || finder_class.respond_to?(method)
+    end
+
+  end
+end

data/lib/draper/helper_proxy.rb

@@ -0,0 +1,16 @@
+module Draper
+  class HelperProxy
+    # Some helpers are private, for example html_escape... as a workaround
+    # we are wrapping the helpers in a delegator that passes the methods
+    # along through a send, which will ignore private/public distinctions
+    def method_missing(method, *args, &block)
+      view_context.send(method, *args, &block)
+    end
+
+    private
+
+    def view_context
+      Draper::ViewContext.current
+    end
+  end
+end

data/lib/draper/railtie.rb

@@ -3,8 +3,8 @@ require 'rails/railtie'
 module ActiveModel
   class Railtie < Rails::Railtie
     generators do |app|
-      Rails::Generators.configure!(app.config.generators)
-      require "generators/resource_override"
+      Rails::Generators.configure! app.config.generators
+      require 'generators/resource_override'
     end
   end
 end
@@ -12,40 +12,36 @@ end
 module Draper
   class Railtie < Rails::Railtie
 
-    ##
-    # The `app/decorators` path is eager loaded
-    #
-    # This is the standard "Rails Way" to add paths from which constants
-    # can be loaded.
-    #
     config.after_initialize do |app|
-      app.config.paths.add 'app/decorators', :eager_load => true
+      app.config.paths.add 'app/decorators', eager_load: true
     end
 
-    initializer "draper.extend_action_controller_base" do |app|
-      ActiveSupport.on_load(:action_controller) do
-        Draper::System.setup(self)
+    initializer "draper.setup_action_controller" do |app|
+      ActiveSupport.on_load :action_controller do
+        Draper.setup_action_controller self
       end
     end
 
-    initializer "draper.extend_action_mailer_base" do |app|
-      ActiveSupport.on_load(:action_mailer) do
-        Draper::System.setup(self)
+    initializer "draper.setup_action_mailer" do |app|
+      ActiveSupport.on_load :action_mailer do
+        Draper.setup_action_mailer self
       end
     end
 
-    initializer "draper.extend_active_record_base" do |app|
-      ActiveSupport.on_load(:active_record) do
-        self.send(:include, Draper::ModelSupport)
+    initializer "draper.setup_active_record" do |app|
+      ActiveSupport.on_load :active_record do
+        Draper.setup_active_record self
       end
     end
 
     console do
       require 'action_controller/test_case'
       ApplicationController.new.view_context
-      Draper::ViewContext.current.controller.request ||= ActionController::TestRequest.new
-      Draper::ViewContext.current.request            ||= Draper::ViewContext.current.controller.request
-      Draper::ViewContext.current.params             ||= {}
+      Draper::ViewContext.build_view_context
+    end
+
+    rake_tasks do
+      Dir[File.join(File.dirname(__FILE__),'tasks/*.rake')].each { |f| load f }
     end
   end
 end

data/lib/draper/security.rb

@@ -0,0 +1,48 @@
+module Draper
+  class Security
+    def initialize
+      @methods = []
+    end
+
+    def denies(*methods)
+      apply_strategy :denies
+      add_methods methods
+    end
+
+    def denies_all
+      apply_strategy :denies_all
+    end
+
+    def allows(*methods)
+      apply_strategy :allows
+      add_methods methods
+    end
+
+    def allow?(method)
+      case strategy
+      when :allows
+        methods.include?(method)
+      when :denies
+        !methods.include?(method)
+      when :denies_all
+        false
+      when nil
+        true
+      end
+    end
+
+    private
+
+    attr_reader :methods, :strategy
+
+    def apply_strategy(new_strategy)
+      raise ArgumentError, "Use only one of 'allows', 'denies', or 'denies_all'." if strategy && strategy != new_strategy
+      @strategy = new_strategy
+    end
+
+    def add_methods(new_methods)
+      raise ArgumentError, "Specify at least one method when using #{strategy}" if new_methods.empty?
+      @methods += new_methods.map(&:to_sym)
+    end
+  end
+end

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,26 +1,7 @@
-require 'draper/test/view_context'
-
-module MiniTest
-  class Spec
-    class Decorator < Spec
-      before { Draper::ViewContext.infect!(self) }
-    end
+class MiniTest::Rails::ActiveSupport::TestCase
+  # Use AS::TestCase for the base class when describing a decorator
+  register_spec_type(self) do |desc|
+    desc < Draper::Decorator if desc.is_a?(Class)
   end
-end
-
-class MiniTest::Unit::DecoratorTestCase < MiniTest::Unit::TestCase
-  if method_defined?(:before_setup)
-    # for minitext >= 2.11
-    def before_setup
-      super
-      Draper::ViewContext.infect!(self)
-    end
-  else
-    # for older minitest, like what ships w/Ruby 1.9
-    add_setup_hook { Draper::ViewContext.infect!(self) }
-  end
-end
-
-MiniTest::Spec.register_spec_type(MiniTest::Spec::Decorator) do |desc|
-  desc.superclass == Draper::Base
+  register_spec_type(/Decorator( ?Test)?\z/i, self)
 end

data/lib/draper/test/rspec_integration.rb

@@ -1,5 +1,3 @@
-require 'draper/test/view_context'
-
 module Draper
   module DecoratorExampleGroup
     extend ActiveSupport::Concern
@@ -13,10 +11,6 @@ RSpec.configure do |config|
     :file_path => /spec[\\\/]decorators/
   }
 
-  # Specs tagged type: :decorator set the Draper view context
-  config.before :type => :decorator do
-    Draper::ViewContext.infect!(self)
-  end
 end
 
 if defined?(Capybara)

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.17.0"
+  VERSION = "1.0.0.beta1"
 end

data/lib/draper/view_context.rb

@@ -1,16 +1,34 @@
 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
+
+    def self.current_controller=(controller)
+      Thread.current[:current_controller] = controller
+    end
+
     def self.current
-      Thread.current[:current_view_context] || ApplicationController.new.view_context
+      Thread.current[:current_view_context] ||= build_view_context
     end
 
-    def self.current=(input)
-      Thread.current[:current_view_context] = input
+    def self.current=(context)
+      Thread.current[:current_view_context] = context
     end
 
-    def view_context
-      super.tap do |context|
-        Draper::ViewContext.current = context
+    def self.build_view_context
+      current_controller.view_context.tap do |context|
+        if defined?(ActionController::TestRequest)
+          context.controller.request ||= ActionController::TestRequest.new
+          context.request            ||= context.controller.request
+          context.params             ||= {}
+        end
       end
     end
   end

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/draper.rb

@@ -1,16 +1,51 @@
 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
+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