draper 0.18.0 → 1.0.0.beta1

data/lib/draper/decoratable.rb

@@ -0,0 +1,44 @@
+module Draper::Decoratable
+  extend ActiveSupport::Concern
+
+  def decorate(options = {})
+    decorator_class.decorate(self, options)
+  end
+
+  def decorator_class
+    self.class.decorator_class
+  end
+
+  def applied_decorators
+    []
+  end
+
+  def decorated_with?(decorator_class)
+    false
+  end
+
+  def decorated?
+    false
+  end
+
+  def ===(other)
+    super || (other.respond_to?(:source) && super(other.source))
+  end
+
+  module ClassMethods
+    def decorate(options = {})
+      decorator_class.decorate_collection(self.scoped, options)
+    end
+
+    def decorator_class
+      prefix = respond_to?(:model_name) ? model_name : name
+      "#{prefix}Decorator".constantize
+    rescue NameError
+      raise Draper::UninferrableDecoratorError.new(self)
+    end
+
+    def ===(other)
+      super || (other.respond_to?(:source) && super(other.source))
+    end
+  end
+end

data/lib/draper/decorated_association.rb

@@ -0,0 +1,55 @@
+module Draper
+  class DecoratedAssociation
+
+    attr_reader :source, :association, :options
+
+    def initialize(source, association, options)
+      @source = source
+      @association = association
+      @options = options
+    end
+
+    def call
+      return undecorated if undecorated.nil? || undecorated == []
+      decorate
+    end
+
+    private
+
+    def undecorated
+      @undecorated ||= begin
+        associated = source.send(association)
+        associated = associated.send(options[:scope]) if options[:scope]
+        associated
+      end
+    end
+
+    def decorate
+      @decorated ||= decorator_class.send(decorate_method, undecorated, options)
+    end
+
+    def decorate_method
+      if collection? && decorator_class.respond_to?(:decorate_collection)
+        :decorate_collection
+      else
+        :decorate
+      end
+    end
+
+    def collection?
+      undecorated.respond_to?(:first)
+    end
+
+    def decorator_class
+      return options[:with] if options[:with]
+
+      if collection?
+        options[:with] = :infer
+        Draper::CollectionDecorator
+      else
+        undecorated.decorator_class
+      end
+    end
+
+  end
+end

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_action_controller(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_action_mailer(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