drape 1.0.0.beta1

data/Rakefile

@@ -0,0 +1,76 @@
+require 'rake'
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+def run_in_dummy_app(command)
+  success = system("cd spec/dummy && #{command}")
+  raise "#{command} failed" unless success
+end
+
+task 'default' => 'ci'
+
+desc 'Run all tests for CI'
+task 'ci' => 'spec'
+
+desc 'Run all specs'
+task 'spec' => 'spec:all'
+
+namespace 'spec' do
+  task 'all' => ['drape', 'generators', 'integration']
+
+  def spec_task(name)
+    desc "Run #{name} specs"
+    RSpec::Core::RakeTask.new(name) do |t|
+      t.pattern = "spec/#{name}/**/*_spec.rb"
+    end
+  end
+
+  spec_task 'drape'
+  spec_task 'generators'
+
+  desc 'Run integration specs'
+  task 'integration' => ['db:setup', 'integration:all']
+
+  namespace 'integration' do
+    task 'all' => ['development', 'production', 'test']
+
+    ['development', 'production'].each do |environment|
+      task environment do
+        Rake::Task['spec:integration:run'].execute environment
+      end
+    end
+
+    task 'run' do |_t, environment|
+      puts "Running integration specs in #{environment}"
+
+      ENV['RAILS_ENV'] = environment
+      success = system('bundle exec rspec spec/integration')
+
+      raise "Integration specs failed in #{environment}" unless success
+    end
+
+    task 'test' do
+      puts 'Running rake in dummy app'
+      ENV['RAILS_ENV'] = 'test'
+      run_in_dummy_app 'bundle exec rake'
+    end
+  end
+end
+
+namespace 'db' do
+  desc 'Set up databases for integration testing'
+  task 'setup' do
+    puts 'Setting up databases'
+
+    run_in_dummy_app 'rm -f db/*.sqlite3'
+
+    run_in_dummy_app 'RAILS_ENV=development rails db:environment:set'
+    run_in_dummy_app 'RAILS_ENV=development rails db:schema:load db:seed'
+
+    run_in_dummy_app 'RAILS_ENV=production rails db:environment:set'
+    run_in_dummy_app 'RAILS_ENV=production rails db:schema:load db:seed'
+
+    run_in_dummy_app 'RAILS_ENV=test rails db:environment:set'
+    run_in_dummy_app 'RAILS_ENV=test rails db:schema:load db:seed'
+  end
+end

data/drape.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+$LOAD_PATH.push File.expand_path('../lib', __FILE__)
+require 'drape/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'drape'
+  s.version     = Drape::VERSION
+  s.authors     = ['Andrew Emelianenko', 'Jeff Casimir', 'Steve Klabnik']
+  s.email       = ['andrew@soften-it.com', 'jeff@casimircreative.com', 'steve@steveklabnik.com']
+  s.homepage    = 'http://github.com/MrEmelianenko/drape'
+  s.summary     = 'View Models for Rails'
+  s.description = 'Drape adds an object-oriented layer of presentation logic to your Rails apps.'
+  s.license     = 'MIT'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  s.add_dependency 'activesupport', '>= 5.0.0.beta1'
+  s.add_dependency 'actionpack', '>= 5.0.0.beta1'
+  s.add_dependency 'request_store', '~> 1.0'
+  s.add_dependency 'activemodel', '>= 5.0.0.beta1'
+  s.add_dependency 'activemodel-serializers-xml', '>= 1.0'
+
+  s.add_development_dependency 'rake', '>= 0.9.2'
+  s.add_development_dependency 'rspec-rails', '>= 3.5.0.beta1'
+  s.add_development_dependency 'minitest-rails', '>= 2.2.0'
+  s.add_development_dependency 'capybara'
+  s.add_development_dependency 'active_model_serializers'
+end

data/gemfiles/5.0.gemfile

@@ -0,0 +1,8 @@
+gem "rails", ">= 5.0.rc1"
+gem "mongoid", github: "mongodb/mongoid"
+gem "devise", github: "plataformatec/devise"
+gem "minitest-rails", github: "blowmage/minitest-rails", branch: "rails5"
+
+group :development, :test do
+  gem 'listen'
+end

data/lib/drape.rb

