enumerize 2.2.1 → 2.5.0

data/test/mongoid_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 begin
@@ -18,10 +20,16 @@ describe Enumerize do
 
     field :sex
     field :role
+    field :foo
+    field :skill
+
     enumerize :sex,    :in => %w[male female], scope: true
     enumerize :status, :in => %w[notice warning error], scope: true
     enumerize :role,   :in => %w[admin user], :default => 'user', scope: :having_role
     enumerize :mult,   :in => %w[one two three four], :multiple => true
+    enumerize :foo,    :in => %w[bar baz], :skip_validations => true
+    enumerize :skill,  :in => { noob: 0, casual: 1, pro: 2 }, scope: :shallow
+    enumerize :account_type, :in => %w[basic premium], scope: :shallow
   end
 
   before { $VERBOSE = nil }
@@ -32,7 +40,7 @@ describe Enumerize do
   it 'sets nil if invalid value is passed' do
     user = model.new
     user.sex = :invalid
-    user.sex.must_be_nil
+    expect(user.sex).must_be_nil
   end
 
   it 'saves value' do
@@ -40,7 +48,7 @@ describe Enumerize do
     user = model.new
     user.sex = :female
     user.save!
-    user.sex.must_equal 'female'
+    expect(user.sex).must_equal 'female'
   end
 
   it 'loads value' do
@@ -48,13 +56,13 @@ describe Enumerize do
     model.create!(:sex => :male)
     store_translations(:en, :enumerize => {:sex => {:male => 'Male'}}) do
       user = model.first
-      user.sex.must_equal 'male'
-      user.sex_text.must_equal 'Male'
+      expect(user.sex).must_equal 'male'
+      expect(user.sex_text).must_equal 'Male'
     end
   end
 
   it 'has default value' do
-    model.new.role.must_equal 'user'
+    expect(model.new.role).must_equal 'user'
   end
 
   it 'uses after_initialize callback to set default value' do
@@ -62,7 +70,7 @@ describe Enumerize do
     model.create!(sex: 'male', role: nil)
 
     user = model.where(sex: 'male').first
-    user.role.must_equal 'user'
+    expect(user.role).must_equal 'user'
   end
 
   it 'does not set default value for not selected attributes' do
@@ -75,7 +83,21 @@ describe Enumerize do
   it 'validates inclusion' do
     user = model.new
     user.role = 'wrong'
-    user.wont_be :valid?
+    expect(user).wont_be :valid?
+  end
+
+  it 'does not validate inclusion when :skip_validations option passed' do
+    user = model.new
+    user.foo = 'wrong'
+    expect(user).must_be :valid?
+  end
+
+  it 'sets value to enumerized field from db when record is reloaded' do
+    user = model.create!(mult: [:one])
+    model.find(user.id).update(mult: %i[two three])
+    expect(user.mult).must_equal %w[one]
+    user.reload
+    expect(user.mult).must_equal %w[two three]
   end
 
   it 'assigns value on loaded record' do
@@ -83,7 +105,7 @@ describe Enumerize do
     model.create!(:sex => :male)
     user = model.first
     user.sex = :female
-    user.sex.must_equal 'female'
+    expect(user.sex).must_equal 'female'
   end
 
   it 'loads multiple properly' do
@@ -91,25 +113,32 @@ describe Enumerize do
 
     model.create!(:mult => ['one', 'two'])
     user = model.first
-    user.mult.to_a.must_equal ['one', 'two']
+    expect(user.mult.to_a).must_equal ['one', 'two']
   end
 
   it 'adds scope' do
     model.delete_all
 
-    user_1 = model.create!(sex: :male, role: :admin)
-    user_2 = model.create!(sex: :female, role: :user)
+    user_1 = model.create!(sex: :male, skill: :noob, role: :admin, account_type: :basic)
+    user_2 = model.create!(sex: :female, skill: :noob, role: :user, account_type: :basic)
+    user_3 = model.create!(skill: :pro, account_type: :premium)
+
+    expect(model.with_sex(:male).to_a).must_equal [user_1]
+    expect(model.with_sex(:female).to_a).must_equal [user_2]
+    expect(model.with_sex(:male, :female).to_set).must_equal [user_1, user_2].to_set
+
+    expect(model.without_sex(:male).to_set).must_equal [user_2, user_3].to_set
+    expect(model.without_sex(:female).to_set).must_equal [user_1, user_3].to_set
+    expect(model.without_sex(:male, :female).to_a).must_equal [user_3]
 
