draper 1.0.0.beta4 → 1.0.0.beta5

data/CHANGELOG.markdown

@@ -1,5 +1,13 @@
 # Draper Changelog
 
+## 1.0.0.beta5
+
+* Change CollectionDecorator to freeze its collection [https://github.com/drapergem/draper/commit/04d779615c43580409083a71661489e1bbf91ad4](https://github.com/drapergem/draper/commit/04d779615c43580409083a71661489e1bbf91ad4)
+
+* Bugfix on `CollectionDecorator#to_s` [https://github.com/drapergem/draper/commit/eefd7d09cac97d531b9235246378c3746d153f08](https://github.com/drapergem/draper/commit/eefd7d09cac97d531b9235246378c3746d153f08)
+
+* Upgrade `request_store` dependency to take advantage of a bugfix [https://github.com/drapergem/draper/commit/9f17212fd1fb656ef1314327d60fe45e0acf60a2](https://github.com/drapergem/draper/commit/9f17212fd1fb656ef1314327d60fe45e0acf60a2)
+
 ## 1.0.0.beta4
 
 * Fixed a race condition with capybara integration. [https://github.com/drapergem/draper/commit/e79464931e7b98c85ed5d78ed9ca38d51f43006e](https://github.com/drapergem/draper/commit/e79464931e7b98c85ed5d78ed9ca38d51f43006e)
@@ -44,7 +52,7 @@
   Rails app in both development and production mode to help ensure that we
   don't make changes that break Draper. [https://github.com/drapergem/draper/commit/90a4859085cab158658d23d77cd3108b6037e36f](https://github.com/drapergem/draper/commit/90a4859085cab158658d23d77cd3108b6037e36f)
 * Add `#decorated?` method. This gives us a free RSpec matcher,
-  `is_decorated?`. [https://github.com/drapergem/draper/commit/834a6fd1f24b5646c333a04a99fe9846a58965d6](https://github.com/drapergem/draper/commit/834a6fd1f24b5646c333a04a99fe9846a58965d6)
+  `be_decorated`. [https://github.com/drapergem/draper/commit/834a6fd1f24b5646c333a04a99fe9846a58965d6](https://github.com/drapergem/draper/commit/834a6fd1f24b5646c333a04a99fe9846a58965d6)
 * `#decorates` is no longer needed inside your models, and should be removed.
   Decorators automatically infer the class they decorate. [https://github.com/drapergem/draper/commit/e1214d97b62f2cab45227cc650029734160dcdfe](https://github.com/drapergem/draper/commit/e1214d97b62f2cab45227cc650029734160dcdfe)
 * Decorators do not automatically come with 'finders' by default. If you'd like

data/Gemfile

@@ -2,6 +2,11 @@ source :rubygems
 
 gemspec
 
-gem "sqlite3", :platforms => :ruby
+platforms :ruby do
+  gem "sqlite3"
+end
 
-gem "activerecord-jdbcsqlite3-adapter",   :platforms => :jruby
+platforms :jruby do
+  gem "minitest", ">= 3.0"
+  gem "activerecord-jdbcsqlite3-adapter", "~> 1.2.2.1"
+end

data/draper.gemspec

@@ -18,13 +18,13 @@ Gem::Specification.new do |s|
 
   s.add_dependency 'activesupport', '>= 3.0'
   s.add_dependency 'actionpack', '>= 3.0'
-  s.add_dependency 'request_store', '~> 1.0.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.10'
+  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 'minitest-rails', '~> 0.2'
-  s.add_development_dependency 'minitest', '~> 3.0' if RUBY_PLATFORM == "java"
   s.add_development_dependency 'capybara'
 end

data/lib/draper/collection_decorator.rb

@@ -3,20 +3,21 @@ module Draper
     include Enumerable
     include ViewHelpers
 
-    attr_accessor :source, :context, :decorator_class
+    attr_reader :source
     alias_method :to_source, :source
 
-    delegate :as_json, *(Array.instance_methods - Object.instance_methods), to: :decorated_collection
+    attr_accessor :context
+
+    array_methods = Array.instance_methods - Object.instance_methods
+    delegate :as_json, *array_methods, to: :decorated_collection
 
     # @param source collection to decorate
-    # @param [Hash] options (optional)
-    # @option options [Class, Symbol] :with the class used to decorate
-    #   items, or `:infer` to call each item's `decorate` method instead
+    # @option options [Class] :with the class used to decorate items
     # @option options [Hash] :context context available to each item's decorator
     def initialize(source, options = {})
       options.assert_valid_keys(:with, :context)
-      @source = source
-      @decorator_class = options.fetch(:with) { self.class.inferred_decorator_class }
+      @source = source.dup.freeze
+      @decorator_class = options[:with]
       @context = options.fetch(:context, {})
     end
 
@@ -25,7 +26,7 @@ module Draper
     end
 
     def decorated_collection
-      @decorated_collection ||= source.collect {|item| decorate_item(item) }
+      @decorated_collection ||= source.map{|item| decorate_item(item)}.freeze
     end
 
     def find(*args, &block)
@@ -36,25 +37,18 @@ module Draper
       end
     end
 
-    def method_missing(method, *args, &block)
-      source.send(method, *args, &block)
-    end
-
-    def respond_to?(method, include_private = false)
-      super || source.respond_to?(method, include_private)
-    end
-
-    def kind_of?(klass)
-      super || source.kind_of?(klass)
-    end
-    alias_method :is_a?, :kind_of?
-
     def ==(other)
       source == (other.respond_to?(:source) ? other.source : other)
     end
 
     def to_s
-      "#<CollectionDecorator of #{decorator_class} for #{source.inspect}>"
+      klass = begin
+        decorator_class
+      rescue Draper::UninferrableDecoratorError
+        "inferred decorators"
+      end
+
+      "#<CollectionDecorator of #{klass} for #{source.inspect}>"
     end
 
     def context=(value)
@@ -62,14 +56,14 @@ module Draper
       each {|item| item.context = value } if @decorated_collection
     end
 
+    def decorator_class
+      @decorator_class ||= self.class.inferred_decorator_class
+    end
+
     protected
 
     def decorate_item(item)
-      if decorator_class == :infer
-        item.decorate(context: context)
-      else
-        decorator_class.decorate(item, context: context)
-      end
+      item_decorator.call(item, context: context)
     end
 
     def self.inferred_decorator_class
@@ -85,5 +79,15 @@ module Draper
     def self.decorator_uninferrable
       raise Draper::UninferrableDecoratorError.new(self)
     end
+
+    private
+
+    def item_decorator
+      @item_decorator ||= begin
+        decorator_class.method(:decorate)
+      rescue Draper::UninferrableDecoratorError
+        ->(item, options) { item.decorate(options) }
+      end
+    end
   end
 end

data/lib/draper/decorated_association.rb

@@ -1,70 +1,70 @@
 module Draper
   class DecoratedAssociation
 
-    attr_reader :base, :association, :options
+    def initialize(owner, association, options)
+      options.assert_valid_keys(:with, :scope, :context)
 
-    def initialize(base, association, options)
-      @base = base
+      @owner = owner
       @association = association
-      options.assert_valid_keys(:with, :scope, :context)
-      @options = options
+
+      @decorator_class = options[:with]
+      @scope = options[:scope]
+      @context = options.fetch(:context, owner.context)
     end
 
     def call
       return undecorated if undecorated.nil?
-      decorate
+      decorated
     end
 
-    def source
-      base.source
+    def context
+      return @context.call(owner.context) if @context.respond_to?(:call)
+      @context
     end
 
     private
 
+    attr_reader :owner, :association, :decorator_class, :scope
+
+    def source
+      owner.source
+    end
+
     def undecorated
       @undecorated ||= begin
         associated = source.send(association)
-        associated = associated.send(options[:scope]) if options[:scope]
+        associated = associated.send(scope) if scope
         associated
       end
     end
 
-    def decorate
-      @decorated ||= decorator_class.send(decorate_method, undecorated, decorator_options)
-    end
-
-    def decorate_method
-      if collection? && decorator_class.respond_to?(:decorate_collection)
-        :decorate_collection
-      else
-        :decorate
-      end
+    def decorated
+      @decorated ||= decorator.call(undecorated, context: context)
     end
 
     def collection?
       undecorated.respond_to?(:first)
     end
 
-    def decorator_class
-      return options[:with] if options[:with]
+    def decorator
+      return collection_decorator if collection?
 
-      if collection?
-        options[:with] = :infer
-        Draper::CollectionDecorator
+      if decorator_class
+        decorator_class.method(:decorate)
       else
-        undecorated.decorator_class
+        ->(item, options) { item.decorate(options) }
       end
     end
 
-    def decorator_options
-      decorator_class # Ensures options[:with] = :infer for unspecified collections
+    def collection_decorator
+      klass = decorator_class || Draper::CollectionDecorator
 
-      dec_options = collection? ? options.slice(:with, :context) : options.slice(:context)
-      dec_options[:context] = base.context unless dec_options.key?(:context)
-      if dec_options[:context].respond_to?(:call)
-        dec_options[:context] = dec_options[:context].call(base.context) 
+      if klass.respond_to?(:decorate_collection)
+        klass.method(:decorate_collection)
+      else
+        klass.method(:decorate)
       end
-      dec_options
     end
+
   end
 end

data/lib/draper/decorator.rb

@@ -5,11 +5,12 @@ module Draper
     include Draper::ViewHelpers
     include ActiveModel::Serialization if defined?(ActiveModel::Serialization)
 
-    attr_accessor :source, :context
-
+    attr_reader :source
     alias_method :model, :source
     alias_method :to_source, :source
 
+    attr_accessor :context
+
     # Initialize a new decorator instance by passing in
     # an instance of the source class. Pass in an optional
     # :context inside the options hash which is available
@@ -23,7 +24,6 @@ module Draper
     # multiple places in the chain.
     #
     # @param [Object] source object to decorate
-    # @param [Hash] options (optional)
     # @option options [Hash] :context context available to the decorator
     def initialize(source, options = {})
       options.assert_valid_keys(:context)
@@ -136,8 +136,8 @@ module Draper
     # @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
+    # @option options [Class] :with (self) the class used to decorate
+    #   items
     # @option options [Hash] :context context available to decorated items
     def self.decorate_collection(source, options = {})
       options.assert_valid_keys(:with, :context)
@@ -258,8 +258,8 @@ module Draper
 
     def handle_multiple_decoration(options)
       if source.instance_of?(self.class)
-        self.context = source.context unless options.has_key?(:context)
-        self.source = source.source
+        @context = source.context unless options.has_key?(:context)
+        @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

data/lib/draper/version.rb

@@ -1,3 +1,3 @@
 module Draper
-  VERSION = "1.0.0.beta4"
+  VERSION = "1.0.0.beta5"
 end

data/spec/draper/collection_decorator_spec.rb

@@ -16,6 +16,27 @@ describe Draper::CollectionDecorator do
     subject.map{|item| item.source}.should == source
   end
 
+  describe "#source" do
+    it "duplicates the source collection" do
+      subject.source.should == source
+      subject.source.should_not be source
+    end
+
+    it "is frozen" do
+      subject.source.should be_frozen
+    end
+
+    it "is aliased to #to_source" do
+      subject.to_source.should == source
+    end
+  end
+
+  describe "#decorated_collection" do
+    it "is frozen" do
+      subject.decorated_collection.should be_frozen
+    end
+  end
+
   context "with context" do
     subject { Draper::CollectionDecorator.new(source, with: ProductDecorator, context: {some: 'context'}) }
 
@@ -79,55 +100,58 @@ describe Draper::CollectionDecorator do
         expect { Draper::CollectionDecorator.new(source, valid_options.merge(foo: 'bar')) }.to raise_error(ArgumentError, 'Unknown key: foo')
       end
     end
+  end
+
+  describe "item decoration" do
+    subject { subject_class.new(source, options) }
+    let(:decorator_classes) { subject.decorated_collection.map(&:class) }
+    let(:source) { [Product.new, Widget.new] }
+
+    context "when the :with option was given" do
+      let(:options) { {with: SpecificProductDecorator} }
 
-    context "when the :with option is given" do
       context "and the decorator can't be inferred from the class" do
-        subject { Draper::CollectionDecorator.new(source, with: ProductDecorator) }
+        let(:subject_class) { Draper::CollectionDecorator }
 
         it "uses the :with option" do
-          subject.decorator_class.should be ProductDecorator
+          decorator_classes.should == [SpecificProductDecorator, SpecificProductDecorator]
         end
       end
 
       context "and the decorator is inferrable from the class" do
-        subject { ProductsDecorator.new(source, with: SpecificProductDecorator) }
+        let(:subject_class) { ProductsDecorator }
 
         it "uses the :with option" do
-          subject.decorator_class.should be SpecificProductDecorator
+          decorator_classes.should == [SpecificProductDecorator, SpecificProductDecorator]
         end
       end
     end
 
-    context "when the :with option is not given" do
+    context "when the :with option was not given" do
+      let(:options) { {} }
+
       context "and the decorator can't be inferred from the class" do
-        it "raises an UninferrableDecoratorError" do
-          expect{Draper::CollectionDecorator.new(source)}.to raise_error Draper::UninferrableDecoratorError
+        let(:subject_class) { Draper::CollectionDecorator }
+
+        it "infers the decorator from each item" do
+          decorator_classes.should == [ProductDecorator, WidgetDecorator]
         end
       end
 
       context "and the decorator is inferrable from the class" do
-        subject { ProductsDecorator.new(source) }
+        let(:subject_class) { ProductsDecorator}
 
         it "infers the decorator" do
-          subject.decorator_class.should be ProductDecorator
+          decorator_classes.should == [ProductDecorator, ProductDecorator]
         end
       end
     end
   end
 
-  describe "#source" do
-    it "returns the source collection" do
-      subject.source.should be source
-    end
-
-    it "is aliased to #to_source" do
-      subject.to_source.should be source
-    end
-  end
-
   describe "#find" do
     context "with a block" do
       it "decorates Enumerable#find" do
+        subject.stub decorated_collection: []
         subject.decorated_collection.should_receive(:find)
         subject.find {|p| p.title == "title" }
       end
@@ -184,36 +208,15 @@ describe Draper::CollectionDecorator do
   describe "#to_ary" do
     # required for `render @collection` in Rails
     it "delegates to the decorated collection" do
-      subject.decorated_collection.should_receive(:to_ary).and_return(:an_array)
+      subject.stub decorated_collection: double(to_ary: :an_array)
       subject.to_ary.should == :an_array
     end
   end
 
-  describe "#respond_to?" do
-    it "returns true for its own methods" do
-      subject.should respond_to :decorated_collection
-    end
-
-    it "returns true for the wrapped collection's methods" do
-      source.stub(:respond_to?).with(:whatever, true).and_return(true)
-      subject.respond_to?(:whatever, true).should be_true
-    end
-  end
-
-  context "Array methods" do
-    describe "#include?" do
-      it "delegates to the decorated collection" do
-        subject.decorated_collection.should_receive(:include?).with(:something).and_return(true)
-        subject.should include :something
-      end
-    end
-
-    describe "#[]" do
-      it "delegates to the decorated collection" do
-        subject.decorated_collection.should_receive(:[]).with(42).and_return(:something)
-        subject[42].should == :something
-      end
-    end
+  it "delegates array methods to the decorated collection" do
+    subject.stub decorated_collection: []
+    subject.decorated_collection.should_receive(:[]).with(42).and_return(:the_answer)
+    subject[42].should == :the_answer
   end
 
   describe "#==" do
@@ -250,27 +253,24 @@ describe Draper::CollectionDecorator do
     end
   end
 
-  it "pretends to be the source class" do
-    subject.kind_of?(source.class).should be_true
-    subject.is_a?(source.class).should be_true
-  end
+  describe "#to_s" do
+    subject { Draper::CollectionDecorator.new(source, options) }
+    let(:source) { ["a", "b", "c"] }
 
-  it "is still its own class" do
-    subject.kind_of?(subject.class).should be_true
-    subject.is_a?(subject.class).should be_true
-  end
+    context "when :with option was given" do
+      let(:options) { {with: ProductDecorator} }
 
-  describe "#method_missing" do
-    before do
-      class << source
-        def page_number
-          42
-        end
+      it "returns a string representation of the CollectionDecorator" do
+        subject.to_s.should == '#<CollectionDecorator of ProductDecorator for ["a", "b", "c"]>'
       end
     end
 
-    it "proxies unknown methods to the source collection" do
-      subject.page_number.should == 42
+    context "when :with option was not given" do
+      let(:options) { {} }
+
+      it "returns a string representation of the CollectionDecorator" do
+        subject.to_s.should == '#<CollectionDecorator of inferred decorators for ["a", "b", "c"]>'
+      end
     end
   end
 

data/spec/draper/decoratable_spec.rb

@@ -150,7 +150,7 @@ describe Draper::Decoratable do
 
       decorator.should be_a Draper::CollectionDecorator
       decorator.decorator_class.should be WidgetDecorator
-      decorator.source.should be Product.scoped
+      decorator.source.should == Product.scoped
     end
 
     it "accepts context" do

data/spec/draper/decorated_association_spec.rb

@@ -1,313 +1,131 @@
 require 'spec_helper'
 
 describe Draper::DecoratedAssociation do
-  let(:decorated_association) { Draper::DecoratedAssociation.new(base, association, options) }
+  let(:decorated_association) { Draper::DecoratedAssociation.new(owner, :association, options) }
   let(:source) { Product.new }
-  let(:base) { source.decorate }
+  let(:owner) { source.decorate }
   let(:options) { {} }
 
   describe "#initialize" do
     describe "options validation" do
-      let(:association) { :similar_products }
       let(:valid_options) { {with: ProductDecorator, scope: :foo, context: {}} }
 
       it "does not raise error on valid options" do
-        expect { Draper::DecoratedAssociation.new(base, association, valid_options) }.to_not raise_error
+        expect { Draper::DecoratedAssociation.new(owner, :association, valid_options) }.to_not raise_error
       end
 
       it "raises error on invalid options" do
-        expect { Draper::DecoratedAssociation.new(base, association, valid_options.merge(foo: 'bar')) }.to raise_error(ArgumentError, 'Unknown key: foo')
+        expect { Draper::DecoratedAssociation.new(owner, :association, valid_options.merge(foo: 'bar')) }.to raise_error(ArgumentError, 'Unknown key: foo')
       end
     end
   end
 
-  describe "#base" do
-    subject { decorated_association.base }
-    let(:association) { :similar_products }
-
-    it "returns the base decorator" do
-      should be base
-    end
-
-    it "returns a Decorator" do
-      subject.class.should == ProductDecorator
-    end
-  end
-
-  describe "#source" do
-    subject { decorated_association.source }
-    let(:association) { :similar_products }
-
-    it "returns the base decorator's source" do
-      should be base.source
-    end
-
-    it "returns a Model" do
-      subject.class.should == Product
-    end
-  end
-
   describe "#call" do
-    subject { decorated_association.call }
-
-    context "for an ActiveModel collection association" do
-      let(:association) { :similar_products }
-
-      context "when the association is not empty" do
-        it "decorates the collection" do
-          subject.should be_a Draper::CollectionDecorator
-        end
-
-        it "infers the decorator" do
-          subject.decorator_class.should be :infer
-        end
-      end
+    let(:context) { {foo: "bar"} }
+    let(:expected_options) { {context: context} }
 
-      context "when the association is empty" do
-        it "returns an empty collection decorator" do
-          source.stub(:similar_products).and_return([])
-          subject.should be_a Draper::CollectionDecorator
-          subject.should be_empty
-          subject.first.should be_nil
-        end
-      end
+    before do
+      source.stub association: associated
+      decorated_association.stub context: context
     end
 
-    context "for non-ActiveModel collection associations" do
-      let(:association) { :poro_similar_products }
+    context "for a singular association" do
+      let(:associated) { Product.new }
 
-      context "when the association is not empty" do
-        it "decorates the collection" do
-          subject.should be_a Draper::CollectionDecorator
-        end
-
-        it "infers the decorator" do
-          subject.decorator_class.should be :infer
-        end
-      end
-
-      context "when the association is empty" do
-        it "returns an empty collection decorator" do
-          source.stub(:poro_similar_products).and_return([])
-          subject.should be_a Draper::CollectionDecorator
-          subject.should be_empty
-          subject.first.should be_nil
-        end
-      end
-    end
-
-    context "for an ActiveModel singular association" do
-      let(:association) { :previous_version }
+      context "when :with option was given" do
+        let(:options) { {with: decorator} }
+        let(:decorator) { SpecificProductDecorator }
 
-      context "when the association is present" do
-        it "decorates the association" do
-          subject.should be_decorated_with ProductDecorator
+        it "uses the specified decorator" do
+          decorator.should_receive(:decorate).with(associated, expected_options).and_return(:decorated)
+          decorated_association.call.should be :decorated
         end
       end
 
-      context "when the association is absent" do
-        it "doesn't decorate the association" do
-          source.stub(:previous_version).and_return(nil)
-          subject.should be_nil
+      context "when :with option was not given" do
+        it "infers the decorator" do
+          associated.should_receive(:decorate).with(expected_options).and_return(:decorated)
+          decorated_association.call.should be :decorated
         end
       end
     end
 
-    context "for a non-ActiveModel singular association" do
-      let(:association) { :poro_previous_version }
+    context "for a collection association" do
+      let(:associated) { [Product.new, Widget.new] }
 
-      context "when the association is present" do
-        it "decorates the association" do
-          subject.should be_decorated_with ProductDecorator
-        end
-      end
+      context "when :with option is a collection decorator" do
+        let(:options) { {with: collection_decorator} }
+        let(:collection_decorator) { ProductsDecorator }
 
-      context "when the association is absent" do
-        it "doesn't decorate the association" do
-          source.stub(:poro_previous_version).and_return(nil)
-          subject.should be_nil
+        it "uses the specified decorator" do
+          collection_decorator.should_receive(:decorate).with(associated, expected_options).and_return(:decorated_collection)
+          decorated_association.call.should be :decorated_collection
         end
       end
-    end
-
-    context "when a decorator is specified" do
-      let(:options) { {with: SpecificProductDecorator} }
 
-      context "for a singular association" do
-        let(:association) { :previous_version }
+      context "when :with option is a singular decorator" do
+        let(:options) { {with: decorator} }
+        let(:decorator) { SpecificProductDecorator }
 
-        it "decorates with the specified decorator" do
-          subject.should be_decorated_with SpecificProductDecorator
+        it "uses a CollectionDecorator of the specified decorator" do
+          decorator.should_receive(:decorate_collection).with(associated, expected_options).and_return(:decorated_collection)
+          decorated_association.call.should be :decorated_collection
         end
       end
 
-      context "for a collection association" do
-        let(:association) { :similar_products}
-
-        it "decorates with a collection of the specifed decorators" do
-          subject.should be_a Draper::CollectionDecorator
-          subject.decorator_class.should be SpecificProductDecorator
+      context "when :with option was not given" do
+        it "uses a CollectionDecorator of inferred decorators" do
+          Draper::CollectionDecorator.should_receive(:decorate).with(associated, expected_options).and_return(:decorated_collection)
+          decorated_association.call.should be :decorated_collection
         end
       end
     end
 
-    context "when a collection decorator is specified" do
-      let(:association) { :similar_products }
-      let(:options) { {with: ProductsDecorator} }
-
-      it "decorates with the specified decorator" do
-        subject.should be_a ProductsDecorator
-      end
-    end
-
     context "with a scope" do
-      let(:association) { :thing }
+      let(:associated) { [] }
       let(:options) { {scope: :foo} }
 
       it "applies the scope before decoration" do
-        scoped = [SomeThing.new]
-        SomeThing.any_instance.should_receive(:foo).and_return(scoped)
-        subject.source.should be scoped
-      end
-    end
-
-    context "base has context" do
-      let(:association) { :similar_products }
-      let(:base) { source.decorate(context: {some: 'context'}) }
-
-      context "when no context is specified" do
-        it "it should inherit context from base" do
-          subject.context.should == {some: 'context'}
-        end
-
-        it "it should share context hash with base" do
-          subject.context.should be base.context
-        end
-      end
-
-      context "when static context is specified" do
-        let(:options) { {context: {other: 'context'}} }
-
-        it "it should get context from static option" do
-          subject.context.should == {other: 'context'}
-        end
-      end
-
-      context "when lambda context is specified" do
-        let(:options) { {context: lambda {|context| context.merge(other: 'protext')}} }
-
-        it "it should get generated context" do
-          subject.context.should == {some: 'context', other: 'protext'}
-        end
+        scoped = [:scoped]
+        associated.should_receive(:foo).and_return(scoped)
+        decorated_association.call.source.should == scoped
       end
     end
   end
 
-  describe "#decorator_options" do
-    subject { decorated_association.send(:decorator_options) }
-
-    context "collection association" do
-      let(:association) { :similar_products }
+  describe "#context" do
+    before { owner.stub context: :owner_context }
 
-      context "no options" do
-        it "should return default options" do
-          should == {with: :infer, context: {}}
-        end
+    context "when :context option was given" do
+      let(:options) { {context: context} }
 
-        it "should set with: to :infer" do
-          decorated_association.send(:options).should == options
-          subject
-          decorated_association.send(:options).should == {with: :infer}
-        end
-      end
+      context "and is callable" do
+        let(:context) { ->(*){ :dynamic_context } }
 
-      context "option with: ProductDecorator" do
-        let(:options) { {with: ProductDecorator} }
-        it "should pass with: from options" do
-          should == {with: ProductDecorator, context: {}}
+        it "calls it with the owner's context" do
+          context.should_receive(:call).with(:owner_context)
+          decorated_association.context
         end
-      end
 
-      context "option scope: :to_a" do
-        let(:options) { {scope: :to_a} }
-        it "should strip scope: from options" do
-          decorated_association.send(:options).should == options
-          should == {with: :infer, context: {}}
+        it "returns the lambda's return value" do
+          decorated_association.context.should be :dynamic_context
         end
       end
 
-      context "base has context" do
-        let(:base) { source.decorate(context: {some: 'context'}) }
+      context "and is not callable" do
+        let(:context) { :static_context }
 
-        context "no options" do
-          it "should return context from base" do
-            should == {with: :infer, context: {some: 'context'}}
-          end
-        end
-
-        context "option context: {other: 'context'}" do
-          let(:options) { {context: {other: 'context'}} }
-          it "should return specified context" do
-            should == {with: :infer, context: {other: 'context'}}
-          end
-        end
-
-        context "option context: lambda" do
-          let(:options) { {context: lambda {|context| context.merge(other: 'protext')}} }
-          it "should return specified context" do
-            should == {with: :infer, context: {some: 'context', other: 'protext'}}
-          end
+        it "returns the specified value" do
+          decorated_association.context.should be :static_context
         end
       end
     end
 
-    context "singular association" do
-      let(:association) { :previous_version }
-
-      context "no options" do
-        it "should return default options" do
-          should == {context: {}}
-        end
-      end
-
-      context "option with: ProductDecorator" do
-        let(:options) { {with: ProductDecorator} }
-        it "should strip with: from options" do
-          should == {context: {}}
-        end
-      end
-
-      context "option scope: :decorate" do
-        let(:options) { {scope: :decorate} }
-        it "should strip scope: from options" do
-          decorated_association.send(:options).should == options
-          should == {context: {}}
-        end
-      end
-
-      context "base has context" do
-        let(:base) { source.decorate(context: {some: 'context'}) }
-
-        context "no options" do
-          it "should return context from base" do
-            should == {context: {some: 'context'}}
-          end
-        end
-
-        context "option context: {other: 'context'}" do
-          let(:options) { {context: {other: 'context'}} }
-          it "should return specified context" do
-            should == {context: {other: 'context'}}
-          end
-        end
-
-        context "option context: lambda" do
-          let(:options) { {context: lambda {|context| context.merge(other: 'protext')}} }
-          it "should return specified context" do
-            should == {context: {some: 'context', other: 'protext'}}
-          end
-        end
+    context "when :context option was not given" do
+      it "returns the owner's context" do
+        decorated_association.context.should be :owner_context
       end
     end
   end
+
 end

data/spec/draper/decorator_spec.rb

@@ -94,22 +94,13 @@ describe Draper::Decorator do
 
     it "returns a collection decorator" do
       subject.should be_a Draper::CollectionDecorator
-      subject.source.should be source
+      subject.source.should == source
     end
 
     it "uses itself as the item decorator by default" do
       subject.each {|item| item.should be_a ProductDecorator}
     end
 
-    context "when given :with => :infer" do
-      subject { ProductDecorator.decorate_collection(source, with: :infer) }
-
-      it "infers the item decorators" do
-        subject.first.should be_a ProductDecorator
-        subject.last.should be_a WidgetDecorator
-      end
-    end
-
     context "with context" do
       subject { ProductDecorator.decorate_collection(source, with: :infer, context: {some: 'context'}) }
 

data/spec/draper/finders_spec.rb

@@ -64,7 +64,7 @@ describe Draper::Finders do
 
   describe ".find_all_by_" do
     it "proxies to the model class" do
-      Product.should_receive(:find_all_by_name_and_size).with("apples", "large")
+      Product.should_receive(:find_all_by_name_and_size).with("apples", "large").and_return([])
       ProductDecorator.find_all_by_name_and_size("apples", "large")
     end
 
@@ -73,7 +73,7 @@ describe Draper::Finders do
       Product.stub(:find_all_by_name).and_return(found)
       decorator = ProductDecorator.find_all_by_name("apples")
       decorator.should be_a Draper::CollectionDecorator
-      decorator.source.should be found
+      decorator.source.should == found
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: draper
 version: !ruby/object:Gem::Version
-  version: 1.0.0.beta4
+  version: 1.0.0.beta5
   prerelease: 6
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-18 00:00:00.000000000 Z
+date: 2012-12-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -51,7 +51,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: 1.0.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -59,7 +59,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: 1.0.3
 - !ruby/object:Gem::Dependency
   name: ammeter
   requirement: !ruby/object:Gem::Requirement
@@ -99,7 +99,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.10'
+        version: '2.12'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -107,7 +107,23 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.10'
+        version: '2.12'
+- !ruby/object:Gem::Dependency
+  name: rspec-mocks
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.12.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.12.1
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement