draper 0.17.0 → 1.0.0.beta2

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,260 @@
+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
+
+    # Specify the class that this class decorates.
+    #
+    # @param [String, Symbol, Class] Class or name of class to decorate.
+    def self.decorates(klass)
+      @source_class = klass.to_s.classify.constantize
+    end
+
+    # @return [Class] The source class corresponding to this
+    #   decorator class
+    def self.source_class
+      @source_class ||= inferred_source_class
+    end
+
+    # Checks whether this decorator class has a corresponding
+    # source class
+    def self.source_class?
+      source_class
+    rescue Draper::UninferrableSourceError
+      false
+    end
+
+    # Automatically decorates ActiveRecord finder methods, so that
+    # you can use `ProductDecorator.find(id)` instead of
+    # `ProductDecorator.decorate(Product.find(id))`.
+    #
+    # The model class to be found is defined by `decorates` or
+    # inferred from the decorator class name.
+    #
+    def self.decorates_finders
+      extend Draper::Finders
+    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?
+
+    # 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
+
+    # For ActiveModel compatibilty
+    def to_model
+      self
+    end
+
+    # For ActiveModel compatibility
+    def to_param
+      source.to_param
+    end
+
+    def method_missing(method, *args, &block)
+      if delegatable_method?(method)
+        self.class.define_proxy(method)
+        send(method, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to?(method, include_private = false)
+      super || delegatable_method?(method)
+    end
+
+    def self.method_missing(method, *args, &block)
+      if delegatable_method?(method)
+        source_class.send(method, *args, &block)
+      else
+        super
+      end
+    end
+
+    def self.respond_to?(method, include_private = false)
+      super || delegatable_method?(method)
+    end
+
+    private
+
+    def delegatable_method?(method)
+      allow?(method) && source.respond_to?(method)
+    end
+
+    def self.delegatable_method?(method)
+      source_class? && source_class.respond_to?(method)
+    end
+
+    def self.inferred_source_class
+      uninferrable_source if name.nil? || name.demodulize !~ /.+Decorator$/
+
+      begin
+        name.chomp("Decorator").constantize
+      rescue NameError
+        uninferrable_source
+      end
+    end
+
+    def self.uninferrable_source
+      raise Draper::UninferrableSourceError.new(self)
+    end
+
+    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,34 @@
+module Draper
+  module Finders
+
+    def find(id, options = {})
+      decorate(source_class.find(id), options)
+    end
+
+    def all(options = {})
+      decorate_collection(source_class.all, options)
+    end
+
+    def first(options = {})
+      decorate(source_class.first, options)
+    end
+
+    def last(options = {})
+      decorate(source_class.last, options)
+    end
+
+    def method_missing(method, *args, &block)
+      result = super
+      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
+  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.beta2"
 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