draper 1.1.0 → 1.2.0

data/lib/draper/automatic_delegation.rb

@@ -12,7 +12,7 @@ module Draper
 
     # Checks if the decorator responds to an instance method, or is able to
     # proxy it to the source object.
-    def respond_to?(method, include_private = false)
+    def respond_to_missing?(method, include_private = false)
       super || delegatable?(method)
     end
 
@@ -31,7 +31,7 @@ module Draper
 
       # Checks if the decorator responds to a class method, or is able to proxy
       # it to the source class.
-      def respond_to?(method, include_private = false)
+      def respond_to_missing?(method, include_private = false)
         super || delegatable?(method)
       end
 
@@ -39,6 +39,12 @@ module Draper
       def delegatable?(method)
         source_class? && source_class.respond_to?(method)
       end
+
+      # @private
+      # Avoids reloading the model class when ActiveSupport clears autoloaded
+      # dependencies in development mode.
+      def before_remove_const
+      end
     end
 
     included do

data/lib/draper/collection_decorator.rb

@@ -4,6 +4,10 @@ module Draper
     include Draper::ViewHelpers
     extend Draper::Delegation
 
+    # @return [Class] the decorator class used to decorate each item, as set by
+    #   {#initialize}.
+    attr_reader :decorator_class
+
     # @return [Hash] extra data to be used in user-defined methods, and passed
     #   to each item's decorator.
     attr_accessor :context
@@ -49,13 +53,7 @@ module Draper
     end
 
     def to_s
-      klass = begin
-        decorator_class
-      rescue Draper::UninferrableDecoratorError
-        "inferred decorators"
-      end
-
-      "#<#{self.class.name} of #{klass} for #{source.inspect}>"
+      "#<#{self.class.name} of #{decorator_class || "inferred decorators"} for #{source.inspect}>"
     end
 
     def context=(value)
@@ -63,12 +61,17 @@ module Draper
       each {|item| item.context = value } if @decorated_collection
     end
 
-    # @return [Class] the decorator class used to decorate each item, as set by
-    #   {#initialize} or as inferred from the collection decorator class (e.g.
-    #   `ProductsDecorator` maps to `ProductDecorator`).
-    def decorator_class
-      @decorator_class ||= self.class.inferred_decorator_class
+    # @return [true]
+    def decorated?
+      true
+    end
+
+    alias_method :decorated_with?, :instance_of?
+
+    def kind_of?(klass)
+      decorated_collection.kind_of?(klass) || super
     end
+    alias_method :is_a?, :kind_of?
 
     protected
 
@@ -82,24 +85,10 @@ module Draper
 
     private
 
-    def self.inferred_decorator_class
-      decorator_name = "#{name.chomp("Decorator").singularize}Decorator"
-      decorator_uninferrable if decorator_name == name
-
-      decorator_name.constantize
-
-    rescue NameError
-      decorator_uninferrable
-    end
-
-    def self.decorator_uninferrable
-      raise Draper::UninferrableDecoratorError.new(self)
-    end
-
     def item_decorator
-      @item_decorator ||= begin
+      if decorator_class
         decorator_class.method(:decorate)
-      rescue Draper::UninferrableDecoratorError
+      else
         ->(item, options) { item.decorate(options) }
       end
     end

data/lib/draper/decoratable.rb

@@ -52,7 +52,8 @@ module Draper
       # @param [Hash] options
       #   see {Decorator.decorate_collection}.
       def decorate(options = {})
-        decorator_class.decorate_collection(self.scoped, options)
+        collection = Rails::VERSION::MAJOR >= 4 ? all : scoped
+        decorator_class.decorate_collection(collection, options.reverse_merge(with: nil))
       end
 
       # Infers the decorator class to be used by {Decoratable#decorate} (e.g.
@@ -61,8 +62,10 @@ module Draper
       # @return [Class] the inferred decorator class.
       def decorator_class
         prefix = respond_to?(:model_name) ? model_name : name
-        "#{prefix}Decorator".constantize
-      rescue NameError
+        decorator_name = "#{prefix}Decorator"
+        decorator_name.constantize
+      rescue NameError => error
+        raise unless error.missing_name?(decorator_name)
         raise Draper::UninferrableDecoratorError.new(self)
       end
 

data/lib/draper/decoratable/equality.rb

@@ -5,9 +5,21 @@ module Draper
       #
       # @return [Boolean]
       def ==(other)
-        super ||
-          other.respond_to?(:decorated?) && other.decorated? &&
-          other.respond_to?(:source) && self == other.source
+        super || Equality.test_for_decorator(self, other)
+      end
+
+      # Compares an object to a possibly-decorated object.
+      #
+      # @return [Boolean]
+      def self.test(object, other)
+        return object == other if object.is_a?(Decoratable)
+        object == other || test_for_decorator(object, other)
+      end
+
+      # @private
+      def self.test_for_decorator(object, other)
+        other.respond_to?(:decorated?) && other.decorated? &&
+        other.respond_to?(:source) && test(object, other.source)
       end
     end
   end

