assignable_values 0.14.0 → 0.16.2

data/lib/assignable_values.rb

@@ -1,4 +1,5 @@
 require 'active_record'
+require 'active_support/deprecation'
 require 'assignable_values/errors'
 require 'assignable_values/active_record'
 require 'assignable_values/active_record/restriction/base'

data/lib/assignable_values/active_record/restriction/base.rb

@@ -48,25 +48,31 @@ module AssignableValues
         end
 
         def assignable_values(record, options = {})
-          assignable_values = []
+          additional_assignable_values = []
           current_values = assignable_values_from_record_or_delegate(record)
 
           if options.fetch(:include_old_value, true) && has_previously_saved_value?(record)
             old_value = previously_saved_value(record)
             if @options[:multiple]
               if old_value.is_a?(Array)
-                assignable_values |= old_value
+                additional_assignable_values |= old_value
               end
             elsif !old_value.blank? && !current_values.include?(old_value)
-              assignable_values << old_value
+              additional_assignable_values << old_value
             end
           end
 
-          assignable_values += current_values
           if options[:decorate]
-            assignable_values = decorate_values(assignable_values)
+            current_values = decorate_values(current_values)
+            additional_assignable_values = decorate_values(additional_assignable_values)
+          end
+
+          if additional_assignable_values.present?
+            # will not keep current_values scoped
+            additional_assignable_values + current_values
+          else
+            current_values
           end
-          assignable_values
         end
 
         private
@@ -94,7 +100,21 @@ module AssignableValues
         def assignable_single_value?(record, value)
           (has_previously_saved_value?(record) && value == previously_saved_value(record)) ||
             (value.blank? && allow_blank?(record)) ||
-            assignable_values(record, :include_old_value => false).include?(value)
+            included_in_assignable_values?(record, value)
+        end
+
+        def included_in_assignable_values?(record, value)
+          values_or_scope = assignable_values(record, :include_old_value => false)
+
+          if is_scope?(values_or_scope)
+            values_or_scope.exists?(value.id)
+          else
+            values_or_scope.include?(value)
+          end
+        end
+
+        def is_scope?(object)
+          object.respond_to?(:scoped) || object.respond_to?(:all)
         end
 
         def assignable_multi_value?(record, value)
@@ -217,9 +237,9 @@ module AssignableValues
 
         def assignable_values_from_record_or_delegate(record)
           if delegate?
-            assignable_values_from_delegate(record).to_a
+            assignable_values_from_delegate(record)
           else
-            record.instance_exec(&@values).to_a
+            record.instance_exec(&@values)
           end
         end
 
@@ -240,7 +260,7 @@ module AssignableValues
           delegate = delegate(record)
           delegate.present? or raise DelegateUnavailable, "Cannot query a nil delegate for assignable values"
           delegate_query_method = :"assignable_#{model.name.underscore.gsub('/', '_')}_#{property.to_s.pluralize}"
-          args = delegate.method(delegate_query_method).arity == 1 ? [record] : []
+          args = delegate.method(delegate_query_method).arity == 0 ? [] : [record]
           delegate.send(delegate_query_method, *args)
         end
 

data/lib/assignable_values/active_record/restriction/scalar_attribute.rb

@@ -7,7 +7,7 @@ module AssignableValues
           super
           define_humanized_value_instance_method
           define_humanized_value_class_method
-          define_humanized_values_instance_method
+          define_humanized_assignable_values_instance_method
         end
 
         def humanized_value(value)
@@ -17,8 +17,8 @@ module AssignableValues
           end
         end
 
-        def humanized_values(record)
-          values = assignable_values(record)
+        def humanized_assignable_values(record, options = {})
+          values = assignable_values(record, options)
           values.collect do |value|
             HumanizedValue.new(value, humanized_value(value))
           end
@@ -37,7 +37,7 @@ module AssignableValues
         def define_humanized_value_class_method
           restriction = self
           enhance_model_singleton do