-    model.with_sex(:male).to_a.must_equal [user_1]
-    model.with_sex(:female).to_a.must_equal [user_2]
-    model.with_sex(:male, :female).to_set.must_equal [user_1, user_2].to_set
+    expect(model.having_role(:admin).to_a).must_equal [user_1]
+    expect(model.having_role(:user).to_a).must_equal [user_2, user_3]
 
-    model.without_sex(:male).to_a.must_equal [user_2]
-    model.without_sex(:female).to_a.must_equal [user_1]
-    model.without_sex(:male, :female).to_a.must_equal []
+    expect(model.pro.to_a).must_equal [user_3]
+    expect(model.premium.to_a).must_equal [user_3]
 
-    model.having_role(:admin).to_a.must_equal [user_1]
-    model.having_role(:user).to_a.must_equal [user_2]
+    expect(model.not_pro.to_set).must_equal [user_1, user_2].to_set
+    expect(model.not_premium.to_set).must_equal [user_1, user_2].to_set
   end
 
   it 'chains scopes' do
@@ -119,14 +148,14 @@ describe Enumerize do
     user_2 = model.create!(status: :warning)
     user_3 = model.create!(status: :error)
 
-    model.with_status(:notice, :warning).with_status(:notice, :error).to_a.must_equal [user_1]
-    model.with_status(:notice, :warning).union.with_status(:notice, :error).to_a.must_equal [user_1, user_2, user_3]
+    expect(model.with_status(:notice, :warning).with_status(:notice, :error).to_a).must_equal [user_1]
+    expect(model.with_status(:notice, :warning).union.with_status(:notice, :error).to_a).must_equal [user_1, user_2, user_3]
   end
 
   it 'ignores not enumerized values that passed to the scope method' do
     model.delete_all
 
-    model.with_sex(:foo).must_equal []
+    expect(model.with_sex(:foo)).must_equal []
   end
 end
 

data/test/multiple_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 describe Enumerize::Base do
@@ -15,38 +17,38 @@ describe Enumerize::Base do
 
   it 'returns [] when not set' do
     kklass.enumerize :foos, in: %w(a b), multiple: true
-    object.foos.must_equal []
+    expect(object.foos).must_equal []
   end
 
   it 'returns setted array' do
     kklass.enumerize :foos, in: %w(a b c), multiple: true
     object.foos = %w(a c)
-    object.foos.must_equal %w(a c)
+    expect(object.foos).must_equal %w(a c)
   end
 
   it 'sets default value as single value' do
     kklass.enumerize :foos, in: %w(a b c), default: 'b', multiple: true
-    object.foos.must_equal %w(b)
+    expect(object.foos).must_equal %w(b)
   end
 
   it 'sets default value as array of one element' do
     kklass.enumerize :foos, in: %w(a b c), default: %w(b), multiple: true
-    object.foos.must_equal %w(b)
+    expect(object.foos).must_equal %w(b)
   end
 
   it 'sets default value as array of several elements' do
     kklass.enumerize :foos, in: %w(a b c), default: %w(b c), multiple: true
-    object.foos.must_equal %w(b c)
+    expect(object.foos).must_equal %w(b c)
   end
 
   it "doesn't define _text method" do
     kklass.enumerize :foos, in: %w(a b c), multiple: true
-    object.wont_respond_to :foos_text
+    expect(object).wont_respond_to :foos_text
   end
 
   it "doesn't define _value method" do
     kklass.enumerize :foos, in: %w(a b c), multiple: true
-    object.wont_respond_to :foos_value
+    expect(object).wont_respond_to :foos_value
   end
 
   it "cannot define multiple with scope" do
@@ -54,4 +56,10 @@ describe Enumerize::Base do
       kklass.enumerize :foos, in: %w(a b c), multiple: true, scope: true
     end
   end
+
+  it 'assign a name with the first letter capitalized' do
+    kklass.enumerize :Foos, in: %w(a b c), multiple: true
+    object.Foos = %w(a c)
+    expect(object.Foos).must_equal %w(a c)
+  end
 end

data/test/predicates_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 describe Enumerize::Predicates do
@@ -11,53 +13,53 @@ describe Enumerize::Predicates do
 
   it 'creates predicate methods' do
     kklass.enumerize(:foo, in: %w(a b), predicates: true)
-    object.must_respond_to :a?
-    object.must_respond_to :b?
+    expect(object).must_respond_to :a?
+    expect(object).must_respond_to :b?
   end
 
   it 'creates predicate methods when enumerized values have dash in it' do
     kklass.enumerize(:foo, in: %w(foo-bar bar-foo), predicates: true)
