enumerate_it 1.2.9 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5eea658aa82d9e739fafd57e5ce7f36aba85ec4e
-  data.tar.gz: f82979bf4a625cea197e51e08e18218b9a513a41
+  metadata.gz: eeb5e0de6df61f17293c7d0c7b5d833c5d3738b3
+  data.tar.gz: 31978fd7c1d78bbcf499ecf4c6d66f3101add5a1
 SHA512:
-  metadata.gz: 0fa1e1833a65794f76d022a9bc2a7398e193c08079c38abc8fb2ca5353ee036e511791d3a87557d5ff38cb4529e18fc71ab2ec5cc1c69ed3c6bf9fd1fc6696db
-  data.tar.gz: 98bf568bb99f96ad7e18a0488b532215f3ea19efc7493ce9be98c373282f4428911841212344e5cf7e80ab1809fb513c6ff120198ff348e7158fe84a5f8dbe1b
+  metadata.gz: 910befeeabdbd3647ca2b1c7c9115cee8e8bd927fd938dac4704a03a6b0cf077524e17a604edf2fb31d5493b6d4aec6819cfbec0e46b51d16a633b0974903af2
+  data.tar.gz: cf9b34ec103040023ac449a9fecffad45a3bca529f3ae041683838fbd25f23f48cce1dda40c5aeae9ccddc7388aa3a9058353b1e985d533a339b09a12105854e

data/.gitignore

