assignable_values 0.16.0 → 0.16.5

data/Gemfile.5.1.pg

@@ -10,7 +10,7 @@ gem 'rake'
 gem 'database_cleaner'
 gem 'rspec'
 gem 'rspec_candy'
-gem 'gemika'
+gem 'gemika', '>= 0.5.0'
 
 # Gem under test
 gem 'assignable_values', :path => '.'

data/Gemfile.5.1.pg.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    assignable_values (0.15.1)
+    assignable_values (0.16.5)
       activerecord (>= 2.3)
 
 GEM
@@ -22,7 +22,7 @@ GEM
     concurrent-ruby (1.0.5)
     database_cleaner (1.6.1)
     diff-lcs (1.3)
-    gemika (0.3.2)
+    gemika (0.5.0)
     i18n (0.9.0)
       concurrent-ruby (~> 1.0)
     minitest (5.10.3)
@@ -57,7 +57,7 @@ DEPENDENCIES
   activerecord (~> 5.1.0)
   assignable_values!
   database_cleaner
-  gemika
+  gemika (>= 0.5.0)
   i18n
   pg (< 1)
   rake
@@ -65,4 +65,4 @@ DEPENDENCIES
   rspec_candy
 
 BUNDLED WITH
-   1.16.4
+   2.1.4

data/{Gemfile.3.2 → Gemfile.6.0.pg}

@@ -1,16 +1,16 @@
 source 'https://rubygems.org'
 
 # Runtime dependencies
-gem 'activerecord', '~>3.2.0'
-gem 'i18n', '<0.7'
-gem 'mysql2', '= 0.3.17'
+gem 'activerecord', '~>6.0.0'
+gem 'i18n'
+gem 'pg', '<1'
 
 # Development dependencies
 gem 'rake'
-gem 'database_cleaner', '~> 1.0.0'
-gem 'rspec', '~> 3.4'
+gem 'database_cleaner'
+gem 'rspec'
 gem 'rspec_candy'
-gem 'gemika'
+gem 'gemika', '>= 0.5.0'
 
 # Gem under test
 gem 'assignable_values', :path => '.'

data/Gemfile.6.0.pg.lock

@@ -0,0 +1,68 @@
+PATH
+  remote: .
+  specs:
+    assignable_values (0.16.4)
+      activerecord (>= 2.3)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (6.0.0)
+      activesupport (= 6.0.0)
+    activerecord (6.0.0)
+      activemodel (= 6.0.0)
+      activesupport (= 6.0.0)
+    activesupport (6.0.0)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+      zeitwerk (~> 2.1, >= 2.1.8)
+    concurrent-ruby (1.1.5)
+    database_cleaner (1.7.0)
+    diff-lcs (1.3)
+    gemika (0.3.4)
+    i18n (1.6.0)
+      concurrent-ruby (~> 1.0)
+    minitest (5.11.3)
+    pg (0.21.0)
+    rake (12.3.2)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.0)
+    rspec_candy (0.5.1)
+      rspec
+      sneaky-save
+    sneaky-save (0.1.3)
+      activerecord (>= 3.2.0)
+    thread_safe (0.3.6)
+    tzinfo (1.2.5)
+      thread_safe (~> 0.1)
+    zeitwerk (2.1.9)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord (~> 6.0.0)
+  assignable_values!
+  database_cleaner
+  gemika
+  i18n
+  pg (< 1)
+  rake
+  rspec
+  rspec_candy
+
+BUNDLED WITH
+   1.17.3

data/README.md