@@ -0,0 +1,63 @@
+require 'action_view'
+require 'active_model/naming'
+require 'active_model/serialization'
+require 'active_model/serializers/json'
+require 'active_model/serializers/xml'
+require 'active_support/inflector'
+require 'active_support/core_ext/hash/keys'
+require 'active_support/core_ext/hash/reverse_merge'
+require 'active_support/core_ext/name_error'
+
+require 'drape/version'
+require 'drape/view_helpers'
+require 'drape/delegation'
+require 'drape/automatic_delegation'
+require 'drape/finders'
+require 'drape/decorator'
+require 'drape/helper_proxy'
+require 'drape/lazy_helpers'
+require 'drape/decoratable'
+require 'drape/factory'
+require 'drape/decorated_association'
+require 'drape/helper_support'
+require 'drape/view_context'
+require 'drape/collection_decorator'
+require 'drape/undecorate'
+require 'drape/decorates_assigned'
+require 'drape/railtie' if defined?(Rails)
+
+module Drape
+  def self.setup_action_controller(base)
+    base.class_eval do
+      include Drape::ViewContext
+      extend Drape::HelperSupport
+      extend Drape::DecoratesAssigned
+
+      before_action :activate_drape
+    end
+  end
+
+  def self.setup_action_mailer(base)
+    base.class_eval do
+      include Drape::ViewContext
+    end
+  end
+
+  def self.setup_orm(base)
+    base.class_eval do
+      include Drape::Decoratable
+    end
+  end
+
+  class UninferrableDecoratorError < NameError
+    def initialize(klass)
+      super("Could not infer a decorator for #{klass}.")
+    end
+  end
+
+  class UninferrableSourceError < NameError
+    def initialize(klass)
+      super("Could not infer a source for #{klass}.")
+    end
+  end
+end

data/lib/drape/automatic_delegation.rb

@@ -0,0 +1,55 @@
+module Drape
+  module AutomaticDelegation
+    extend ActiveSupport::Concern
+
+    # Delegates missing instance methods to the source object.
+    def method_missing(method, *args, &block)
+      return super unless delegatable?(method)
+
+      self.class.delegate method
+      send(method, *args, &block)
+    end
+
+    # Checks if the decorator responds to an instance method, or is able to
+    # proxy it to the source object.
+    def respond_to_missing?(method, include_private = false)
+      super || delegatable?(method)
+    end
+
+    # @private
+    def delegatable?(method)
+      object.respond_to?(method)
+    end
+
+    module ClassMethods
+      # Proxies missing class methods to the source class.
+      def method_missing(method, *args, &block)
+        return super unless delegatable?(method)
+
+        object_class.send(method, *args, &block)
+      end
+
+      # Checks if the decorator responds to a class method, or is able to proxy
+      # it to the source class.
+      def respond_to_missing?(method, include_private = false)
+        super || delegatable?(method)
+      end
+
+      # @private
+      def delegatable?(method)
+        object_class? && object_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
+      private :delegatable?
+      private_class_method :delegatable?
+    end
+  end
+end

data/lib/drape/collection_decorator.rb

@@ -0,0 +1,102 @@
+module Drape
+  class CollectionDecorator
+    include Enumerable
+    include Drape::ViewHelpers
+    extend Drape::Delegation
+
+    # @return the collection being decorated.
+    attr_reader :object
+
+    # @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
+
+    array_methods = Array.instance_methods - Object.instance_methods
+    delegate :==, :as_json, *array_methods, to: :decorated_collection
+
+    # @param [Enumerable] object
+    #   collection to decorate.
+    # @option options [Class, nil] :with (nil)
+    #   the decorator class used to decorate each item. When `nil`, each item's
+    #   {Decoratable#decorate decorate} method will be used.
+    # @option options [Hash] :context ({})
+    #   extra data to be stored in the collection decorator and used in
+    #   user-defined methods, and passed to each item's decorator.
+    def initialize(object, options = {})
+      options.assert_valid_keys(:with, :context)
+      @object = object
+      @decorator_class = options[:with]
+      @context = options.fetch(:context, {})
+    end
+
+    class << self
+      alias decorate new
+    end
+
+    # @return [Array] the decorated items.
+    def decorated_collection
+      @decorated_collection ||= object.map { |item| decorate_item(item) }
+    end
+
+    # Delegated to the decorated collection when using the block form
+    # (`Enumerable#find`) or to the decorator class if not
+    # (`ActiveRecord::FinderMethods#find`)
+    def find(*args, &block)
+      if block_given?
+        decorated_collection.find(*args, &block)
+      else
+        ActiveSupport::Deprecation.warn('Using ActiveRecord\'s `find` on a CollectionDecorator is deprecated. ' +
+                                        'Call `find` on a model, and then decorate the result', caller)
+
+        decorate_item(object.find(*args))
+      end
+    end
+
+    def to_s
+      "#<#{self.class.name} of #{decorator_class || 'inferred decorators'} for #{object.inspect}>"
+    end
+
+    def context=(value)
+      @context = value
+      each { |item| item.context = value } if @decorated_collection
+    end
+
+    # @return [true]
+    def decorated?
+      true
+    end
+
+    alias decorated_with? instance_of?
+
+    def kind_of?(klass)
+      decorated_collection.is_a?(klass) || super
+    end
+    alias is_a? kind_of?
+
+    def replace(other)
+      decorated_collection.replace(other)
+      self
+    end
+
+    protected
+
+    # Decorates the given item.
+    def decorate_item(item)
+      item_decorator.call(item, context: context)
+    end
+
+    private
+
+    def item_decorator
+      if decorator_class
+        decorator_class.method(:decorate)
+      else
+        ->(item, options) { item.decorate(options) }
+      end
+    end
+  end
+end