-            define_method :"humanized_#{restriction.property}" do |given_value|
+            define_method :"humanized_#{restriction.property.to_s.singularize}" do |given_value|
               restriction.humanized_value(given_value)
             end
           end
@@ -45,20 +45,45 @@ module AssignableValues
 
         def define_humanized_value_instance_method
           restriction = self
+          multiple = @options[:multiple]
           enhance_model do
-            define_method :"humanized_#{restriction.property}" do |*args|
+            define_method :"humanized_#{restriction.property.to_s.singularize}" do |*args|
+              if args.size > 1 || (multiple && args.size == 0)
+                raise ArgumentError.new("wrong number of arguments (#{args.size} for #{multiple ? '1' : '0..1'})")
+              end
               given_value = args[0]
               value = given_value || send(restriction.property)
               restriction.humanized_value(value)
             end
+
+            if multiple
+              define_method :"humanized_#{restriction.property}" do
+                values = send(restriction.property)
+                if values.respond_to?(:map)
+                  values.map do |value|
+                    restriction.humanized_value(value)
+                  end
+                else
+                  values
+                end
+              end
+            end
           end
         end
 
-        def define_humanized_values_instance_method
+        def define_humanized_assignable_values_instance_method
           restriction = self
+          multiple = @options[:multiple]
           enhance_model do
-            define_method :"humanized_#{restriction.property.to_s.pluralize}" do
-              restriction.humanized_values(self)
+            define_method :"humanized_assignable_#{restriction.property.to_s.pluralize}" do |*args|
+              restriction.humanized_assignable_values(self, *args)
+            end
+
+            unless multiple
+              define_method :"humanized_#{restriction.property.to_s.pluralize}" do
+                ActiveSupport::Deprecation.warn("humanized_<value>s is deprecated, use humanized_assignable_<value>s instead", caller)
+                restriction.humanized_assignable_values(self)
+              end
             end
           end
         end

data/lib/assignable_values/humanizable_string.rb

@@ -8,7 +8,8 @@ class HumanizableString < String
   end
 
   def humanized
+    ActiveSupport::Deprecation.warn("assignable_<value>.humanized is deprecated, use humanized_assignable_<value>s.humanized instead", caller)
     @humanization
   end
 
-end
+end

data/lib/assignable_values/version.rb

@@ -1,3 +1,3 @@
 module AssignableValues
-  VERSION = '0.14.0'
+  VERSION = '0.16.2'
 end

data/spec/assignable_values/active_record_spec.rb

@@ -1,6 +1,14 @@
 require 'spec_helper'
 require 'ostruct'
 
+def save_without_validation(record)
+  if ActiveRecord::VERSION::MAJOR < 3
+    record.save(false)
+  else
+    record.save(:validate => false)
+  end
+end
+
 describe AssignableValues::ActiveRecord do
 
   describe '.assignable_values' do
@@ -17,24 +25,30 @@ describe AssignableValues::ActiveRecord do
 
       before :each do
         @klass = Song.disposable_copy do
-          assignable_values_for :sub_genre do
+          assignable_values_for :virtual_sub_genre do
+            %w[pop rock]
+          end
+
+          assignable_values_for :virtual_multi_genres, :multiple => true, :allow_blank => true do
             %w[pop rock]
           end
         end
       end
 
       it 'should validate that the attribute is allowed' do
-        @klass.new(:sub_genre => 'pop').should be_valid
-        @klass.new(:sub_genre => 'disallowed value').should_not be_valid
+        @klass.new(:virtual_sub_genre => 'pop').should be_valid
+        @klass.new(:virtual_sub_genre => 'disallowed value').should_not be_valid
       end
 
       it 'should not allow nil for the attribute value' do
-        @klass.new(:sub_genre => nil).should_not be_valid
+        @klass.new(:virtual_sub_genre => nil).should_not be_valid
       end
 
       it 'should generate a method returning the humanized value' do