@@ -1,3 +1,4 @@
 /.bundle/
 /pkg/
 /gemfiles/*.lock
+.ruby-gemset

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.3.1

data/.travis.yml

@@ -9,7 +9,7 @@ rvm:
   - 2.0.0
   - 2.1.5
   - 2.2.1
-  - 2.3.0
+  - 2.3.1
 
 gemfile:
   - gemfiles/activesupport_3_0.gemfile

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    enumerate_it (1.2.9)
+    enumerate_it (1.3.0)
       activesupport (>= 3.0.0)
 
 GEM
@@ -17,30 +17,48 @@ GEM
       bundler
       rake
       thor (>= 0.14.0)
+    ast (2.2.0)
     coderay (1.0.9)
     diff-lcs (1.2.5)
     i18n (0.7.0)
     json (1.8.3)
     method_source (0.8.1)
     minitest (5.8.4)
+    parser (2.3.0.7)
+      ast (~> 2.2)
+    powerpack (0.1.1)
     pry (0.9.12)
       coderay (~> 1.0.5)
       method_source (~> 0.8)
       slop (~> 3.4)
+    rainbow (2.1.0)
     rake (11.1.1)
-    rspec (2.14.1)
-      rspec-core (~> 2.14.0)
-      rspec-expectations (~> 2.14.0)
-      rspec-mocks (~> 2.14.0)
-    rspec-core (2.14.8)
-    rspec-expectations (2.14.5)
-      diff-lcs (>= 1.1.3, < 2.0)
-    rspec-mocks (2.14.6)
+    rspec (3.4.0)
+      rspec-core (~> 3.4.0)
+      rspec-expectations (~> 3.4.0)
+      rspec-mocks (~> 3.4.0)
+    rspec-core (3.4.1)
+      rspec-support (~> 3.4.0)
+    rspec-expectations (3.4.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-mocks (3.4.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-support (3.4.1)
+    rubocop (0.38.0)
+      parser (>= 2.3.0.6, < 3.0)
+      powerpack (~> 0.1)
+      rainbow (>= 1.99.1, < 3.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (~> 1.0, >= 1.0.1)
+    ruby-progressbar (1.7.5)
     slop (3.4.4)
     thor (0.19.1)
     thread_safe (0.3.5)
     tzinfo (1.2.2)
       thread_safe (~> 0.1)
+    unicode-display_width (1.0.2)
 
 PLATFORMS
   ruby
@@ -50,7 +68,8 @@ DEPENDENCIES
   enumerate_it!
   pry
   rake
-  rspec (~> 2.14.1)
+  rspec
+  rubocop
 
 BUNDLED WITH
    1.11.2

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009 Cássio Marques
+Copyright (c) 2010-2016 Cássio Marques and Lucas Caton
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -172,9 +172,9 @@ You can also create enumerations in the following ways:
 
 ### Defining a default sort mode
 
-When calling methods like `to_a` and `to_json`, the returned values will be
-sorted using the translation for each one of the enumeration values. If you
-want to overwrite the default sort mode, you can use the `sort_by` class
+When calling methods like `to_a`, `to_json` and `list`, the returned values
+will be sorted using the translation for each one of the enumeration values.
+If you want to overwrite the default sort mode, you can use the `sort_by` class
 method.
 
 ```ruby
@@ -405,6 +405,18 @@ This will create:
     #=> "can't be blank"
     ```
 
+* If you pass the `:skip_validation` option as `true`, it will not create any validations:
+
+    ```ruby
+    class Person < ActiveRecord::Base
+      has_enumeration_for :relationship_status, with: RelationshipStatus, skip_validation: true
+    end
+
+    p = Person.new(relationship_status: 1_000_000)
+    p.valid?
+    #=> true
+    ```
+
 Remember that you can add validations to any kind of class and not only to
 those derived from ActiveRecord::Base.
 
@@ -482,7 +494,7 @@ their locale files. Take a look at how to use it running:
 rails generate enumerate_it:enum --help
 ```
 
-## Supported versions
+## Supported Ruby and Rails (ActiveSupport) versions
 
 Check [travis config file](https://github.com/lucascaton/enumerate_it/blob/master/.travis.yml).
 

data/enumerate_it.gemspec

@@ -6,7 +6,6 @@ Gem::Specification.new do |gem|
   gem.summary       = 'Ruby Enumerations'
   gem.homepage      = 'https://github.com/lucascaton/enumerate_it'
 
-  gem.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
   gem.files         = `git ls-files`.split("\n")
   gem.test_files    = `git ls-files -- spec/*`.split("\n")
   gem.name          = 'enumerate_it'
@@ -18,5 +17,6 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency 'appraisal'
   gem.add_development_dependency 'pry'
   gem.add_development_dependency 'rake'
-  gem.add_development_dependency 'rspec', '~> 2.14.1'
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'rubocop'
 end

data/lib/enumerate_it/base.rb

@@ -27,7 +27,7 @@ module EnumerateIt
     end
 
     def self.to_a
-      sorted_map.map { |k, v| [translate(v[1]), v[0]] }
+      sorted_map.map { |_k, v| [translate(v[1]), v[0]] }
     end
 
     def self.length
@@ -47,7 +47,7 @@ module EnumerateIt
     end
 
     def self.to_json
-      sorted_map.map { |k, v| { :value => v[0], :label => translate(v[1]) } }.to_json
+      sorted_map.map { |_k, v| { value: v[0], label: translate(v[1]) } }.to_json
     end
 
     def self.t(value)
@@ -75,7 +75,7 @@ module EnumerateIt
     end
 
     def self.key_for(value)
-      enumeration.map {|e| e[0] if e[1][0] == value }.compact.first
+      enumeration.map { |e| e[0] if e[1][0] == value }.compact.first
     end
 
     def self.to_range
@@ -92,9 +92,9 @@ module EnumerateIt
 
     def self.sort_lambda
       {
-        :value       => lambda { |k, v| v[0] },
-        :name        => lambda { |k, v| k },
-        :translation => lambda { |k, v| translate(v[1]) },
+        value:       lambda { |_k, v| v[0] },
+        name:        lambda { |k, _v| k },
+        translation: lambda { |_k, v| translate(v[1]) }
       }[sort_mode || :translation]
     end
 
@@ -102,14 +102,12 @@ module EnumerateIt
       return value unless value.is_a? Symbol
 
       default = value.to_s.gsub(/_/, ' ').split.map(&:capitalize).join(' ')
-      I18n.t("enumerations.#{self.name.underscore}.#{value.to_s.underscore}", :default => default)
+      I18n.t("enumerations.#{self.name.underscore}.#{value.to_s.underscore}", default: default)
     end
 
     def self.normalize_enumeration(values_hash)
       values_hash.each_pair do |key, value|
-        unless value.is_a? Array
-          values_hash[key] = [value, key]
-        end
+        values_hash[key] = [value, key] unless value.is_a? Array
       end
     end
 

data/lib/enumerate_it/class_methods.rb

@@ -5,10 +5,13 @@ module EnumerateIt
       self.enumerations = self.enumerations.dup
 
       define_enumeration_class attribute, options
-      set_validations attribute, options
       create_enumeration_humanize_method options[:with], attribute
       store_enumeration options[:with], attribute
 
+      unless options[:skip_validation]
+        set_validations attribute, options
+      end
+
       if options[:create_helpers]
         create_helper_methods options[:with], attribute, options[:create_helpers]
         create_mutator_methods options[:with], attribute, options[:create_helpers]
@@ -21,6 +24,7 @@ module EnumerateIt
     end
 
     private
+
     def store_enumeration(klass, attribute)
       enumerations[attribute] = klass
     end
@@ -52,7 +56,7 @@ module EnumerateIt
 
       klass.enumeration.keys.each do |key|
         if respond_to? :scope
-          scope "#{prefix_name}#{key}", lambda { where(attribute_name => klass.enumeration[key].first)}
+          scope "#{prefix_name}#{key}", lambda { where(attribute_name => klass.enumeration[key].first) }
         end
       end
     end
@@ -92,7 +96,7 @@ module EnumerateIt
     end
 
     def set_validations(attribute, options)
-      validates_inclusion_of(attribute, :in => options[:with].list, :allow_blank => true) if self.respond_to?(:validates_inclusion_of)
+      validates_inclusion_of(attribute, in: options[:with].list, allow_blank: true) if self.respond_to?(:validates_inclusion_of)
 
       if options[:required] && respond_to?(:validates_presence_of)
         opts = options[:required].is_a?(Hash) ? options[:required] : {}

data/lib/enumerate_it/version.rb

@@ -1,3 +1,3 @@
 module EnumerateIt
-  VERSION = '1.2.9'
+  VERSION = '1.3.0'
 end

data/lib/generators/enumerate_it/enum/enum_generator.rb

@@ -3,11 +3,11 @@ module EnumerateIt
     class EnumGenerator < Rails::Generators::NamedBase
       source_root File.expand_path('../templates', __FILE__)
 
-      argument :attributes, :type => 'array', :default => []
+      argument :attributes, type: 'array', default: []
 
-      class_option :singular, :type => 'string', :desc => 'Singular name for i18n'
+      class_option :singular, type: 'string', desc: 'Singular name for i18n'
 
-      class_option :lang, :type => 'string', :desc => 'Lang to use in i18n', :default => 'en'
+      class_option :lang, type: 'string', desc: 'Lang to use in i18n', default: 'en'
 
       desc "Creates a locale file on config/locales"
       def create_locale

data/spec/enumerate_it/base_spec.rb

@@ -1,24 +1,25 @@
 # encoding: utf-8
+
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 describe EnumerateIt::Base do
   it "creates constants for each enumeration value" do
     [TestEnumeration::VALUE_1, TestEnumeration::VALUE_2, TestEnumeration::VALUE_3].each_with_index do |constant, idx|
-      constant.should == (idx + 1).to_s
+      expect(constant).to eq((idx + 1).to_s)
     end
   end
 
   it "creates constants for camel case values" do
-    TestEnumerationWithCamelCase::IPHONE.should == 'iPhone'
+    expect(TestEnumerationWithCamelCase::IPHONE).to eq('iPhone')
   end
 
   it "creates constants replacing its dashes with underscores" do
-    TestEnumerationWithDash::PT_BR.should == 'pt-BR'
+    expect(TestEnumerationWithDash::PT_BR).to eq('pt-BR')
   end
 
   describe ".list" do
     it "creates a method that returns the allowed values in the enumeration's class" do
-      TestEnumeration.list.should == ['1', '2', '3']
+      expect(TestEnumeration.list).to eq(['1', '2', '3'])
     end
 
     context "specifying a default sort mode" do
@@ -27,40 +28,40 @@ describe EnumerateIt::Base do
       context "by value" do
         let(:sort_mode) { :value }
 
-        it { should == %w(0 1 2 3) }
+        it { should eq(%w(0 1 2 3)) }
       end
 
       context "by name" do
         let(:sort_mode) { :name }
 
-        it { should == %w(2 1 3 0) }
+        it { should eq(%w(2 1 3 0)) }
       end
 
       context "by translation" do
         let(:sort_mode) { :translation }
 
-        it { should == %w(3 2 0 1) }
+        it { should eq(%w(3 2 0 1)) }
       end
 
       context "by nothing" do
         let(:sort_mode) { :none }
 
-        it { should == %w(1 2 3 0) }
+        it { should eq(%w(1 2 3 0)) }
       end
     end
  end
 
   it "creates a method that returns the enumeration specification" do
-    TestEnumeration.enumeration.should == {
-      :value_1 => ['1', 'Hey, I am 1!'],
-      :value_2 => ['2', 'Hey, I am 2!'],
-      :value_3 => ['3', 'Hey, I am 3!']
-    }
+    expect(TestEnumeration.enumeration).to eq(
+      value_1: ['1', 'Hey, I am 1!'],
+      value_2: ['2', 'Hey, I am 2!'],
+      value_3: ['3', 'Hey, I am 3!']
+    )
   end
 
   describe ".length" do
     it "returns the length of the enumeration" do
-      TestEnumeration.length.should == 3
+      expect(TestEnumeration.length).to eq(3)
     end
   end
 
@@ -70,13 +71,13 @@ describe EnumerateIt::Base do
       TestEnumeration.each_translation do |translation|
         translations << translation
       end
-      translations.should == ["Hey, I am 1!", "Hey, I am 2!", "Hey, I am 3!"]
+      expect(translations).to eq(["Hey, I am 1!", "Hey, I am 2!", "Hey, I am 3!"])
     end
   end
 
   describe ".translations" do
     it "returns all translations" do
-      TestEnumeration.translations.should == ["Hey, I am 1!", "Hey, I am 2!", "Hey, I am 3!"]
+      expect(TestEnumeration.translations).to eq(["Hey, I am 1!", "Hey, I am 2!", "Hey, I am 3!"])
     end
   end
 
@@ -86,115 +87,116 @@ describe EnumerateIt::Base do
       TestEnumeration.each_value do |value|
         values << value
       end
-      values.should == TestEnumeration.list
+      expect(values).to eq(TestEnumeration.list)
     end
   end
 
   describe ".to_a" do
     it "returns an array with the values and human representations" do
-      TestEnumeration.to_a.should == [['Hey, I am 1!', '1'], ['Hey, I am 2!', '2'], ['Hey, I am 3!', '3']]
+      expect(TestEnumeration.to_a).to eq([['Hey, I am 1!', '1'], ['Hey, I am 2!', '2'], ['Hey, I am 3!', '3']])
     end
 
     it "translates the available values" do
-      TestEnumerationWithoutArray.to_a.should == [['First Value', '1'], ['Value Two', '2']]
+      I18n.locale = :en
+      expect(TestEnumerationWithoutArray.to_a).to eq([['First Value', '1'], ['Value Two', '2']])
       I18n.locale = :pt
-      TestEnumerationWithoutArray.to_a.should == [['Primeiro Valor', '1'], ['Value Two', '2']]
+      expect(TestEnumerationWithoutArray.to_a).to eq([['Primeiro Valor', '1'], ['Value Two', '2']])
     end
 
     it "can be extended from the enumeration class" do
-      TestEnumerationWithExtendedBehaviour.to_a.should == [['Second', '2'],['First','1']]
+      expect(TestEnumerationWithExtendedBehaviour.to_a).to eq([['Second', '2'],['First','1']])
     end
   end
 
   describe ".to_json" do
     it "gives a valid json back" do
       I18n.locale = :inexsistent
-      TestEnumerationWithoutArray.to_json.should == '[{"value":"1","label":"Value One"},{"value":"2","label":"Value Two"}]'
+      expect(TestEnumerationWithoutArray.to_json).to eq('[{"value":"1","label":"Value One"},{"value":"2","label":"Value Two"}]')
     end
 
     it "give translated values when available" do
       I18n.locale = :pt
-      TestEnumerationWithoutArray.to_json.should == '[{"value":"1","label":"Primeiro Valor"},{"value":"2","label":"Value Two"}]'
+      expect(TestEnumerationWithoutArray.to_json).to eq('[{"value":"1","label":"Primeiro Valor"},{"value":"2","label":"Value Two"}]')
     end
   end
 
   describe ".t" do
     it "translates a given value" do
       I18n.locale = :pt
-      TestEnumerationWithoutArray.t('1').should == 'Primeiro Valor'
+      expect(TestEnumerationWithoutArray.t('1')).to eq('Primeiro Valor')
     end
   end
 
   describe ".to_range" do
     it "returns a Range object containing the enumeration's value interval" do
-      TestEnumeration.to_range.should == ("1".."3")
+      expect(TestEnumeration.to_range).to eq("1".."3")
     end
   end
 
   describe ".values_for" do
     it "returns an array with the corresponding values for a string array representing some of the enumeration's values" do
-      TestEnumeration.values_for(%w(VALUE_1 VALUE_2)).should == [TestEnumeration::VALUE_1, TestEnumeration::VALUE_2]
+      expect(TestEnumeration.values_for(%w(VALUE_1 VALUE_2))).to eq([TestEnumeration::VALUE_1, TestEnumeration::VALUE_2])
     end
 
     it "returns a nil value if the a constant named after one of the given strings cannot be found" do
-      TestEnumeration.values_for(%w(VALUE_1 THIS_IS_WRONG)).should == [TestEnumeration::VALUE_1, nil]
+      expect(TestEnumeration.values_for(%w(VALUE_1 THIS_IS_WRONG))).to eq([TestEnumeration::VALUE_1, nil])
     end
   end
 
   describe ".value_for" do
     it "returns the enumeration's value" do
-      TestEnumeration.value_for("VALUE_1").should == TestEnumeration::VALUE_1
+      expect(TestEnumeration.value_for("VALUE_1")).to eq(TestEnumeration::VALUE_1)
     end
 
     context "when a constant named after the received value cannot be found" do
       it "returns nil" do
-        TestEnumeration.value_for("THIS_IS_WRONG").should be_nil
+        expect(TestEnumeration.value_for("THIS_IS_WRONG")).to be_nil
       end
     end
   end
 
   describe ".value_from_key" do
     it "returns the correct value when the key is a string" do
-      TestEnumeration.value_from_key("value_1").should == TestEnumeration::VALUE_1
+      expect(TestEnumeration.value_from_key("value_1")).to eq(TestEnumeration::VALUE_1)
     end
 
     it "returns the correct value when the key is a symbol" do
-      TestEnumeration.value_from_key(:value_1).should == TestEnumeration::VALUE_1
+      expect(TestEnumeration.value_from_key(:value_1)).to eq(TestEnumeration::VALUE_1)
     end
 
     it "returns nil when the key does not exist in the enumeration" do
-      TestEnumeration.value_from_key("wrong").should be_nil
+      expect(TestEnumeration.value_from_key("wrong")).to be_nil
     end
 
     it "returns nil when the given value is nil" do
-      TestEnumeration.value_from_key(nil).should be_nil
+      expect(TestEnumeration.value_from_key(nil)).to be_nil
     end
   end
 
   describe ".keys" do
     it "returns a list with the keys used to define the enumeration" do
-      TestEnumeration.keys.should == [:value_1, :value_2, :value_3]
+      expect(TestEnumeration.keys).to eq([:value_1, :value_2, :value_3])
     end
   end
 
   describe ".key_for" do
     it "returns the key for the given value inside the enumeration" do
-      TestEnumeration.key_for(TestEnumeration::VALUE_1).should == :value_1
+      expect(TestEnumeration.key_for(TestEnumeration::VALUE_1)).to eq(:value_1)
     end
 
     it "returns nil if the enumeration does not have the given value" do
-      TestEnumeration.key_for("foo").should be_nil
+      expect(TestEnumeration.key_for("foo")).to be_nil
     end
   end
 
   context 'associate values with a list' do
     it "creates constants for each enumeration value" do
-      TestEnumerationWithList::FIRST.should == "first"
-      TestEnumerationWithList::SECOND.should == "second"
+      expect(TestEnumerationWithList::FIRST).to eq("first")
+      expect(TestEnumerationWithList::SECOND).to eq("second")
     end
 
     it "returns an array with the values and human representations" do
-      TestEnumerationWithList.to_a.should == [['First', 'first'], ['Second', 'second']]
+      expect(TestEnumerationWithList.to_a).to eq([['First', 'first'], ['Second', 'second']])
     end
   end
 
@@ -204,30 +206,30 @@ describe EnumerateIt::Base do
     context "by value" do
       let(:sort_mode) { :value }
 
-      it { should == [["jkl", "0"], ["xyz", "1"], ["fgh", "2"], ["abc", "3"]] }
+      it { is_expected.to eq([["jkl", "0"], ["xyz", "1"], ["fgh", "2"], ["abc", "3"]]) }
     end
 
     context "by name" do
       let(:sort_mode) { :name }
 
-      it { should == [["fgh", "2"], ["xyz", "1"], ["abc", "3"], ["jkl", "0"]] }
+      it { is_expected.to eq([["fgh", "2"], ["xyz", "1"], ["abc", "3"], ["jkl", "0"]]) }
     end
 
     context "by translation" do
       let(:sort_mode) { :translation }
 
-      it { should == [["abc", "3"] ,["fgh", "2"], ["jkl", "0"], ["xyz", "1"]] }
+      it { is_expected.to eq([["abc", "3"] ,["fgh", "2"], ["jkl", "0"], ["xyz", "1"]]) }
     end
 
     context "by nothing" do
       let(:sort_mode) { :none }
 
-      it { should == [["xyz", "1"], ["fgh", "2"], ["abc", "3"], ["jkl", "0"] ] }
+      it { is_expected.to eq([["xyz", "1"], ["fgh", "2"], ["abc", "3"], ["jkl", "0"] ]) }
     end
   end
 
   context "when included in ActiveRecord::Base" do
-    before :each do
+    before do
       class ActiveRecordStub
         attr_accessor :bla
 
@@ -237,40 +239,56 @@ describe EnumerateIt::Base do
         end
       end
 
-      ActiveRecordStub.stub(:validates_inclusion_of).and_return(true)
+      allow(ActiveRecordStub).to receive(:validates_inclusion_of).and_return(true)
       ActiveRecordStub.extend EnumerateIt
     end
 
     it "creates a validation for inclusion" do
-      ActiveRecordStub.should_receive(:validates_inclusion_of).with(:bla, :in => TestEnumeration.list, :allow_blank => true)
+      expect(ActiveRecordStub).to receive(:validates_inclusion_of).with(:bla, in: TestEnumeration.list, allow_blank: true)
       class ActiveRecordStub
-        has_enumeration_for :bla, :with => TestEnumeration
+        has_enumeration_for :bla, with: TestEnumeration
       end
     end
 
     context "using the :required option" do
-      before :each do
-        ActiveRecordStub.stub(:validates_presence_of).and_return(true)
+      before do
+        allow(ActiveRecordStub).to receive(:validates_presence_of).and_return(true)
       end
 
       it "creates a validation for presence" do
-        ActiveRecordStub.should_receive(:validates_presence_of)
+        expect(ActiveRecordStub).to receive(:validates_presence_of)
         class ActiveRecordStub
-          has_enumeration_for :bla, :with => TestEnumeration, :required => true
+          has_enumeration_for :bla, with: TestEnumeration, required: true
         end
       end
 
       it "passes the given options to the validation method" do
-        ActiveRecordStub.should_receive(:validates_presence_of).with(:bla, :if => :some_method)
+        expect(ActiveRecordStub).to receive(:validates_presence_of).with(:bla, if: :some_method)
         class ActiveRecordStub
-          has_enumeration_for :bla, :with => TestEnumeration, :required => { :if => :some_method }
+          has_enumeration_for :bla, with: TestEnumeration, required: { if: :some_method }
         end
       end
 
       it "do not require the attribute by default" do
-        ActiveRecordStub.should_not_receive(:validates_presence_of)
+        expect(ActiveRecordStub).to_not receive(:validates_presence_of)
+        class ActiveRecordStub
+          has_enumeration_for :bla, with: TestEnumeration
+        end
+      end
+    end
+
+    context "using :skip_validation option" do
+      it "doesn't create a validation for inclusion" do
+        expect(ActiveRecordStub).to_not receive(:validates_inclusion_of)
+        class ActiveRecordStub
+          has_enumeration_for :bla, with: TestEnumeration, skip_validation: true
+        end
+      end
+
+      it "doesn't create a validation for presence" do
+        expect(ActiveRecordStub).to_not receive(:validates_presence_of)
         class ActiveRecordStub
-          has_enumeration_for :bla, :with => TestEnumeration
+          has_enumeration_for :bla, with: TestEnumeration, require: true, skip_validation: true
         end
       end
     end

data/spec/enumerate_it_spec.rb

@@ -1,14 +1,18 @@
-#encoding: utf-8
+# encoding: utf-8
+
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe EnumerateIt do
-  before :each do
+  before do
     class TestClass
       extend EnumerateIt
       attr_accessor :foobar
-      has_enumeration_for :foobar, :with => TestEnumeration
+      has_enumeration_for :foobar, with: TestEnumeration
+
+      def initialize(foobar)
+        @foobar = foobar
+      end
 
-      def initialize(foobar); @foobar = foobar; end
       I18n.locale = :en
     end
 
@@ -17,33 +21,33 @@ describe EnumerateIt do
 
   context "associating an enumeration with a class attribute" do
     it "creates an humanized description for the attribute's value" do
-      @target.foobar_humanize.should == 'Hey, I am 2!'
+      expect(@target.foobar_humanize).to eq('Hey, I am 2!')
     end
 
     it "if the attribute is blank, the humanize description is nil" do
       @target.foobar = nil
-      @target.foobar_humanize.should be_nil
+      expect(@target.foobar_humanize).to be_nil
     end
 
     it "defaults to not creating helper methods" do
-      @target.should_not respond_to(:value_1?)
+      expect(@target).not_to respond_to(:value_1?)
     end
 
     it "stores the enumeration class in a class-level hash" do
-      TestClass.enumerations[:foobar].should == TestEnumeration
+      expect(TestClass.enumerations[:foobar]).to eq(TestEnumeration)
     end
 
     context 'use the same enumeration from an inherited class' do
       before do
-        class SomeClass < BaseClass
+        class SomeClassWithoutEnum < BaseClass
         end
-        @target = SomeClass.new
+        @target = SomeClassWithoutEnum.new
       end
 
       it 'should have use the correct class' do
         @base = BaseClass.new
-        @base.class.enumerations[:foobar].should == TestEnumeration
-        @target.class.enumerations[:foobar].should == TestEnumeration
+        expect(@base.class.enumerations[:foobar]).to eq(TestEnumeration)
+        expect(@target.class.enumerations[:foobar]).to eq(TestEnumeration)
       end
     end
 
@@ -56,39 +60,41 @@ describe EnumerateIt do
       end
       it 'should have use the corret class' do
         @base = BaseClass.new
-        @base.class.enumerations[:foobar].should == TestEnumeration
-        @target.class.enumerations[:foobar].should == Foobar
+        expect(@base.class.enumerations[:foobar]).to eq(TestEnumeration)
+        expect(@target.class.enumerations[:foobar]).to eq(Foobar)
       end
     end
 
     context "passing the value of each option without the human string (just the value, without an array)" do
-      before :each do
+      before do
         class TestClassForEnumerationWithoutArray
           extend EnumerateIt
           attr_accessor :foobar
-          has_enumeration_for :foobar, :with => TestEnumerationWithoutArray
+          has_enumeration_for :foobar, with: TestEnumerationWithoutArray
 
-          def initialize(foobar); @foobar = foobar; end
+          def initialize(foobar)
+            @foobar = foobar
+          end
         end
 
         @target = TestClassForEnumerationWithoutArray.new(TestEnumerationWithoutArray::VALUE_TWO)
       end
 
       it "humanizes the respective hash key" do
-        @target.foobar_humanize.should == 'Value Two'
+        expect(@target.foobar_humanize).to eq('Value Two')
       end
 
       it "translates the respective hash key when a translation is found" do
         @target.foobar = TestEnumerationWithoutArray::VALUE_ONE
-        @target.foobar_humanize.should == 'First Value'
+        expect(@target.foobar_humanize).to eq('First Value')
         I18n.locale = :pt
 
-        @target.foobar_humanize.should == 'Primeiro Valor'
+        expect(@target.foobar_humanize).to eq('Primeiro Valor')
       end
     end
 
     context "without passing the enumeration class" do
-      before :each do
+      before do
         class FooBar
           extend EnumerateIt
           attr_accessor :test_enumeration
@@ -103,18 +109,18 @@ describe EnumerateIt do
 
       it "should find out which enumeration class to use" do
         target = FooBar.new(TestEnumeration::VALUE_1)
-        target.test_enumeration_humanize.should == 'Hey, I am 1!'
+        expect(target.test_enumeration_humanize).to eq('Hey, I am 1!')
       end
 
       context "when using a nested class as the enumeration" do
         before do
           class NestedEnum < EnumerateIt::Base
-            associate_values :foo => ['1', 'Fooo'], :bar => ['2', 'Barrrr']
+            associate_values foo: ['1', 'Fooo'], bar: ['2', 'Barrrr']
           end
 
           class ClassWithNestedEnum
             class NestedEnum < EnumerateIt::Base
-              associate_values :foo => ['1', 'Blerrgh'], :bar => ['2' => 'Blarghhh']
+              associate_values foo: ['1', 'Blerrgh'], bar: ['2' => 'Blarghhh']
             end
 
             extend EnumerateIt
@@ -130,68 +136,74 @@ describe EnumerateIt do
         end
 
         it "uses the inner class as the enumeration class" do
-          target = ClassWithNestedEnum.new('1').nested_enum_humanize.should == 'Blerrgh'
+          expect(ClassWithNestedEnum.new('1').nested_enum_humanize).to eq('Blerrgh')
         end
       end
     end
   end
 
   context "using the :create_helpers option" do
-    before :each do
-      class TestClass
-        has_enumeration_for :foobar, :with => TestEnumeration, :create_helpers => true
+    before do
+      class TestClassWithHelper
+        extend EnumerateIt
+        attr_accessor :foobar
+        has_enumeration_for :foobar, with: TestEnumeration, create_helpers: true
+
+        def initialize(foobar)
+          @foobar = foobar
+        end
       end
     end
 
     it "creates helpers methods with question marks for each enumeration option" do
-      target = TestClass.new(TestEnumeration::VALUE_2)
-      target.should be_value_2
-      target.should_not be_value_1
+      target = TestClassWithHelper.new(TestEnumeration::VALUE_2)
+      expect(target).to be_value_2
+      expect(target).not_to be_value_1
     end
 
     it "creates a mutator method for each enumeration value" do
       [:value_1, :value_2, :value_3].each do |value|
-        TestClass.new(TestEnumeration::VALUE_1).should respond_to(:"#{value}!")
+        expect(TestClassWithHelper.new(TestEnumeration::VALUE_1)).to respond_to(:"#{value}!")
       end
     end
 
     it "changes the attribute's value through mutator methods" do
-      target = TestClass.new(TestEnumeration::VALUE_2)
+      target = TestClassWithHelper.new(TestEnumeration::VALUE_2)
       target.value_3!
-      target.foobar.should == TestEnumeration::VALUE_3
+      expect(target.foobar).to eq(TestEnumeration::VALUE_3)
     end
 
     context "with :prefix option" do
-      before :each do
-        class TestClass
-          has_enumeration_for :foobar, :with => TestEnumeration, :create_helpers => { :prefix => true }
+      before do
+        class TestClassWithHelper
+          has_enumeration_for :foobar, with: TestEnumeration, create_helpers: { prefix: true }
         end
       end
 
       it "creates helpers methods with question marks and prefixes for each enumeration option" do
-        target = TestClass.new(TestEnumeration::VALUE_2)
-        target.should be_foobar_value_2
+        target = TestClassWithHelper.new(TestEnumeration::VALUE_2)
+        expect(target).to be_foobar_value_2
       end
 
       it "creates a mutator method for each enumeration value" do
         [:value_1, :value_2, :value_3].each do |value|
-          TestClass.new(TestEnumeration::VALUE_1).should respond_to(:"foobar_#{value}!")
+          expect(TestClassWithHelper.new(TestEnumeration::VALUE_1)).to respond_to(:"foobar_#{value}!")
         end
       end
 
       it "changes the attribute's value through mutator methods" do
-        target = TestClass.new(TestEnumeration::VALUE_2)
+        target = TestClassWithHelper.new(TestEnumeration::VALUE_2)
         target.foobar_value_3!
-        target.foobar.should == TestEnumeration::VALUE_3
+        expect(target.foobar).to eq(TestEnumeration::VALUE_3)
       end
     end
 
     context "with :polymorphic option" do
-      before :each do
+      before do
         class Polymorphic
           extend EnumerateIt
           attr_accessor :foo
-          has_enumeration_for :foo, :with => PolymorphicEnum, :create_helpers => { :polymorphic => true }
+          has_enumeration_for :foo, with: PolymorphicEnum, create_helpers: { polymorphic: true }
         end
       end
 
@@ -199,23 +211,23 @@ describe EnumerateIt do
         target = Polymorphic.new
         target.foo = PolymorphicEnum::NORMAL
 
-        target.foo_object.print("Gol").should == "I'm Normal: Gol"
+        expect(target.foo_object.print("Gol")).to eq("I'm Normal: Gol")
 
         target.foo = PolymorphicEnum::CRAZY
 
-        target.foo_object.print("Gol").should == "Whoa!: Gol"
+        expect(target.foo_object.print("Gol")).to eq("Whoa!: Gol")
       end
 
       it "returns nil if foo is not set" do
         target = Polymorphic.new
 
-        target.foo_object.should be_nil
+        expect(target.foo_object).to be_nil
       end
 
       context "and :suffix" do
-        before :each do
+        before do
           class Polymorphic
-            has_enumeration_for :foo, :with => PolymorphicEnum, :create_helpers => { :polymorphic => { :suffix => "_strategy" } }
+            has_enumeration_for :foo, with: PolymorphicEnum, create_helpers: { polymorphic: { suffix: "_strategy" } }
           end
         end
 
@@ -223,44 +235,39 @@ describe EnumerateIt do
           target = Polymorphic.new
           target.foo = PolymorphicEnum::NORMAL
 
-          target.foo_strategy.print("Gol").should == "I'm Normal: Gol"
+          expect(target.foo_strategy.print("Gol")).to eq("I'm Normal: Gol")
 
           target.foo = PolymorphicEnum::CRAZY
 
-          target.foo_strategy.print("Gol").should == "Whoa!: Gol"
+          expect(target.foo_strategy.print("Gol")).to eq("Whoa!: Gol")
         end
       end
     end
   end
 
   describe "using the :create_scopes option" do
-    def setup_enumeration
-      OtherTestClass.send(:has_enumeration_for, :foobar, :with => TestEnumeration, :create_scopes => true)
-    end
-
     context "if the hosting class responds to :scope" do
       before do
         if ActiveSupport::VERSION::STRING =~ /3\.1/
-          Object.send :remove_const, 'OtherTestClass' if defined?(OtherTestClass)
+          Object.send :remove_const, 'TestClassWithScope' if defined?(TestClassWithScope)
         end
 
-        class OtherTestClass < ActiveRecord::Base
+        class TestClassWithScope < ActiveRecord::Base
           extend EnumerateIt
+          has_enumeration_for :foobar, with: TestEnumeration, create_scopes: true
         end
-
-        setup_enumeration
       end
 
       it "creates a scope for each enumeration value" do
         TestEnumeration.enumeration.keys.each do |symbol|
-          OtherTestClass.should respond_to(symbol)
+          expect(TestClassWithScope).to respond_to(symbol)
         end
       end
 
       it "when called, the scopes create the correct query" do
         TestEnumeration.enumeration.each do |symbol, pair|
-          OtherTestClass.should_receive(:where).with(:foobar => pair.first)
-          OtherTestClass.send symbol
+          expect(TestClassWithScope).to receive(:where).with(foobar: pair.first)
+          TestClassWithScope.send symbol
         end
       end
     end
@@ -274,22 +281,22 @@ describe EnumerateIt do
 
       it "raises no errors" do
         expect {
-          GenericClass.send(:has_enumeration_for, :foobar, :with => TestEnumeration, :create_scopes => true)
+          GenericClass.send(:has_enumeration_for, :foobar, with: TestEnumeration, create_scopes: true)
         }.to_not raise_error
       end
     end
 
     context "with :prefix option" do
       before do
-        class OtherTestClass
+        class OtherTestClass < ActiveRecord::Base
           extend EnumerateIt
-          has_enumeration_for :foobar, :with => TestEnumerationWithReservedWords, :create_scopes => { :prefix => true }
+          has_enumeration_for :foobar, with: TestEnumerationWithReservedWords, create_scopes: { prefix: true }
         end
       end
 
       it "creates a scope with prefix for each enumeration value" do
         TestEnumerationWithReservedWords.enumeration.keys.each do |symbol|
-          OtherTestClass.should respond_to(:"foobar_#{symbol}")
+          expect(OtherTestClass).to respond_to(:"foobar_#{symbol}")
         end
       end
     end

data/spec/spec_helper.rb

@@ -10,6 +10,7 @@ Dir['./spec/support/**/*.rb'].each { |f| require f }
 I18n.config.enforce_available_locales = false
 I18n.load_path = Dir['spec/i18n/*.yml']
 