@@ -1,11 +1,11 @@
-assignable_values - Enums on vitamins [![Build Status](https://secure.travis-ci.org/makandra/assignable_values.png?branch=master)](https://travis-ci.org/makandra/assignable_values)
+assignable_values - Enums on vitamins [![Tests](https://github.com/makandra/assignable_values/workflows/Tests/badge.svg)](https://github.com/makandra/assignable_values/actions)
 =====================================
 
 `assignable_values` lets you restrict the values that can be assigned to attributes or associations of ActiveRecord models. You can think of it as enums where the list of allowed values is generated at runtime and the value is checked during validation.
 
 We carefully enhanced the core enum functionality with small tweaks that are useful for web forms, internationalized applications and common authorization patterns.
 
-`assignable_values` is tested with Rails 2.3, 3.2, 4.2 and 5.0 on Ruby 1.8.7, 2.1 and 2.3.
+`assignable_values` is tested with Rails 2.3, 3.2, 4.2, 5.1 and 6.0 (beta) on Ruby 1.8.7, 2.1, 2.3, 2.4 and 2.5.
 
 
 Restricting scalar attributes
@@ -91,7 +91,7 @@ The default is applied to new records:
 Defaults can be procs:
 
     class Song < ActiveRecord::Base
-      assignable_values_for :genre, default: proc { Date.today.year } do
+      assignable_values_for :year, default: proc { Date.today.year } do
         1980 .. 2011
       end
     end
@@ -205,7 +205,7 @@ You can restrict `belongs_to` associations in the same manner as scalar attribut
 
     end
 
-Listing and validating als works the same:
+Listing and validating also works the same:
 
     chicane = Artist.create!(name: 'Chicane', signed: true)
     lt2 = Artist.create!(name: 'LT2', signed: false)
@@ -349,18 +349,21 @@ Development
 
 There are tests in `spec`. We only accept PRs with tests. To run tests:
 
-- Install Ruby 2.1.8
-- Create a local test database `assignable_values_test` in both MySQL and PostgreSQL
-- Copy `spec/support/database.sample.yml` to `spec/support/database.yml` and enter your local credentials for the test database
+- Install Ruby 2.3.8
+- Create a local test database `assignable_values_test` in both MySQL and PostgreSQL (see
+  `.github/workflows/test.yml` for commands to do so)
+- Copy `spec/support/database.sample.yml` to `spec/support/database.yml` and enter your local
+  credentials for the test databases (postgres entry is not required if you are using a socket
+  connection)
 - Install development dependencies using `bundle install`
-- Run tests using `bundle exec current_rspec`
+- Run tests using `bundle exec rake current_rspec`
 
-We recommend to test large changes against multiple versions of Ruby and multiple dependency sets. Supported combinations are configured in `.travis.yml`. We provide some rake tasks to help with this:
+We recommend to test large changes against multiple versions of Ruby and multiple dependency sets. Supported combinations are configured in `.github/workflows/test.yml`. We provide some rake tasks to help with this:
 
 - Install development dependencies using `bundle exec rake matrix:install`
 - Run tests using `bundle exec rake matrix:spec`
 
-Note that we have configured Travis CI to automatically run tests in all supported Ruby versions and dependency sets after each push. We will only merge pull requests after a green Travis build.
+Note that we have configured GitHub Actions to automatically run tests in all supported Ruby versions and dependency sets after each push. We will only merge pull requests after a green GitHub Actions run.
 
 I'm very eager to keep this gem leightweight and on topic. If you're unsure whether a change would make it into the gem, [talk to me beforehand](mailto:henning.koch@makandra.de).
 

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) unless value.nil?
+          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)
@@ -216,10 +236,16 @@ module AssignableValues
         end
 
         def assignable_values_from_record_or_delegate(record)
-          if delegate?
-            assignable_values_from_delegate(record).to_a
+          assignable_values = if delegate?
+            assignable_values_from_delegate(record)
+          else
+            record.instance_exec(&@values)
+          end
+
+          if is_scope?(assignable_values)
+            assignable_values
           else
-            record.instance_exec(&@values).to_a
+            Array(assignable_values)
           end
         end
 

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

@@ -17,8 +17,8 @@ module AssignableValues
           end
         end
 
-        def humanized_assignable_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
@@ -75,8 +75,8 @@ module AssignableValues
           restriction = self
           multiple = @options[:multiple]
           enhance_model do
-            define_method :"humanized_assignable_#{restriction.property.to_s.pluralize}" do
-              restriction.humanized_assignable_values(self)
+            define_method :"humanized_assignable_#{restriction.property.to_s.pluralize}" do |*args|
+              restriction.humanized_assignable_values(self, *args)
             end
 
             unless multiple

data/lib/assignable_values/version.rb

@@ -1,3 +1,3 @@
 module AssignableValues
-  VERSION = '0.16.0'
+  VERSION = '0.16.5'
 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,30 +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 :multi_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 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.humanized_sub_genre('rock').should == 'Rock music'
-        song.humanized_multi_genre('rock').should == 'Rock 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
@@ -51,21 +59,21 @@ describe AssignableValues::ActiveRecord do
 
         before :each do
           @klass = Song.disposable_copy do
-            assignable_values_for :multi_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(:multi_genres => ['pop']).should be_valid
-          @klass.new(:multi_genres => ['pop', 'rock']).should be_valid
-          @klass.new(:multi_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(:multi_genres => nil).should_not be_valid
-          @klass.new(:multi_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
@@ -74,15 +82,15 @@ describe AssignableValues::ActiveRecord do
 
         before :each do
           @klass = Song.disposable_copy do
-            assignable_values_for :multi_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(:multi_genres => nil).should be_valid
-          @klass.new(:multi_genres => []).should be_valid
+          @klass.new(:virtual_multi_genres => nil).should be_valid
+          @klass.new(:virtual_multi_genres => []).should be_valid
         end
 
       end
@@ -99,7 +107,7 @@ describe AssignableValues::ActiveRecord do
               %w[pop rock]
             end
 
-            assignable_values_for :multi_genres, :multiple => true, :allow_blank => true do
+            assignable_values_for :virtual_multi_genres, :multiple => true, :allow_blank => true do
               %w[pop rock]
             end
           end
@@ -166,26 +174,26 @@ describe AssignableValues::ActiveRecord do
         context 'for multiple: true' do
           it 'should raise when trying to humanize a value without an argument' do
             song = @klass.new
-            proc { song.humanized_multi_genre }.should raise_error(ArgumentError)
+            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_multi_genre('rock').should == 'Rock music'
+            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_multi_genre('rock').should == 'Rock music'
+            @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.multi_genres = nil
-            song.humanized_multi_genres.should == nil
-            song.multi_genres = []
-            song.humanized_multi_genres.should == []
-            song.multi_genres = ['pop', 'rock']
-            song.humanized_multi_genres.should == ['Pop music', 'Rock music']
+            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
@@ -280,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
 
@@ -326,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
@@ -444,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)
@@ -506,6 +510,63 @@ describe AssignableValues::ActiveRecord do
         record.valid?
       end
 
+      context 'when assignable values are provided as an ActiveRecord scope' do
+        MyArtist = Artist.disposable_copy
+        let(:klass) { Song.disposable_copy }
+
+        before do
+          klass.class_eval do
+            assignable_values_for :artist do
+              if ::ActiveRecord::VERSION::MAJOR < 4
+                MyArtist.scoped({})
+              else
+                MyArtist.all
+              end
+            end
+          end
+        end
+
+        it 'allows assigning a record from the scope' do
+          artist = MyArtist.create!
+          song = klass.new(:artist => artist)
+          song.should be_valid
+        end
+
+        it 'will not crash during validation when the assigned value is nil' do
+          song = klass.new
+          expect { song.valid? }.to_not raise_error
+          song.errors[:artist_id].should be_present
+        end
+
+        it 'should not load all records into memory' do
+          unless ::ActiveRecord::VERSION::MAJOR < 3 # somehow rails 2 still initializes Objects during the scope.exists?-call
+            initialized_artists_count = 0
+
+            MyArtist.class_eval do
+              after_initialize :increase_initialized_count
+
+              define_method :increase_initialized_count do
+                initialized_artists_count += 1
+              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
+
     end
 
     context 'when delegating using the :through option' do
@@ -726,7 +787,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
@@ -747,15 +808,63 @@ describe AssignableValues::ActiveRecord do
         klass.new.assignable_genres.should == %w[pop rock]
       end
 
+      it 'returns an array when the value block returns a single value' do
+        klass = Song.disposable_copy do
+          assignable_values_for :genre do
+            'techno'
+          end
+        end
+
+        klass.new.assignable_genres.should == ['techno']
+      end
+
+      it 'returns an empty array when the value block returns nothing' do
+        klass = Song.disposable_copy do
+          assignable_values_for :genre do
+            nil
+          end
+        end
+
+        klass.new.assignable_genres.should == []
+      end
+
+      it 'should not return saved value twice (BUGFIX)' do
+        klass = Song.disposable_copy do
+          assignable_values_for :multi_genres, :multiple => true do
+            %w[pop rock]
+          end
+        end
+        record = klass.create!(:multi_genres => ['pop'])
+        record.assignable_multi_genres.should eq ['pop', 'rock']
+      end
+
       it 'should prepend a previously saved value to the top of the list, even if is no longer allowed' do
         klass = Song.disposable_copy 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
@@ -795,10 +904,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