-        song = @klass.new(:sub_genre => 'pop')
-        song.humanized_sub_genre.should == 'Pop music'
+        song = @klass.new(:virtual_sub_genre => 'pop')
+        song.humanized_virtual_sub_genre.should == 'Pop music'
+        song.humanized_virtual_sub_genre('rock').should == 'Rock music'
+        song.humanized_virtual_multi_genre('rock').should == 'Rock music'
       end
 
     end
@@ -45,21 +59,21 @@ describe AssignableValues::ActiveRecord do
 
         before :each do
           @klass = Song.disposable_copy do
-            assignable_values_for :sub_genres,:multiple => true do
+            assignable_values_for :virtual_multi_genres, :multiple => true do
               %w[pop rock]
             end
           end
         end
 
         it 'should validate that the attribute is a subset' do
-          @klass.new(:sub_genres => ['pop']).should be_valid
-          @klass.new(:sub_genres => ['pop', 'rock']).should be_valid
-          @klass.new(:sub_genres => ['pop', 'disallowed value']).should_not be_valid
+          @klass.new(:virtual_multi_genres => ['pop']).should be_valid
+          @klass.new(:virtual_multi_genres => ['pop', 'rock']).should be_valid
+          @klass.new(:virtual_multi_genres => ['pop', 'disallowed value']).should_not be_valid
         end
 
         it 'should not allow nil or [] for allow_blank: false' do
-          @klass.new(:sub_genres => nil).should_not be_valid
-          @klass.new(:sub_genres => []).should_not be_valid
+          @klass.new(:virtual_multi_genres => nil).should_not be_valid
+          @klass.new(:virtual_multi_genres => []).should_not be_valid
         end
 
       end
@@ -68,15 +82,15 @@ describe AssignableValues::ActiveRecord do
 
         before :each do
           @klass = Song.disposable_copy do
-            assignable_values_for :sub_genres, :multiple => true, :allow_blank => true do
+            assignable_values_for :virtual_multi_genres, :multiple => true, :allow_blank => true do
               %w[pop rock]
             end
           end
         end
 
         it 'should allow nil or [] for allow_blank: false' do
-          @klass.new(:sub_genres => nil).should be_valid
-          @klass.new(:sub_genres => []).should be_valid
+          @klass.new(:virtual_multi_genres => nil).should be_valid
+          @klass.new(:virtual_multi_genres => []).should be_valid
         end
 
       end
@@ -92,6 +106,10 @@ describe AssignableValues::ActiveRecord do
             assignable_values_for :genre do
               %w[pop rock]
             end
+
+            assignable_values_for :virtual_multi_genres, :multiple => true, :allow_blank => true do
+              %w[pop rock]
+            end
           end
         end
 
@@ -153,6 +171,31 @@ describe AssignableValues::ActiveRecord do
           @klass.humanized_genre('rock').should == 'Rock music'
         end
 
+        context 'for multiple: true' do
+          it 'should raise when trying to humanize a value without an argument' do
+            song = @klass.new
+            proc { song.humanized_virtual_multi_genre }.should raise_error(ArgumentError)
+          end
+
+          it 'should generate an instance method to retrieve the humanization of any given value' do
+            song = @klass.new(:genre => 'pop')
+            song.humanized_virtual_multi_genre('rock').should == 'Rock music'
+          end
+
+          it 'should generate a class method to retrieve the humanization of any given value' do
+            @klass.humanized_virtual_multi_genre('rock').should == 'Rock music'
+          end
+
+          it 'should generate an instance method to retrieve the humanizations of all current values' do
+            song = @klass.new
+            song.virtual_multi_genres = nil
+            song.humanized_virtual_multi_genres.should == nil
+            song.virtual_multi_genres = []
+            song.humanized_virtual_multi_genres.should == []
+            song.virtual_multi_genres = ['pop', 'rock']
+            song.humanized_virtual_multi_genres.should == ['Pop music', 'Rock music']
+          end
+        end
       end
 
       context 'if the :allow_blank option is set to true' do