data/lib/drape/decoratable.rb

@@ -0,0 +1,93 @@
+require 'drape/decoratable/equality'
+
+module Drape
+  # Provides shortcuts to decorate objects directly, so you can do
+  # `@product.decorate` instead of `ProductDecorator.new(@product)`.
+  #
+  # This module is included by default into `ActiveRecord::Base` and
+  # `Mongoid::Document`, but you're using another ORM, or want to decorate
+  # plain old Ruby objects, you can include it manually.
+  module Decoratable
+    extend ActiveSupport::Concern
+    include Drape::Decoratable::Equality
+
+    # Decorates the object using the inferred {#decorator_class}.
+    # @param [Hash] options
+    #   see {Decorator#initialize}
+    def decorate(options = {})
+      decorator_class.decorate(self, options)
+    end
+
+    # (see ClassMethods#decorator_class)
+    def decorator_class
+      self.class.decorator_class
+    end
+
+    def decorator_class?
+      self.class.decorator_class?
+    end
+
+    # The list of decorators that have been applied to the object.
+    #
+    # @return [Array<Class>] `[]`
+    def applied_decorators
+      []
+    end
+
+    # (see Decorator#decorated_with?)
+    # @return [false]
+    def decorated_with?(_decorator_class)
+      false
+    end
+
+    # Checks if this object is decorated.
+    #
+    # @return [false]
+    def decorated?
+      false
+    end
+
+    module ClassMethods
+      # Decorates a collection of objects. Used at the end of a scope chain.
+      #
+      # @example
+      #   Product.popular.decorate
+      # @param [Hash] options
+      #   see {Decorator.decorate_collection}.
+      def decorate(options = {})
+        collection = Rails::VERSION::MAJOR >= 4 ? all : scoped
+        decorator_class.decorate_collection(collection, options.reverse_merge(with: nil))
+      end
+
+      def decorator_class?
+        decorator_class
+      rescue Drape::UninferrableDecoratorError
+        false
+      end
+
+      # Infers the decorator class to be used by {Decoratable#decorate} (e.g.
+      # `Product` maps to `ProductDecorator`).
+      #
+      # @return [Class] the inferred decorator class.
+      def decorator_class
+        prefix = respond_to?(:model_name) ? model_name : name
+        decorator_name = "#{prefix}Decorator"
+        decorator_name.constantize
+      rescue NameError => error
+        if superclass.respond_to?(:decorator_class)
+          superclass.decorator_class
+        else
+          raise unless error.missing_name?(decorator_name)
+          raise Drape::UninferrableDecoratorError, self
+        end
+      end
+
+      # Compares with possibly-decorated objects.
+      #
+      # @return [Boolean]
+      def ===(other)
+        super || (other.respond_to?(:object) && super(other.object))
+      end
+    end
+  end
+end

data/lib/drape/decoratable/equality.rb

@@ -0,0 +1,26 @@
+module Drape
+  module Decoratable
+    module Equality
+      # Compares self with a possibly-decorated object.
+      #
+      # @return [Boolean]
+      def ==(other)
+        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?(:object) && test(object, other.object)
+      end
+    end
+  end
+end