draper 1.0.0.beta6 → 1.0.0

data/.travis.yml

@@ -4,6 +4,12 @@ rvm:
   - rbx-19mode
   - jruby-19mode
   - ruby-head
+env:
+  - "RAILS_VERSION=3.2"
+  - "RAILS_VERSION=3.1"
+  - "RAILS_VERSION=3.0"
+  - "RAILS_VERSION=master"
 matrix:
   allow_failures:
     - rvm: ruby-head
+    - env: "RAILS_VERSION=master"

data/.yardopts

@@ -1 +1 @@
-yardoc 'lib/draper/**/*.rb' -m markdown
+yardoc 'lib/draper/**/*.rb' -m markdown --no-private

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Draper Changelog
 
+## 1.0.0
+
+* Infer collection decorators. [https://github.com/drapergem/draper/commit/e8253df7dc6c90a542444c0f4ef289909fce4f90](https://github.com/drapergem/draper/commit/e8253df7dc6c90a542444c0f4ef289909fce4f90)
+
+* Prevent calls to `scoped` on decorated associations. [https://github.com/drapergem/draper/commit/5dcc6c31ecf408753158d15fed9fb23fbfdc3734](https://github.com/drapergem/draper/commit/5dcc6c31ecf408753158d15fed9fb23fbfdc3734)
+
+* Add `helper` method to tests. [https://github.com/drapergem/draper/commit/551961e72ee92355bc9c848bedfcc573856d12b0](https://github.com/drapergem/draper/commit/551961e72ee92355bc9c848bedfcc573856d12b0)
+
+* Inherit method security. [https://github.com/drapergem/draper/commit/1865ed3e3b2b34853689a60b59b8ce9145674d1d](https://github.com/drapergem/draper/commit/1865ed3e3b2b34853689a60b59b8ce9145674d1d)
+
+* Test against all versions of Rails 3. [https://github.com/drapergem/draper/commit/1865ed3e3b2b34853689a60b59b8ce9145674d1d](https://github.com/drapergem/draper/commit/1865ed3e3b2b34853689a60b59b8ce9145674d1d)
+
+* Pretend to be `instance_of?(source.class)` [https://github.com/drapergem/draper/commit/30d209f990847e84b221ac798e84b976f5775cc0](https://github.com/drapergem/draper/commit/30d209f990847e84b221ac798e84b976f5775cc0)
+
+* Remove security from `Decorator`. Do manual delegation with `:delegate`. [https://github.com/drapergem/draper/commit/c6f8aaa2b2bd4679738050aede2503aa8e9db130](https://github.com/drapergem/draper/commit/c6f8aaa2b2bd4679738050aede2503aa8e9db130)
+
+* Add generators for MiniTest. [https://github.com/drapergem/draper/commit/1fac02b65b15e32f06e8292cb858c97cb1c1da2c](https://github.com/drapergem/draper/commit/1fac02b65b15e32f06e8292cb858c97cb1c1da2c)
+
+* Test against edge rails. [https://github.com/drapergem/draper/commit/e9b71e3cf55a800b48c083ff257a7c1cbe1b601b](https://github.com/drapergem/draper/commit/e9b71e3cf55a800b48c083ff257a7c1cbe1b601b)
+
 ## 1.0.0.beta6
 
 * Fix up README to include changes made. [https://github.com/drapergem/draper/commit/5e6e4d11b1e0c07c12b6b1e87053bc3f50ef2ab6](https://github.com/drapergem/draper/commit/5e6e4d11b1e0c07c12b6b1e87053bc3f50ef2ab6)

data/Gemfile

@@ -10,3 +10,14 @@ platforms :jruby do
   gem "minitest", ">= 3.0"
   gem "activerecord-jdbcsqlite3-adapter", "~> 1.2.2.1"
 end
+
+case ENV["RAILS_VERSION"]
+when "master"
+  gem "rails", github: "rails/rails"
+when "3.2", nil
+  gem "rails", "~> 3.2.0"
+when "3.1"
+  gem "rails", "~> 3.1.0"
+when "3.0"
+  gem "rails", "~> 3.0.0"
+end

data/README.md

@@ -35,6 +35,8 @@ could be better written as:
 ```ruby
 # app/decorators/article_decorator.rb
 class ArticleDecorator < Draper::Decorator
+  delegate_all
+
   def publication_status
     if published?
       "Published at #{published_at}"
@@ -49,7 +51,7 @@ class ArticleDecorator < Draper::Decorator
 end
 ```
 
-Notice that the `published?` method can be called even though `ArticleDecorator` doesn't define it - the decorator delegates methods to the source model. However, we can override methods like `published_at` to add presentation-specific formatting, in which case we access the underlying model using the `source` method.
+Notice that the `published?` method can be called even though `ArticleDecorator` doesn't define it - thanks to `delegate_all`, the decorator delegates missing methods to the source model. However, we can override methods like `published_at` to add presentation-specific formatting, in which case we access the underlying model using the `source` method.
 
 You might have heard this sort of decorator called a "presenter", an "exhibit", a "view model", or even just a "view" (in that nomenclature, what Rails calls "views" are actually "templates"). Whatever you call it, it's a great way to replace procedural helpers like the one above with "real" object-oriented programming.
 
@@ -64,7 +66,7 @@ Decorators are the ideal place to:
 Add Draper to your Gemfile:
 
 ```ruby
-gem 'draper', '~> 1.0'
+gem 'draper', '~> 1.0.0.beta6'
 ```
 
 And run `bundle install` within your app's directory.
@@ -105,6 +107,8 @@ Decorators will delegate methods to the model where possible, which means in mos
 
 ```ruby
 class ArticleDecorator < Draper::Decorator
+  delegate_all
+
   def published_at
     source.published_at.strftime("%A, %B %e")
   end
@@ -158,14 +162,16 @@ end
 
 Draper guesses the decorator used for each item from the name of the collection decorator (`ArticlesDecorator` becomes `ArticleDecorator`). If that fails, it falls back to using each item's `decorate` method. Alternatively, you can specify a decorator by overriding the collection decorator's `decorator_class` method.
 
-Some pagination gems add methods to `ActiveRecord::Relation`. For example, [Kaminari](https://github.com/amatsuda/kaminari)'s `paginate` helper method requires the collection to implement `current_page`, `total_pages`, and `limit_value`. To expose these on a collection decorator, you can simply delegate to `source`:
+Some pagination gems add methods to `ActiveRecord::Relation`. For example, [Kaminari](https://github.com/amatsuda/kaminari)'s `paginate` helper method requires the collection to implement `current_page`, `total_pages`, and `limit_value`. To expose these on a collection decorator, you can simply delegate to the `source`:
 
 ```ruby
 class PaginatingDecorator < Draper::CollectionDecorator
-  delegate :current_page, :total_pages, :limit_value, to: :source
+  delegate :current_page, :total_pages, :limit_value
 end
 ```
 
+The `delegate` method used here is the same as that added by [Active Support](http://api.rubyonrails.org/classes/Module.html#method-i-delegate), except that the `:to` option is not required; it defaults to `:source` when omitted.
+
 ### Handy shortcuts
 
 You can automatically decorate associated models:
@@ -193,7 +199,7 @@ so that you can do:
 
 ## Testing
 
-Draper supports RSpec and Minitest::Rails out of the box, and should work with Test::Unit as well.
+Draper supports RSpec, MiniTest::Rails, and Test::Unit, and will add the appropriate tests when you generate a decorator.
 
 ### RSpec
 
@@ -229,25 +235,16 @@ and inherit from it instead of directly from `Draper::Decorator`.
 
 ### Enforcing an interface between controllers and views
 
-If you want to strictly control which methods are called in your views, you can restrict the methods that the decorator delegates to the model. Use `denies` to blacklist methods:
+The `delegate_all` call at the top of your decorator means that all missing methods will delegated to the source. If you want to strictly control which methods are called in your views, you can choose to only delegate certain methods.
 
 ```ruby
 class ArticleDecorator < Draper::Decorator
-  # allow everything except `title` and `author` to be delegated
-  denies :title, :author
+  delegate :title, :author
 end
 ```
 
-or, better, use `allows` for a whitelist:
-
-```ruby
-class ArticleDecorator < Draper::Decorator
-  # only allow `title` and `author` to be delegated to the model
-  allows :title, :author
-end
-```
+As mentioned above for `CollectionDecorator`, the `delegate` method defaults to using `:source` if the `:to` option is omitted.
 
-You can prevent method delegation altogether using `denies_all`.
 
 ### Adding context
 

data/Rakefile

@@ -16,7 +16,7 @@ desc "Run all specs"
 task "spec" => "spec:all"
 
 namespace "spec" do
-  task "all" => ["draper", "generators", "minitest-rails", "integration"]
+  task "all" => ["draper", "generators", "integration"]
 
   def spec_task(name)
     desc "Run #{name} specs"
@@ -27,7 +27,6 @@ namespace "spec" do
 
   spec_task "draper"
   spec_task "generators"
-  spec_task "minitest-rails"
 
   desc "Run integration specs"
   task "integration" => ["db:setup", "integration:all"]
@@ -51,6 +50,8 @@ namespace "spec" do
     end
 
     task "test" do
+      puts "Running rake in dummy app"
+      ENV["RAILS_ENV"] = "test"
       run_in_dummy_app "rake"
     end
   end
@@ -60,7 +61,8 @@ namespace "db" do
   desc "Set up databases for integration testing"
   task "setup" do
     run_in_dummy_app "rm -f db/*.sqlite3"
-    run_in_dummy_app "RAILS_ENV=development rake db:schema:load db:seed db:test:prepare"
+    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

@@ -21,10 +21,10 @@ Gem::Specification.new do |s|
   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 'rake', '>= 0.9.2'
   s.add_development_dependency 'rspec', '~> 2.12'
   s.add_development_dependency 'rspec-mocks', '>= 2.12.1'
-  s.add_development_dependency 'yard'
+  s.add_development_dependency 'rspec-rails', '~> 2.12'
   s.add_development_dependency 'minitest-rails', '~> 0.2'
   s.add_development_dependency 'capybara'
 end

data/lib/draper.rb

@@ -2,13 +2,14 @@ require 'action_view'
 
 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/decorated_association'
-require 'draper/security'
 require 'draper/helper_support'
 require 'draper/view_context'
 require 'draper/collection_decorator'

data/lib/draper/automatic_delegation.rb

@@ -0,0 +1,50 @@
+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?(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?(method, include_private = false)
+        super || delegatable?(method)
+      end
+
+      # @private
+      def delegatable?(method)
+        source_class? && source_class.respond_to?(method)
+      end
+    end
+
+    included do
+      private :delegatable?
+      private_class_method :delegatable?
+    end
+
+  end
+end

data/lib/draper/collection_decorator.rb

@@ -1,16 +1,26 @@
 module Draper
   class CollectionDecorator
     include Enumerable
-    include ViewHelpers
+    include Draper::ViewHelpers
+    extend Draper::Delegation
 
+    # @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 source collection to decorate
-    # @option options [Class] :with the class used to decorate items
-    # @option options [Hash] :context context available to each item's decorator
+    # @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
@@ -22,10 +32,14 @@ module Draper
       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)
@@ -41,7 +55,7 @@ module Draper
         "inferred decorators"
       end
 
-      "#<CollectionDecorator of #{klass} for #{source.inspect}>"
+      "#<#{self.class.name} of #{klass} for #{source.inspect}>"
     end
 
     def context=(value)
@@ -49,18 +63,25 @@ 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
     end
 
     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 self.inferred_decorator_class
       decorator_name = "#{name.chomp("Decorator").singularize}Decorator"
       decorator_uninferrable if decorator_name == name
@@ -75,8 +96,6 @@ module Draper
       raise Draper::UninferrableDecoratorError.new(self)
     end
 
-    private
-
     def item_decorator
       @item_decorator ||= begin
         decorator_class.method(:decorate)

data/lib/draper/decoratable.rb

@@ -1,44 +1,83 @@
-module Draper::Decoratable
-  extend ActiveSupport::Concern
+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
 
-  def decorate(options = {})
-    decorator_class.decorate(self, options)
-  end
-
-  def decorator_class
-    self.class.decorator_class
-  end
-
-  def applied_decorators
-    []
-  end
+    # Decorates the object using the inferred {#decorator_class}.
+    # @param [Hash] options
+    #   see {Decorator#initialize}
+    def decorate(options = {})
+      decorator_class.decorate(self, options)
+    end
 
-  def decorated_with?(decorator_class)
-    false
-  end
+    # (see ClassMethods#decorator_class)
+    def decorator_class
+      self.class.decorator_class
+    end
 
-  def decorated?
-    false
-  end
+    # The list of decorators that have been applied to the object.
+    #
+    # @return [Array<Class>] `[]`
+    def applied_decorators
+      []
+    end
 
-  def ==(other)
-    super || (other.respond_to?(:source) && self == other.source)
-  end
+    # (see Decorator#decorated_with?)
+    # @return [false]
+    def decorated_with?(decorator_class)
+      false
+    end
 
-  module ClassMethods
-    def decorate(options = {})
-      decorator_class.decorate_collection(self.scoped, options)
+    # Checks if this object is decorated.
+    #
+    # @return [false]
+    def decorated?
+      false
     end
 
-    def decorator_class
-      prefix = respond_to?(:model_name) ? model_name : name
-      "#{prefix}Decorator".constantize
-    rescue NameError
-      raise Draper::UninferrableDecoratorError.new(self)
+    # Compares with possibly-decorated objects.
+    #
+    # @return [Boolean]
+    def ==(other)
+      super || (other.respond_to?(:source) && self == other.source)
     end
 
-    def ===(other)
-      super || (other.respond_to?(:source) && super(other.source))
+    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 = {})
+        decorator_class.decorate_collection(self.scoped, options)
+      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
+        "#{prefix}Decorator".constantize
+      rescue NameError
+        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