@@ -220,11 +263,11 @@ describe AssignableValues::ActiveRecord do
       context 'if the :message option is set to a string' do
 
         before :each do
-           @klass = Song.disposable_copy do
-             assignable_values_for :genre, :message => 'should be something different' do
-               %w[pop rock]
-             end
-           end
+          @klass = Song.disposable_copy do
+            assignable_values_for :genre, :message => 'should be something different' do
+              %w[pop rock]
+            end
+          end
         end
 
         it 'should use this string as a custom error message' do
@@ -245,43 +288,39 @@ describe AssignableValues::ActiveRecord do
 
         before :each do
           @klass = Song.disposable_copy do
-            assignable_values_for :genres, :multiple => true do
+            assignable_values_for :multi_genres, :multiple => true do
               %w[pop rock]
             end
           end
         end
 
         it 'should validate that the attribute is allowed' do
-          @klass.new(:genres => ['pop']).should be_valid
-          @klass.new(:genres => ['pop', 'rock']).should be_valid
-          @klass.new(:genres => ['pop', 'invalid value']).should_not be_valid
+          @klass.new(:multi_genres => ['pop']).should be_valid
+          @klass.new(:multi_genres => ['pop', 'rock']).should be_valid
+          @klass.new(:multi_genres => ['pop', 'invalid value']).should_not be_valid
         end
 
         it 'should not allow a scalar attribute' do
-          @klass.new(:genres => 'pop').should_not be_valid
+          @klass.new(:multi_genres => 'pop').should_not be_valid
         end
 
         it 'should not allow nil or [] for the attribute value' do
-          @klass.new(:genres => nil).should_not be_valid
-          @klass.new(:genres => []).should_not be_valid
+          @klass.new(:multi_genres => nil).should_not be_valid
+          @klass.new(:multi_genres => []).should_not be_valid
         end
 
         it 'should allow a subset of previously saved values even if that value is no longer allowed' do
-          record = @klass.create!(:genres => ['pop'])
-          record.genres = ['pretend', 'previously', 'valid', 'value']
-          if ActiveRecord::VERSION::MAJOR < 3
-            record.save(false)
-          else
-            record.save(:validate => false) # update without validations for the sake of this test
-          end
+          record = @klass.create!(:multi_genres => ['pop'])
+          record.multi_genres = ['pretend', 'previously', 'valid', 'value']
+          save_without_validation(record) # update without validation for the sake of this test
           record.reload.should be_valid
-          record.genres = ['valid', 'previously', 'pop']
+          record.multi_genres = ['valid', 'previously', 'pop']
           record.should be_valid
         end
 
         it 'should allow a previously saved, blank value even if that value is no longer allowed' do
-          record = @klass.create!(:genres => ['pop'])
-          @klass.update_all(:genres => []) # update without validations for the sake of this test
+          record = @klass.create!(:multi_genres => ['pop'])
+          @klass.update_all(:multi_genres => []) # update without validations for the sake of this test
           record.reload.should be_valid
         end
 
@@ -291,18 +330,18 @@ describe AssignableValues::ActiveRecord do
 
         before :each do
           @klass = Song.disposable_copy do
-            assignable_values_for :genres, :multiple => true, :allow_blank => true do
+            assignable_values_for :multi_genres, :multiple => true, :allow_blank => true do
               %w[pop rock]
             end
           end
         end
 
         it 'should allow nil for the attribute value' do
-          @klass.new(:genres => nil).should be_valid
+          @klass.new(:multi_genres => nil).should be_valid
         end
 
         it 'should allow an empty array as value' do
-          @klass.new(:genres => []).should be_valid
+          @klass.new(:multi_genres => []).should be_valid
         end
 
       end
@@ -409,7 +448,7 @@ describe AssignableValues::ActiveRecord do
         record.should be_valid
       end
 