data/lib/draper/decorated_association.rb

@@ -8,66 +8,27 @@ module Draper
       @owner = owner
       @association = association
 
-      @decorator_class = options[:with]
       @scope = options[:scope]
-      @context = options.fetch(:context, owner.context)
-    end
 
-    def call
-      return undecorated if undecorated.nil?
-      decorated
+      decorator_class = options[:with]
+      context = options.fetch(:context, ->(context){ context })
+      @factory = Draper::Factory.new(with: decorator_class, context: context)
     end
 
-    def context
-      return @context.call(owner.context) if @context.respond_to?(:call)
-      @context
+    def call
+      decorate unless defined?(@decorated)
+      @decorated
     end
 
     private
 
-    attr_reader :owner, :association, :scope
-
-    def source
-      owner.source
-    end
-
-    def undecorated
-      @undecorated ||= begin
-        associated = source.send(association)
-        associated = associated.send(scope) if scope
-        associated
-      end
-    end
-
-    def decorated
-      @decorated ||= decorator.call(undecorated, context: context)
-    end
+    attr_reader :factory, :owner, :association, :scope
 
-    def collection?
-      undecorated.respond_to?(:first)
-    end
-
-    def decorator
-      return collection_decorator if collection?
-      decorator_class.method(:decorate)
-    end
-
-    def collection_decorator
-      klass = decorator_class || Draper::CollectionDecorator
-
-      if klass.respond_to?(:decorate_collection)
-        klass.method(:decorate_collection)
-      else
-        klass.method(:decorate)
-      end
-    end
-
-    def decorator_class
-      @decorator_class || inferred_decorator_class
-    end
+    def decorate
+      associated = owner.source.send(association)
+      associated = associated.send(scope) if scope
 
-    def inferred_decorator_class
-      undecorated.decorator_class if undecorated.respond_to?(:decorator_class)
+      @decorated = factory.decorate(associated, context_args: owner.context)
     end
 
   end

data/lib/draper/decorates_assigned.rb

@@ -0,0 +1,44 @@
+module Draper
+  module DecoratesAssigned
+    # @overload decorates_assigned(*variables, options = {})
+    #   Defines a helper method to access decorated instance variables.
+    #
+    #   @example
+    #     # app/controllers/articles_controller.rb
+    #     class ArticlesController < ApplicationController
+    #       decorates_assigned :article
+    #
+    #       def show
+    #         @article = Article.find(params[:id])
+    #       end
+    #     end
+    #
+    #     # app/views/articles/show.html.erb
+    #     <%= article.decorated_title %>
+    #
+    #   @param [Symbols*] variables
+    #     names of the instance variables to decorate (without the `@`).
+    #   @param [Hash] options
+    #   @option options [Decorator, CollectionDecorator] :with (nil)
+    #     decorator class to use. If nil, it is inferred from the instance
+    #     variable.
+    #   @option options [Hash, #call] :context
+    #     extra data to be stored in the decorator. If a Proc is given, it will
+    #     be passed the controller and should return a new context hash.
+    def decorates_assigned(*variables)
+      factory = Draper::Factory.new(variables.extract_options!)
+
+      variables.each do |variable|
+        undecorated = "@#{variable}"
+        decorated = "@decorated_#{variable}"
+
+        define_method variable do
+          return instance_variable_get(decorated) if instance_variable_defined?(decorated)
+          instance_variable_set decorated, factory.decorate(instance_variable_get(undecorated), context_args: self)
+        end
+
+        helper_method variable
+      end
+    end
+  end
+end

data/lib/draper/decorator.rb

@@ -2,7 +2,10 @@ module Draper
   class Decorator
     include Draper::ViewHelpers
     extend Draper::Delegation
+
     include ActiveModel::Serialization
+    include ActiveModel::Serializers::JSON
+    include ActiveModel::Serializers::Xml
 
     # @return the object being decorated.
     attr_reader :source
@@ -160,7 +163,7 @@ module Draper
     #
     # @return [Boolean]
     def ==(other)
-      source.extend(Draper::Decoratable::Equality) == other
+      Draper::Decoratable::Equality.test(source, other)
     end
 
     # Checks if `self.kind_of?(klass)` or `source.kind_of?(klass)`
@@ -187,16 +190,24 @@ module Draper
       self
     end
 
+    # @return [Hash] the source's attributes, sliced to only include those
+    # implemented by the decorator.
+    def attributes
+      source.attributes.select {|attribute, _| respond_to?(attribute) }
+    end
+
     # ActiveModel compatibility
