enumerate_it 1.3.0 → 1.3.1.rc1

data/spec/enumerate_it_spec.rb

@@ -3,7 +3,7 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe EnumerateIt do
-  before do
+  let :target do
     class TestClass
       extend EnumerateIt
       attr_accessor :foobar
@@ -16,57 +16,62 @@ describe EnumerateIt do
       I18n.locale = :en
     end
 
-    @target = TestClass.new(TestEnumeration::VALUE_2)
+    TestClass.new(TestEnumeration::VALUE_2)
   end
 
-  context "associating an enumeration with a class attribute" do
+  context 'associating an enumeration with a class attribute' do
     it "creates an humanized description for the attribute's value" do
-      expect(@target.foobar_humanize).to eq('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
-      expect(@target.foobar_humanize).to be_nil
+    it 'if the attribute is blank, the humanize description is nil' do
+      target.foobar = nil
+      expect(target.foobar_humanize).to be_nil
     end
 
-    it "defaults to not creating helper methods" do
-      expect(@target).not_to respond_to(:value_1?)
+    it 'defaults to not creating helper methods' do
+      expect(target).not_to respond_to(:value_1?)
     end
 
-    it "stores the enumeration class in a class-level hash" do
+    it 'stores the enumeration class in a class-level hash' do
       expect(TestClass.enumerations[:foobar]).to eq(TestEnumeration)
     end
 
     context 'use the same enumeration from an inherited class' do
-      before do
+      let :target do
         class SomeClassWithoutEnum < BaseClass
         end
-        @target = SomeClassWithoutEnum.new
+
+        SomeClassWithoutEnum.new
       end
 
-      it 'should have use the correct class' do
-        @base = BaseClass.new
-        expect(@base.class.enumerations[:foobar]).to eq(TestEnumeration)
-        expect(@target.class.enumerations[:foobar]).to eq(TestEnumeration)
+      let(:base) { BaseClass.new }
+
+      it 'has use the correct class' do
+        expect(base.class.enumerations[:foobar]).to eq(TestEnumeration)
+        expect(target.class.enumerations[:foobar]).to eq(TestEnumeration)
       end
     end
 
     context 'declaring a simple enum on an inherited class' do
-      before do
+      let :target do
         class SomeClass < BaseClass
           has_enumeration_for :foobar
         end
-        @target = SomeClass.new
+
+        SomeClass.new
       end
-      it 'should have use the corret class' do
-        @base = BaseClass.new
-        expect(@base.class.enumerations[:foobar]).to eq(TestEnumeration)
-        expect(@target.class.enumerations[:foobar]).to eq(Foobar)
+
+      let(:base) { BaseClass.new }
+
+      it 'has use the corret class' do
+        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 do
+    context 'passing options values without the human string (just the value, without an array)' do
+      let :target do
         class TestClassForEnumerationWithoutArray
           extend EnumerateIt
           attr_accessor :foobar
@@ -77,56 +82,54 @@ describe EnumerateIt do
           end
         end
 
-        @target = TestClassForEnumerationWithoutArray.new(TestEnumerationWithoutArray::VALUE_TWO)
+        TestClassForEnumerationWithoutArray.new(TestEnumerationWithoutArray::VALUE_TWO)
       end
 
-      it "humanizes the respective hash key" do
-        expect(@target.foobar_humanize).to eq('Value Two')
+      it 'humanizes the respective hash key' do
+        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
-        expect(@target.foobar_humanize).to eq('First Value')
+      it 'translates the respective hash key when a translation is found' do
+        target.foobar = TestEnumerationWithoutArray::VALUE_ONE
+        expect(target.foobar_humanize).to eq('First Value')
         I18n.locale = :pt
 
-        expect(@target.foobar_humanize).to eq('Primeiro Valor')
+        expect(target.foobar_humanize).to eq('Primeiro Valor')
       end
     end
 
-    context "without passing the enumeration class" do
-      before do
+    context 'without passing the enumeration class' do
+      let :target do
         class FooBar
           extend EnumerateIt
           attr_accessor :test_enumeration
-
           has_enumeration_for :test_enumeration
 
           def initialize(test_enumeration_value)
             @test_enumeration = test_enumeration_value
           end
         end
+
+        FooBar.new(TestEnumeration::VALUE_1)
       end
 
-      it "should find out which enumeration class to use" do
-        target = FooBar.new(TestEnumeration::VALUE_1)
+      it 'finds out which enumeration class to use' do
         expect(target.test_enumeration_humanize).to eq('Hey, I am 1!')
       end
 
-      context "when using a nested class as the enumeration" do
+      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: %w(1 Fooo), bar: %w(2 Barrrr)
           end
 
           class ClassWithNestedEnum
             class NestedEnum < EnumerateIt::Base
-              associate_values foo: ['1', 'Blerrgh'], bar: ['2' => 'Blarghhh']
+              associate_values foo: %w(1 Blerrgh), bar: ['2' => 'Blarghhh']
             end
 
             extend EnumerateIt
-
             attr_accessor :nested_enum
-
             has_enumeration_for :nested_enum
 
             def initialize(nested_enum_value)
@@ -135,14 +138,14 @@ describe EnumerateIt do
           end
         end
 
-        it "uses the inner class as the enumeration class" do
+        it 'uses the inner class as the enumeration class' do
           expect(ClassWithNestedEnum.new('1').nested_enum_humanize).to eq('Blerrgh')
         end
       end
     end
   end
 
-  context "using the :create_helpers option" do
+  context 'using the :create_helpers option' do
     before do
       class TestClassWithHelper
         extend EnumerateIt
@@ -155,13 +158,13 @@ describe EnumerateIt do
       end
     end
 
-    it "creates helpers methods with question marks for each enumeration option" do
+    it 'creates helpers methods with question marks for each enumeration option' do
       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
+    it 'creates a mutator method for each enumeration value' do
       [:value_1, :value_2, :value_3].each do |value|
         expect(TestClassWithHelper.new(TestEnumeration::VALUE_1)).to respond_to(:"#{value}!")
       end
@@ -173,21 +176,22 @@ describe EnumerateIt do
       expect(target.foobar).to eq(TestEnumeration::VALUE_3)
     end
 
-    context "with :prefix option" do
+    context 'with :prefix option' do
       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
+      it 'creates helpers methods with question marks and prefixes for each enumeration option' do
         target = TestClassWithHelper.new(TestEnumeration::VALUE_2)
         expect(target).to be_foobar_value_2
       end
 
-      it "creates a mutator method for each enumeration value" do
+      it 'creates a mutator method for each enumeration value' do
         [:value_1, :value_2, :value_3].each do |value|
-          expect(TestClassWithHelper.new(TestEnumeration::VALUE_1)).to respond_to(:"foobar_#{value}!")
+          expect(TestClassWithHelper.new(TestEnumeration::VALUE_1))
+            .to respond_to(:"foobar_#{value}!")
         end
       end
 
@@ -198,7 +202,7 @@ describe EnumerateIt do
       end
     end
 
-    context "with :polymorphic option" do
+    context 'with :polymorphic option' do
       before do
         class Polymorphic
           extend EnumerateIt
@@ -211,23 +215,24 @@ describe EnumerateIt do
         target = Polymorphic.new
         target.foo = PolymorphicEnum::NORMAL
 
-        expect(target.foo_object.print("Gol")).to eq("I'm Normal: Gol")
+        expect(target.foo_object.print('Gol')).to eq("I'm Normal: Gol")
 
         target.foo = PolymorphicEnum::CRAZY
 
-        expect(target.foo_object.print("Gol")).to eq("Whoa!: Gol")
+        expect(target.foo_object.print('Gol')).to eq('Whoa!: Gol')
       end
 
-      it "returns nil if foo is not set" do
+      it 'returns nil if foo is not set' do
         target = Polymorphic.new
 
         expect(target.foo_object).to be_nil
       end
 
-      context "and :suffix" do
+      context 'and :suffix' 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
 
@@ -235,22 +240,20 @@ describe EnumerateIt do
           target = Polymorphic.new
           target.foo = PolymorphicEnum::NORMAL
 
-          expect(target.foo_strategy.print("Gol")).to eq("I'm Normal: Gol")
+          expect(target.foo_strategy.print('Gol')).to eq("I'm Normal: Gol")
 
           target.foo = PolymorphicEnum::CRAZY
 
-          expect(target.foo_strategy.print("Gol")).to eq("Whoa!: Gol")
+          expect(target.foo_strategy.print('Gol')).to eq('Whoa!: Gol')
         end
       end
     end
   end
 
-  describe "using the :create_scopes option" do
-    context "if the hosting class responds to :scope" do
+  describe 'using the :create_scopes option' do
+    context 'if the hosting class responds to :scope' do
       before do
-        if ActiveSupport::VERSION::STRING =~ /3\.1/
-          Object.send :remove_const, 'TestClassWithScope' if defined?(TestClassWithScope)
-        end
+        Object.send :remove_const, 'TestClassWithScope' if defined?(TestClassWithScope)
 
         class TestClassWithScope < ActiveRecord::Base
           extend EnumerateIt
@@ -258,43 +261,44 @@ describe EnumerateIt do
         end
       end
 
-      it "creates a scope for each enumeration value" do
+      it 'creates a scope for each enumeration value' do
         TestEnumeration.enumeration.keys.each do |symbol|
           expect(TestClassWithScope).to respond_to(symbol)
         end
       end
 
-      it "when called, the scopes create the correct query" do
+      it 'when called, the scopes create the correct query' do
         TestEnumeration.enumeration.each do |symbol, pair|
           expect(TestClassWithScope).to receive(:where).with(foobar: pair.first)
-          TestClassWithScope.send symbol
+          TestClassWithScope.send(symbol)
         end
       end
     end
 
-    context "when the hosting class do not respond to :scope" do
+    context 'when the hosting class do not respond to :scope' do
       before do
         class GenericClass
           extend EnumerateIt
         end
       end
 
-      it "raises no errors" do
-        expect {
-          GenericClass.send(:has_enumeration_for, :foobar, with: TestEnumeration, create_scopes: true)
-        }.to_not raise_error
+      it 'raises no errors' do
+        expect do
+          GenericClass.has_enumeration_for(:foobar, with: TestEnumeration, create_scopes: true)
+        end.not_to raise_error
       end
     end
 
-    context "with :prefix option" do
+    context 'with :prefix option' do
       before do
         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
+      it 'creates a scope with prefix for each enumeration value' do
         TestEnumerationWithReservedWords.enumeration.keys.each do |symbol|
           expect(OtherTestClass).to respond_to(:"foobar_#{symbol}")
         end

data/spec/spec_helper.rb

@@ -11,6 +11,6 @@ I18n.config.enforce_available_locales = false
 I18n.load_path = Dir['spec/i18n/*.yml']
 
 RSpec.configure do |config|
-  config.filter_run_including focus: true
+  config.filter_run :focus
   config.run_all_when_everything_filtered = true
 end

data/spec/support/test_classes.rb

@@ -75,10 +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:  %w(1 xyz),
+      bar:  %w(2 fgh),
+      omg:  %w(3 abc),
+      zomg: %w(0 jkl)
     )
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: enumerate_it
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.3.1.rc1
 platform: ruby
 authors:
 - Cássio Marques
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-01 00:00:00.000000000 Z
+date: 2016-08-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -95,15 +95,29 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        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: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".document"
 - ".gitignore"
 - ".rspec"
+- ".rubocop.yml"
 - ".ruby-version"
 - ".travis.yml"
 - Appraisals
@@ -114,12 +128,13 @@ files:
 - README.md
 - Rakefile
 - enumerate_it.gemspec
-- gemfiles/activesupport_3_0.gemfile
-- gemfiles/activesupport_3_1.gemfile
-- gemfiles/activesupport_3_2.gemfile
-- gemfiles/activesupport_4_0.gemfile
-- gemfiles/activesupport_4_1.gemfile
-- gemfiles/activesupport_4_2.gemfile
+- gemfiles/rails_3.0.gemfile
+- gemfiles/rails_3.1.gemfile
+- gemfiles/rails_3.2.gemfile
+- gemfiles/rails_4.0.gemfile
+- gemfiles/rails_4.1.gemfile
+- gemfiles/rails_4.2.gemfile
+- gemfiles/rails_5.0.gemfile
 - lib/enumerate_it.rb
 - lib/enumerate_it/base.rb
 - lib/enumerate_it/class_methods.rb
@@ -151,12 +166,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.6
 signing_key: 
 specification_version: 4
 summary: Ruby Enumerations