-      it 'sould not allow nil for an association (the "previously saved value") if the record is new' do
+      it 'should not allow nil for an association (the "previously saved value") if the record is new' do
         allowed_association = Artist.create!
         klass = Song.disposable_copy
         record = klass.new(:artist => nil)
@@ -471,6 +510,47 @@ describe AssignableValues::ActiveRecord do
         record.valid?
       end
 
+      it 'should not load all records to memory when assignable values are scoped' do
+        unless ::ActiveRecord::VERSION::MAJOR < 3 # somehow rails 2 still initializes Objects during the scope.exists?-call
+          initialized_artists_count = 0
+          MyArtist = Artist.disposable_copy
+
+          MyArtist.class_eval do
+            after_initialize :increase_initialized_count
+
+            define_method :increase_initialized_count do
+              initialized_artists_count += 1
+            end
+          end
+
+          klass = Song.disposable_copy
+
+          klass.class_eval do
+            assignable_values_for :artist do
+              if ::ActiveRecord::VERSION::MAJOR < 4
+                MyArtist.scoped
+              else
+                MyArtist.all
+              end
+            end
+          end
+
+          artist = MyArtist.create!
+          initialized_artists_count.should == 1
+
+          song = klass.new(:artist => artist)
+
+          song.valid?
+          initialized_artists_count.should == 1
+
+          song.assignable_artists
+          initialized_artists_count.should == 1
+
+          song.assignable_artists.to_a
+          initialized_artists_count.should == 2
+        end
+      end
+
     end
 
     context 'when delegating using the :through option' do
@@ -479,7 +559,11 @@ describe AssignableValues::ActiveRecord do
         klass = Song.disposable_copy do
           assignable_values_for :genre, :through => :delegate
           def delegate
-            OpenStruct.new(:assignable_song_genres => %w[pop rock])
+            Class.new do
+              def assignable_song_genres
+                %w[pop rock]
+              end
+            end.new
           end
         end
         klass.new(:genre => 'pop').should be_valid
@@ -490,9 +574,14 @@ describe AssignableValues::ActiveRecord do
         klass = Song.disposable_copy do
           assignable_values_for :genre, :through => lambda { delegate }
           def delegate
-            OpenStruct.new(:assignable_song_genres => %w[pop rock])
+            Class.new do
+              def assignable_song_genres
+                %w[pop rock]
+              end
+            end.new
           end
         end
+
         klass.new(:genre => 'pop').should be_valid
         klass.new(:genre => 'disallowed value').should_not be_valid
       end
@@ -501,7 +590,11 @@ describe AssignableValues::ActiveRecord do
         klass = Recording::Vinyl.disposable_copy do
           assignable_values_for :year, :through => :delegate
           def delegate
-            OpenStruct.new(:assignable_recording_vinyl_years => [1977, 1980, 1983])
+            Class.new do
+              def assignable_recording_vinyl_years
+                [1977, 1980, 1983]
+              end
+            end.new
           end
         end
         klass.new.assignable_years.should == [1977, 1980, 1983]
@@ -678,7 +771,7 @@ describe AssignableValues::ActiveRecord do
         klass.new.assignable_genres.should == %w[pop rock]
       end
 
-      it 'should call #to_a on the list of assignable values, allowing ranges and scopes to be passed as allowed value descriptors' do
+      it 'should work with ranges' do
         klass = Song.disposable_copy do
           assignable_values_for :year do
             1999..2001
@@ -704,10 +797,28 @@ describe AssignableValues::ActiveRecord do
           assignable_values_for :genre do
             %w[pop rock]
           end
+
+          assignable_values_for :multi_genres, :multiple => true do
+            %w[pop rock]
+          end
         end
-        record = klass.create!(:genre => 'pop')
+        record = klass.create!(:genre => 'pop', :multi_genres => ['rock'])
         klass.update_all(:genre => 'ballad') # update without validation for the sake of this test
         record.reload.assignable_genres.should == %w[ballad pop rock]