-    delegate :attributes, :to_param, :to_partial_path
+    delegate :to_param, :to_partial_path
 
     # ActiveModel compatibility
     singleton_class.delegate :model_name, to: :source_class
 
     # @return [Class] the class created by {decorate_collection}.
     def self.collection_decorator_class
-      collection_decorator_name.constantize
-    rescue NameError
+      name = collection_decorator_name
+      name.constantize
+    rescue NameError => error
+      raise if name && !error.missing_name?(name)
       Draper::CollectionDecorator
     end
 
@@ -208,8 +219,10 @@ module Draper
     end
 
     def self.inferred_source_class
-      source_name.constantize
-    rescue NameError
+      name = source_name
+      name.constantize
+    rescue NameError => error
+      raise if name && !error.missing_name?(name)
       raise Draper::UninferrableSourceError.new(self)
     end
 

data/lib/draper/factory.rb

@@ -0,0 +1,87 @@
+module Draper
+  class Factory
+    # Creates a decorator factory.
+    #
+    # @option options [Decorator, CollectionDecorator] :with (nil)
+    #   decorator class to use. If nil, it is inferred from the object
+    #   passed to {#decorate}.
+    # @option options [Hash, #call] context
+    #   extra data to be stored in created decorators. If a proc is given, it
+    #   will be called each time {#decorate} is called and its return value
+    #   will be used as the context.
+    def initialize(options = {})
+      options.assert_valid_keys(:with, :context)
+      @decorator_class = options.delete(:with)
+      @default_options = options
+    end
+
+    # Decorates an object, inferring whether to create a singular or collection
+    # decorator from the type of object passed.
+    #
+    # @param [Object] source
+    #   object to decorate.
+    # @option options [Hash] context
+    #   extra data to be stored in the decorator. Overrides any context passed
+    #   to the constructor.
+    # @option options [Object, Array] context_args (nil)
+    #   argument(s) to be passed to the context proc.
+    # @return [Decorator, CollectionDecorator] the decorated object.
+    def decorate(source, options = {})
+      return nil if source.nil?
+      Worker.new(decorator_class, source).call(options.reverse_merge(default_options))
+    end
+
+    private
+
+    attr_reader :decorator_class, :default_options
+
+    # @private
+    class Worker
+      def initialize(decorator_class, source)
+        @decorator_class = decorator_class
+        @source = source
+      end
+
+      def call(options)
+        update_context options
+        decorator.call(source, options)
+      end
+
+      def decorator
+        return decorator_method(decorator_class) if decorator_class
+        return source_decorator if decoratable?
+        return decorator_method(Draper::CollectionDecorator) if collection?
+        raise Draper::UninferrableDecoratorError.new(source.class)
+      end
+
+      private
+
+      attr_reader :decorator_class, :source
+
+      def source_decorator
+        ->(source, options) { source.decorate(options) }
+      end
+
+      def decorator_method(klass)
+        if collection? && klass.respond_to?(:decorate_collection)
+          klass.method(:decorate_collection)
+        else
+          klass.method(:decorate)
+        end
+      end
+
+      def collection?
+        source.respond_to?(:first)
+      end
+
+      def decoratable?
+        source.respond_to?(:decorate)
+      end
+
+      def update_context(options)
+        args = options.delete(:context_args)
+        options[:context] = options[:context].call(*Array.wrap(args)) if options[:context].respond_to?(:call)
+      end
+    end
+  end
+end

data/lib/draper/helper_proxy.rb

@@ -16,6 +16,8 @@ module Draper
       send(method, *args, &block)
     end
 
+    delegate :capture, to: :view_context
+
     protected
 
     attr_reader :view_context

data/lib/draper/railtie.rb

@@ -17,7 +17,7 @@ module Draper
     config.after_initialize do |app|
       app.config.paths.add 'app/decorators', eager_load: true
 
-      unless Rails.env.production?
+      if Rails.env.test?
         require 'draper/test_case'
         require 'draper/test/rspec_integration' if defined?(RSpec) and RSpec.respond_to?(:configure)
         require 'draper/test/minitest_integration' if defined?(MiniTest::Rails)
@@ -44,10 +44,16 @@ module Draper
       end
     end
 
+    initializer "draper.setup_active_model_serializers" do |app|
+      ActiveSupport.on_load :active_model_serializers do
+        Draper::CollectionDecorator.send :include, ActiveModel::ArraySerializerSupport
+      end
+    end
+
     console do
       require 'action_controller/test_case'
       ApplicationController.new.view_context
-      Draper::ViewContext.build_view_context
+      Draper::ViewContext.build
     end
 
     rake_tasks do