jamesgolick-draper 1.1.1a

data/Rakefile

@@ -0,0 +1,69 @@
+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" => ["draper", "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 "draper"
+  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("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 "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 rake db:schema:load db:seed"
+    run_in_dummy_app "RAILS_ENV=production rake db:schema:load db:seed"
+    run_in_dummy_app "RAILS_ENV=test rake db:schema:load"
+  end
+end

data/draper.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "draper/version"
+
+Gem::Specification.new do |s|
+  s.name        = "jamesgolick-draper"
+  s.version     = Draper::VERSION
+  s.authors     = ["Jeff Casimir", "Steve Klabnik"]
+  s.email       = ["jeff@casimircreative.com", "steve@steveklabnik.com"]
+  s.homepage    = "http://github.com/drapergem/draper"
+  s.summary     = "View Models for Rails"
+  s.description = "Draper 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', '>= 3.0'
+  s.add_dependency 'actionpack', '>= 3.0'
+  s.add_dependency 'request_store', '~> 1.0.3'
+
+  s.add_development_dependency 'ammeter'
+  s.add_development_dependency 'rake', '>= 0.9.2'
+  s.add_development_dependency 'rspec', '~> 2.12'
+  s.add_development_dependency 'rspec-mocks', '>= 2.12.1'
+  s.add_development_dependency 'rspec-rails', '~> 2.12'
+  s.add_development_dependency 'minitest-rails', '~> 0.2'
+  s.add_development_dependency 'capybara'
+  s.add_development_dependency 'active_model_serializers'
+end

data/lib/draper.rb

@@ -0,0 +1,64 @@
+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 'draper/version'
+require 'draper/view_helpers'
+require 'draper/delegation'
+require 'draper/automatic_delegation'
+require 'draper/finders'
+require 'draper/decorator'
+require 'draper/helper_proxy'
+require 'draper/lazy_helpers'
+require 'draper/decoratable'
+require 'draper/factory'
+require 'draper/decorated_association'
+require 'draper/helper_support'
+require 'draper/view_context'
+require 'draper/collection_decorator'
+require 'draper/decorates_assigned'
+require 'draper/railtie' if defined?(Rails)
+
+module Draper
+  def self.setup_action_controller(base)
+    base.class_eval do
+      include Draper::ViewContext
+      extend  Draper::HelperSupport
+      extend  Draper::DecoratesAssigned
+
+      before_filter do |controller|
+        Draper::ViewContext.clear!
+        Draper::ViewContext.controller = controller
+      end
+    end
+  end
+
+  def self.setup_action_mailer(base)
+    base.class_eval do
+      include Draper::ViewContext
+    end
+  end
+
+  def self.setup_orm(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
+
+  class UninferrableSourceError < NameError
+    def initialize(klass)
+      super("Could not infer a source for #{klass}.")
+    end
+  end
+end

data/lib/draper/automatic_delegation.rb

@@ -0,0 +1,56 @@
+module Draper
+  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)
+      source.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)
+
+        source_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)
+        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
+      private :delegatable?
+      private_class_method :delegatable?
+    end
+
+  end
+end

data/lib/draper/collection_decorator.rb

@@ -0,0 +1,96 @@
+module Draper
+  class CollectionDecorator
+    include Enumerable
+    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
+
+    array_methods = Array.instance_methods - Object.instance_methods
+    delegate :==, :as_json, *array_methods, to: :decorated_collection
+
+    # @param [Enumerable] source
+    #   collection to decorate.
+    # @option options [Class, nil] :with (nil)
+    #   the decorator class used to decorate each item. When `nil`, it is
+    #   inferred from the collection decorator class if possible (e.g.
+    #   `ProductsDecorator` maps to `ProductDecorator`), otherwise 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(source, options = {})
+      options.assert_valid_keys(:with, :context)
+      @source = source
+      @decorator_class = options[:with]
+      @context = options.fetch(:context, {})
+    end
+
+    class << self
+      alias_method :decorate, :new
+    end
+
+    # @return [Array] the decorated items.
+    def decorated_collection
+      @decorated_collection ||= source.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
+        decorator_class.find(*args)
+      end
+    end
+
+    def to_s
+      "#<#{self.class.name} of #{decorator_class || "inferred decorators"} for #{source.inspect}>"
+    end
+
+    def context=(value)
+      @context = value
+      each {|item| item.context = value } if @decorated_collection
+    end
+
+    # @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
+
+    # @return the collection being decorated.
+    attr_reader :source
+
+    # 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/draper/decoratable.rb

@@ -0,0 +1,82 @@
+require 'draper/decoratable/equality'
+
+module Draper
+  # 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 Draper::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
+
+    # 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
+
+      # 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
+        raise unless error.missing_name?(decorator_name)
+        raise Draper::UninferrableDecoratorError.new(self)
+      end
+
+      # Compares with possibly-decorated objects.
+      #
+      # @return [Boolean]
+      def ===(other)
+        super || (other.respond_to?(:source) && super(other.source))
+      end
+
+    end
+
+  end
+end

data/lib/draper/decoratable/equality.rb

@@ -0,0 +1,18 @@
+module Draper
+  module Decoratable
+    module Equality
+      # Compares self with a possibly-decorated object.
+      #
+      # @return [Boolean]
+      def ==(other)
+        super ||
+          other.respond_to?(:decorated?) && other.decorated? &&
+          other.respond_to?(:source) && self == other.source
+      end
+
+      def self.test(first, other)
+        first == other
+      end
+    end
+  end
+end

data/lib/draper/decorated_association.rb

@@ -0,0 +1,35 @@
+module Draper
+  # @private
+  class DecoratedAssociation
+
+    def initialize(owner, association, options)
+      options.assert_valid_keys(:with, :scope, :context)
+
+      @owner = owner
+      @association = association
+
+      @scope = options[:scope]
+
+      decorator_class = options[:with]
+      context = options.fetch(:context, ->(context){ context })
+      @factory = Draper::Factory.new(with: decorator_class, context: context)
+    end
+
+    def call
+      decorate unless defined?(@decorated)
+      @decorated
+    end
+
+    private
+
+    attr_reader :factory, :owner, :association, :scope
+
+    def decorate
+      associated = owner.source.send(association)
+      associated = associated.send(scope) if scope
+
+      @decorated = factory.decorate(associated, context_args: owner.context)
+    end
+
+  end
+end