-    object.must_respond_to :foo_bar?
-    object.must_respond_to :bar_foo?
+    expect(object).must_respond_to :foo_bar?
+    expect(object).must_respond_to :bar_foo?
   end
 
   it 'creates predicate methods on multiple attribute' do
     kklass.enumerize(:foo, in: %w(a b), predicates: true, multiple: true)
-    object.must_respond_to :a?
-    object.must_respond_to :b?
+    expect(object).must_respond_to :a?
+    expect(object).must_respond_to :b?
   end
 
   it 'checks values' do
     kklass.enumerize(:foo, in: %w(a b), predicates: true)
     object.foo = 'a'
-    object.a?.must_equal true
-    object.b?.must_equal false
+    expect(object.a?).must_equal true
+    expect(object.b?).must_equal false
   end
 
   it 'checks values on multiple attribute' do
     kklass.enumerize(:foo, in: %w(a b), predicates: true, multiple: true)
     object.foo << :a
-    object.a?.must_equal true
-    object.b?.must_equal false
+    expect(object.a?).must_equal true
+    expect(object.b?).must_equal false
   end
 
   it 'prefixes methods' do
     kklass.enumerize(:foo, in: %w(a b), predicates: { prefix: 'bar' })
-    object.wont_respond_to :a?
-    object.wont_respond_to :b?
-    object.must_respond_to :bar_a?
-    object.must_respond_to :bar_b?
+    expect(object).wont_respond_to :a?
+    expect(object).wont_respond_to :b?
+    expect(object).must_respond_to :bar_a?
+    expect(object).must_respond_to :bar_b?
   end
 
   it 'accepts only option' do
     kklass.enumerize(:foo, in: %w(a b), predicates: { only: :a })
-    object.must_respond_to :a?
-    object.wont_respond_to :b?
+    expect(object).must_respond_to :a?
+    expect(object).wont_respond_to :b?
   end
 
   it 'accepts except option' do
     kklass.enumerize(:foo, in: %w(a b), predicates: { except: :a })
-    object.wont_respond_to :a?
-    object.must_respond_to :b?
+    expect(object).wont_respond_to :a?
+    expect(object).must_respond_to :b?
   end
 end

data/test/rails_admin_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class RailsAdminSpec < MiniTest::Spec
@@ -12,14 +14,14 @@ class RailsAdminSpec < MiniTest::Spec
   it 'defines enum method' do
     store_translations(:en, :enumerize => {:foo => {:a => 'a text', :b => 'b text'}}) do
       kklass.enumerize(:foo, in: [:a, :b])
-      object.foo_enum.must_equal [['a text', 'a'], ['b text', 'b']]
+      expect(object.foo_enum).must_equal [['a text', 'a'], ['b text', 'b']]
     end
   end
 
   it 'defines enum properly for custom values enumerations' do
     store_translations(:en, :enumerize => {:foo => {:a => 'a text', :b => 'b text'}}) do
       kklass.enumerize(:foo, in: {:a => 1, :b => 2})
-      object.foo_enum.must_equal [['a text', 'a'], ['b text', 'b']]
+      expect(object.foo_enum).must_equal [['a text', 'a'], ['b text', 'b']]
     end
   end
 end

data/test/sequel_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 require 'sequel'
 require 'logger'
@@ -21,7 +23,9 @@ module SequelTest
     String :name
     String :interests
     String :status
+    Integer :skill
     String :account_type, default: "basic"
+    String :foo
   end
 
   DB.create_table :documents do
@@ -50,12 +54,14 @@ module SequelTest
     plugin :enumerize
     include RoleEnum
 
-    enumerize :sex, :in => [:male, :female]
+    enumerize :sex, :in => [:male, :female], scope: :shallow
 
     enumerize :interests, :in => [:music, :sports, :dancing, :programming], :multiple => true
 
     enumerize :status, :in => { active: 1, blocked: 2 }, scope: true
 
+    enumerize :skill, :in => { noob: 0, casual: 1, pro: 2 }, scope: :shallow
+
     enumerize :account_type, :in => [:basic, :premium]
   end
 
@@ -67,11 +73,27 @@ module SequelTest
     end
   end
 
+  class SkipValidationsUser < Sequel::Model(:users)
+    include SkipValidationsEnum
+  end
+
+  class DoNotSkipValidationsUser < Sequel::Model(:users)
+    include DoNotSkipValidationsEnum
+  end
+
+  class SkipValidationsLambdaUser < Sequel::Model(:users)
+    include SkipValidationsLambdaEnum
+  end
+
+  class SkipValidationsLambdaWithParamUser < Sequel::Model(:users)
+    include SkipValidationsLambdaWithParamEnum
+  end
+
   describe Enumerize::SequelSupport do
     it 'sets nil if invalid value is passed' do
       user = User.new
       user.sex = :invalid