+
+        humanized_genres = record.humanized_assignable_genres
+        humanized_genres.collect(&:value).should == %w[ballad pop rock]
+        humanized_genres.collect(&:humanized).should == ['Ballad', 'Pop music', 'Rock music']
+        humanized_genres.collect(&:to_s).should == ['Ballad', 'Pop music', 'Rock music']
+
+        record.multi_genres = %w[ballad classic]
+        save_without_validation(record) # update without validation for the sake of this test
+        record.reload.multi_genres.should == %w[ballad classic]
+
+        humanized_multi_genres = record.humanized_assignable_multi_genres
+        humanized_multi_genres.collect(&:value).should == %w[ballad classic pop rock]
+        humanized_multi_genres.collect(&:humanized).should == ['Ballad', 'Classic', 'Pop music', 'Rock music']
+        humanized_multi_genres.collect(&:to_s).should == ['Ballad', 'Classic', 'Pop music', 'Rock music']
       end
 
       it 'should not prepend a previously saved value to the top of the list if it is still allowed (bugfix)' do
@@ -747,10 +858,28 @@ describe AssignableValues::ActiveRecord do
           assignable_values_for :genre do
             %w[pop rock]
           end
+
+          assignable_values_for :multi_genres, :multiple => true do
+            %w[pop rock]
+          end
         end
-        record = klass.create!(:genre => 'pop')
+        record = klass.create!(:genre => 'pop', :multi_genres => ['rock'])
         klass.update_all(:genre => 'ballad') # update without validation for the sake of this test
         record.reload.assignable_genres(:include_old_value => false).should == %w[pop rock]
+
+        humanized_genres = record.humanized_assignable_genres(:include_old_value => false)
+        humanized_genres.collect(&:value).should == %w[pop rock]
+        humanized_genres.collect(&:humanized).should == ['Pop music', 'Rock music']
+        humanized_genres.collect(&:to_s).should == ['Pop music', 'Rock music']
+
+        record.multi_genres = %w[ballad classic]
+        save_without_validation(record) # update without validation for the sake of this test
+        record.reload.multi_genres.should == %w[ballad classic]
+
+        humanized_multi_genres = record.humanized_assignable_multi_genres(:include_old_value => false)
+        humanized_multi_genres.collect(&:value).should == %w[pop rock]
+        humanized_multi_genres.collect(&:humanized).should == ['Pop music', 'Rock music']
+        humanized_multi_genres.collect(&:to_s).should == ['Pop music', 'Rock music']
       end
 
       it 'should allow omitting a previously saved association' do
@@ -791,11 +920,18 @@ describe AssignableValues::ActiveRecord do
             assignable_values_for :genre do
               %w[pop rock]
             end
+
+            assignable_values_for :multi_genres, :multiple => true do
+              %w[pop rock]
+            end
           end
-          genres = klass.new.humanized_genres
+          genres = klass.new.humanized_assignable_genres
           genres.collect(&:value).should == ['pop', 'rock']
           genres.collect(&:humanized).should == ['Pop music', 'Rock music']
           genres.collect(&:to_s).should == ['Pop music', 'Rock music']
+
+          multi_genres = klass.new.humanized_assignable_multi_genres
+          multi_genres.collect(&:humanized).should == ['Pop music', 'Rock music']
         end
 
         it 'should use String#humanize as a default translation' do
@@ -804,7 +940,7 @@ describe AssignableValues::ActiveRecord do
               %w[electronic]
             end
           end
-          klass.new.humanized_genres.collect(&:humanized).should == ['Electronic']
+          klass.new.humanized_assignable_genres.collect(&:humanized).should == ['Electronic']
         end
 
         it 'should allow to define humanizations for values that are not strings' do
@@ -813,7 +949,7 @@ describe AssignableValues::ActiveRecord do
               [1977, 1980, 1983]
             end
           end