-# RSpec.configure do |config|
-#   config.filter_run_including focus: true
-# end
+RSpec.configure do |config|
+  config.filter_run_including focus: true
+  config.run_all_when_everything_filtered = true
+end

data/spec/support/test_classes.rb

@@ -1,22 +1,22 @@
 class TestEnumeration < EnumerateIt::Base
   associate_values(
-    :value_1 => ['1', 'Hey, I am 1!'],
-    :value_2 => ['2', 'Hey, I am 2!'],
-    :value_3 => ['3', 'Hey, I am 3!']
+    value_1: ['1', 'Hey, I am 1!'],
+    value_2: ['2', 'Hey, I am 2!'],
+    value_3: ['3', 'Hey, I am 3!']
   )
 end
 
 class TestEnumerationWithoutArray < EnumerateIt::Base
   associate_values(
-    :value_one => '1',
-    :value_two => '2'
+    value_one: '1',
+    value_two: '2'
   )
 end
 
 class TestEnumerationWithExtendedBehaviour < EnumerateIt::Base
   associate_values(
-    :first => '1',
-    :second => '2'
+    first:  '1',
+    second: '2'
   )
   def self.to_a
     super.reverse
@@ -28,7 +28,7 @@ class TestEnumerationWithList < EnumerateIt::Base
 end
 
 class TestEnumerationWithReservedWords < EnumerateIt::Base