-      user.sex.must_be_nil
+      expect(user.sex).must_be_nil
     end
 
     it 'saves value' do
@@ -79,7 +101,7 @@ module SequelTest
       user = User.new
       user.sex = :female
       user.save
-      user.sex.must_equal 'female'
+      expect(user.sex).must_equal 'female'
     end
 
     it 'loads value' do
@@ -87,14 +109,14 @@ module SequelTest
       User.create(:sex => :male)
       store_translations(:en, :enumerize => {:sex => {:male => 'Male'}}) do
         user = User.first
-        user.sex.must_equal 'male'
-        user.sex_text.must_equal 'Male'
+        expect(user.sex).must_equal 'male'
+        expect(user.sex_text).must_equal 'Male'
       end
     end
 
     it 'has default value' do
-      User.new.role.must_equal 'user'
-      User.new.values[:role].must_equal 'user'
+      expect(User.new.role).must_equal 'user'
+      expect(User.new.values[:role]).must_equal 'user'
     end
 
     it 'does not set default value for not selected attributes' do
@@ -105,26 +127,26 @@ module SequelTest
     end
 
     it 'has default value with lambda' do
-      User.new.lambda_role.must_equal 'admin'
-      User.new.values[:lambda_role].must_equal 'admin'
+      expect(User.new.lambda_role).must_equal 'admin'
+      expect(User.new.values[:lambda_role]).must_equal 'admin'
     end
     it 'uses after_initialize callback to set default value' do
       User.filter{ true }.delete
       User.create(sex: 'male', lambda_role: nil)
 
       user = User.where(:sex => 'male').first
-      user.lambda_role.must_equal 'admin'
+      expect(user.lambda_role).must_equal 'admin'
     end
 
     it 'uses default value from db column' do
-      User.new.account_type.must_equal 'basic'
+      expect(User.new.account_type).must_equal 'basic'
     end
 
     it 'validates inclusion' do
       user = User.new
       user.role = 'wrong'
-      user.wont_be :valid?
-      user.errors[:role].must_include 'is not included in the list'
+      expect(user).wont_be :valid?
+      expect(user.errors[:role]).must_include 'is not included in the list'
     end
 
     it 'validates inclusion on mass assignment' do
@@ -135,41 +157,66 @@ module SequelTest
 
     it "uses persisted value for validation if it hasn't been set" do
       user = User.create :sex => :male
-      User[user.id].read_attribute_for_validation(:sex).must_equal 'male'
+      expect(User[user.id].read_attribute_for_validation(:sex)).must_equal 'male'
     end
 
     it 'is valid with empty string assigned' do
       user = User.new
       user.role = ''
-      user.must_be :valid?
+      expect(user).must_be :valid?
     end
 
     it 'stores nil when empty string assigned' do
       user = User.new
       user.role = ''
-      user.values[:role].must_be_nil
+      expect(user.values[:role]).must_be_nil
+    end
+
+    it 'validates inclusion when :skip_validations = false' do
+      user = DoNotSkipValidationsUser.new
+      user.foo = 'wrong'
+      expect(user).wont_be :valid?
+      expect(user.errors[:foo]).must_include 'is not included in the list'
+    end
+
+    it 'does not validate inclusion when :skip_validations = true' do
+      user = SkipValidationsUser.new
+      user.foo = 'wrong'
+      expect(user).must_be :valid?
+    end
+
+    it 'supports :skip_validations option as lambda' do
+      user = SkipValidationsLambdaUser.new
+      user.foo = 'wrong'
+      expect(user).must_be :valid?
+    end
+
+    it 'supports :skip_validations option as lambda with a parameter' do
+      user = SkipValidationsLambdaWithParamUser.new
+      user.foo = 'wrong'
+      expect(user).must_be :valid?
     end
 
     it 'supports multiple attributes' do
       user = User.new
       user.interests ||= []
-      user.interests.must_be_empty
+      expect(user.interests).must_be_empty
       user.interests << "music"
-      user.interests.must_equal %w(music)
+      expect(user.interests).must_equal %w(music)
       user.save
 
       user = User[user.id]
-      user.interests.must_be_instance_of Enumerize::Set
-      user.interests.must_equal %w(music)
+      expect(user.interests).must_be_instance_of Enumerize::Set
+      expect(user.interests).must_equal %w(music)
       user.interests << "sports"
-      user.interests.must_equal %w(music sports)
+      expect(user.interests).must_equal %w(music sports)
 
       user.interests = []
       interests = user.interests
       interests << "music"
-      interests.must_equal %w(music)
+      expect(interests).must_equal %w(music)
       interests << "dancing"