-          years = klass.new.humanized_years
+          years = klass.new.humanized_assignable_years
           years.collect(&:value).should == [1977, 1980, 1983]
           years.collect(&:humanized).should == ['The year a new hope was born', 'The year the Empire stroke back', 'The year the Jedi returned']
         end
@@ -824,18 +960,30 @@ describe AssignableValues::ActiveRecord do
               [1977, 1980, 1983]
             end
           end
-          years = klass.new.humanized_years
+          years = klass.new.humanized_assignable_years
           years.collect(&:humanized).should == ['The year a new hope was born', 'The year the Empire stroke back', 'The year the Jedi returned']
         end
 
         context 'legacy methods for API compatibility' do
 
+          it 'should define a method that return pairs of values and their humanization' do
+            klass = Song.disposable_copy do
+              assignable_values_for :genre do
+                %w[pop rock]
+              end
+            end
+            ActiveSupport::Deprecation.should_receive(:warn)
+            genres = klass.new.humanized_genres
+            genres.collect(&:humanized).should == ['Pop music', 'Rock music']
+          end
+
           it "should define a method #humanized on assignable string values, which return up the value's' translation" do
             klass = Song.disposable_copy do
               assignable_values_for :genre do
                 %w[pop rock]
               end
             end
+            ActiveSupport::Deprecation.should_receive(:warn).at_least(:once)
             klass.new.assignable_genres.collect(&:humanized).should == ['Pop music', 'Rock music']
           end
 
@@ -872,7 +1020,7 @@ describe AssignableValues::ActiveRecord do
           delegate = Object.new
           def delegate.assignable_song_genres(record)
             record_received(record)
-             %w[pop rock]
+            %w[pop rock]
           end
           klass = Song.disposable_copy do
             assignable_values_for :genre, :through => :delegate
@@ -885,6 +1033,55 @@ describe AssignableValues::ActiveRecord do
           record.assignable_genres.should ==  %w[pop rock]
         end
 
+        it "should call the given method on the delegate if the delegate's query method takes no arguments" do
+          delegate = Object.new
+          def delegate.assignable_song_genres
+            no_record_received
+            %w[pop rock]
+          end
+          klass = Song.disposable_copy do
+            assignable_values_for :genre, :through => :delegate
+            define_method :delegate do
+              delegate
+            end
+          end
+          record = klass.new
+          delegate.should_receive(:no_record_received)
+          record.assignable_genres.should ==  %w[pop rock]
+        end
+
+        it "should pass the record to the given method if the delegate's query method takes variable arguments" do
+          delegate = Object.new
+          def delegate.assignable_song_genres(*records)
+            record_received(*records)
+            %w[pop rock]
+          end
+          klass = Song.disposable_copy do
+            assignable_values_for :genre, :through => :delegate
+            define_method :delegate do
+              delegate
+            end
+          end
+          record = klass.new
+          delegate.should_receive(:record_received).with(record)
+          record.assignable_genres.should ==  %w[pop rock]
+        end
+
+        it "should raise an error if the delegate's query method takes more than one argument" do
+          delegate = Object.new
+          def delegate.assignable_song_genres(record, other_arg)
+            %w[pop rock]
+          end
+          klass = Song.disposable_copy do
+            assignable_values_for :genre, :through => :delegate
+            define_method :delegate do
+              delegate
+            end
+          end
+          record = klass.new
+          expect{record.assignable_genres}.to raise_error(ArgumentError)
+        end
+
         it 'should raise an error if the given method returns nil' do
           klass = Song.disposable_copy do
             assignable_values_for :genre, :through => :delegate
@@ -894,11 +1091,7 @@ describe AssignableValues::ActiveRecord do
           end
           expect { klass.new.assignable_genres }.to raise_error(AssignableValues::DelegateUnavailable)
         end
-
       end
-
     end
-
   end
-
 end