-  associate_values :new => 1, :no_schedule => 2, :with_schedule => 3, :suspended => 4
+  associate_values new: 1, no_schedule: 2, with_schedule: 3, suspended: 4
 end
 
 class TestEnumerationWithDash < EnumerateIt::Base
@@ -45,7 +45,7 @@ end
 
 class Foobar < EnumerateIt::Base
   associate_values(
-    :bar => 'foo'
+    bar: 'foo'
   )
 end
 
@@ -67,7 +67,7 @@ end
 
 class BaseClass
   extend EnumerateIt
-  has_enumeration_for :foobar, :with => TestEnumeration
+  has_enumeration_for :foobar, with: TestEnumeration
 end
 
 def create_enumeration_class_with_sort_mode(sort_mode)
@@ -75,11 +75,10 @@ def create_enumeration_class_with_sort_mode(sort_mode)
     sort_by sort_mode
 
     associate_values(
-      :foo  => ["1", "xyz"],
-      :bar  => ["2", "fgh"],
-      :omg  => ["3", "abc"],
-      :zomg => ["0", "jkl"]
+      foo:  ["1", "xyz"],
+      bar:  ["2", "fgh"],
+      omg:  ["3", "abc"],
+      zomg: ["0", "jkl"]
     )
   end
 end
-

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: enumerate_it
 version: !ruby/object:Gem::Version
-  version: 1.2.9
+  version: 1.3.0
 platform: ruby
 authors:
 - Cássio Marques
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-27 00:00:00.000000000 Z
+date: 2016-06-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -71,16 +71,30 @@ dependencies:
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.14.1
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.14.1
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Enumerations for Ruby with some magic powers!
 email: 
 executables: []
@@ -90,6 +104,7 @@ files:
 - ".document"
 - ".gitignore"
 - ".rspec"
+- ".ruby-version"
 - ".travis.yml"
 - Appraisals
 - CHANGELOG.md