-      interests.must_equal %w(music dancing)
+      expect(interests).must_equal %w(music dancing)
     end
 
     it 'returns invalid multiple value for validation' do
@@ -177,19 +224,19 @@ module SequelTest
       user.interests << :music
       user.interests << :invalid
       values = user.read_attribute_for_validation(:interests)
-      values.must_equal %w(music invalid)
+      expect(values).must_equal %w(music invalid)
     end
 
     it 'validates multiple attributes' do
       user = User.new
       user.interests << :invalid
-      user.wont_be :valid?
+      expect(user).wont_be :valid?
 
       user.interests = Object.new
-      user.wont_be :valid?
+      expect(user).wont_be :valid?
 
       user.interests = ['music', '']
-      user.must_be :valid?
+      expect(user).must_be :valid?
     end
 
     it 'stores custom values for multiple attributes' do
@@ -200,27 +247,33 @@ module SequelTest
 
       user = klass.new
       user.interests << :music
-      user.interests.must_equal %w(music)
+      expect(user.interests).must_equal %w(music)
       user.save
 
       user = klass[user.id]
-      user.interests.must_equal %w(music)
+      expect(user.interests).must_equal %w(music)
     end
 
     it 'adds scope' do
       User.filter{ true }.delete
 
-      user_1 = User.create(status: :active, role: :admin)
-      user_2 = User.create(status: :blocked)
+      user_1 = User.create(sex: :female, skill: :noob, status: :active, role: :admin)
+      user_2 = User.create(sex: :female, skill: :casual, status: :blocked)
+      user_3 = User.create(sex: :male, skill: :pro)
+
+      expect(User.with_status(:active).to_a).must_equal [user_1]
+      expect(User.with_status(:blocked).to_a).must_equal [user_2]
+      expect(User.with_status(:active, :blocked).to_set).must_equal [user_1, user_2].to_set
 
-      User.with_status(:active).to_a.must_equal [user_1]
-      User.with_status(:blocked).to_a.must_equal [user_2]
-      User.with_status(:active, :blocked).to_set.must_equal [user_1, user_2].to_set
+      expect(User.without_status(:active).to_a).must_equal [user_2]
+      expect(User.without_status(:active, :blocked).to_a).must_equal []
 
-      User.without_status(:active).to_a.must_equal [user_2]
-      User.without_status(:active, :blocked).to_a.must_equal []
+      expect(User.having_role(:admin).to_a).must_equal [user_1]
+      expect(User.male.to_a).must_equal [user_3]
+      expect(User.pro.to_a).must_equal [user_3]
 
-      User.having_role(:admin).to_a.must_equal [user_1]
+      expect(User.not_male.to_set).must_equal [user_1, user_2].to_set
+      expect(User.not_pro.to_set).must_equal [user_1, user_2].to_set
     end
 
     it 'allows either key or value as valid' do
@@ -228,13 +281,13 @@ module SequelTest
       user_2 = User.new(status: 1)
       user_3 = User.new(status: '1')
 
-      user_1.status.must_equal 'active'
-      user_2.status.must_equal 'active'
-      user_3.status.must_equal 'active'
+      expect(user_1.status).must_equal 'active'
+      expect(user_2.status).must_equal 'active'
+      expect(user_3.status).must_equal 'active'
 
-      user_1.must_be :valid?
-      user_2.must_be :valid?
-      user_3.must_be :valid?
+      expect(user_1).must_be :valid?
+      expect(user_2).must_be :valid?
+      expect(user_3).must_be :valid?
     end
 
     it 'supports defining enumerized attributes on abstract class' do
@@ -242,7 +295,7 @@ module SequelTest
 
       document = Document.new
       document.visibility = :protected
-      document.visibility.must_equal 'protected'
+      expect(document.visibility).must_equal 'protected'
     end
 
     it 'supports defining enumerized scopes on abstract class' do
@@ -251,7 +304,7 @@ module SequelTest
       document_1 = Document.create(visibility: :public)
       document_2 = Document.create(visibility: :private)
 
-      Document.with_visibility(:public).to_a.must_equal [document_1]
+      expect(Document.with_visibility(:public).to_a).must_equal [document_1]
     end
 
     it 'validates uniqueness' do
@@ -260,9 +313,9 @@ module SequelTest
       user = UniqStatusUser.new
       user.sex = "male"
       user.status = :active
-      user.valid?.must_equal false
+      expect(user.valid?).must_equal false
 
-      user.errors[:status].wont_be :empty?
+      expect(user.errors[:status]).wont_be :empty?
     end
 
     it "doesn't update record" do