enumerate_it 4.0.0 → 4.2.0

data/spec/enumerate_it/base_spec.rb

@@ -2,10 +2,11 @@ require 'spec_helper'
 
 describe EnumerateIt::Base do
   it 'creates constants for each enumeration value' do
-    constants = [TestEnumeration::VALUE_1, TestEnumeration::VALUE_2, TestEnumeration::VALUE_3]
+    constants = [TestEnumeration::VALUE_1, TestEnumeration::VALUE_2, TestEnumeration::VALUE_3,
+                 TestEnumeration::VALUE_4]
 
-    constants.each_with_index do |constant, idx|
-      expect(constant).to eq((idx + 1).to_s)
+    constants.each.with_index(1) do |constant, index|
+      expect(constant).to eq(index.to_s)
     end
   end
 
@@ -23,7 +24,7 @@ describe EnumerateIt::Base do
 
   describe '.list' do
     it "creates a method that returns the allowed values in the enumeration's class" do
-      expect(TestEnumeration.list).to eq(%w[1 2 3])
+      expect(TestEnumeration.list).to eq(%w[1 2 3 4])
     end
 
     context 'specifying a default sort mode' do
@@ -32,40 +33,45 @@ describe EnumerateIt::Base do
       context 'by value' do
         let(:sort_mode) { :value }
 
-        it { is_expected.to eq(%w[0 1 2 3]) }
+        it { is_expected.to eq(%w[0 1 2 3 4]) }
       end
 
       context 'by name' do
         let(:sort_mode) { :name }
 
-        it { is_expected.to eq(%w[2 1 3 0]) }
+        it { is_expected.to eq(%w[2 4 1 3 0]) }
       end
 
       context 'by translation' do
         let(:sort_mode) { :translation }
 
-        it { is_expected.to eq(%w[3 2 0 1]) }
+        it { is_expected.to eq(%w[3 2 0 1 4]) }
+      end
+
+      context 'by normalize translation' do
+        let(:sort_mode) { :normalize_translation }
+
+        it { is_expected.to eq(%w[3 4 2 0 1]) }
       end
 
       context 'by nothing' do
         let(:sort_mode) { :none }
 
-        it { is_expected.to eq(%w[1 2 3 0]) }
+        it { is_expected.to eq(%w[1 2 3 4 0]) }
       end
     end
   end
 
   it 'creates a method that returns the enumeration specification' do
     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!']
+      value_1: ['1', 'Hey, I am 1!'], value_2: ['2', 'Hey, I am 2!'],
+      value_3: ['3', 'Hey, I am 3!'], value_4: ['4', 'Héy, I ãm 2!']
     )
   end
 
   describe '.length' do
     it 'returns the length of the enumeration' do
-      expect(TestEnumeration.length).to eq(3)
+      expect(TestEnumeration.length).to eq(4)
     end
   end
 
@@ -75,13 +81,14 @@ describe EnumerateIt::Base do
       TestEnumeration.each_translation do |translation|
         translations << translation
       end
-      expect(translations).to eq(['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!', 'Héy, I ãm 2!'])
     end
   end
 
   describe '.translations' do
     it 'returns all translations' do
-      expect(TestEnumeration.translations).to eq(['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!',
+                                                  'Héy, I ãm 2!'])
     end
   end
 
@@ -91,7 +98,7 @@ describe EnumerateIt::Base do
       TestEnumeration.each_key do |key|
         keys << key
       end
-      expect(keys).to eq(%i[value_1 value_2 value_3])
+      expect(keys).to eq(%i[value_1 value_2 value_3 value_4])
     end
   end
 
@@ -108,7 +115,8 @@ describe EnumerateIt::Base do
   describe '.to_a' do
     it 'returns an array with the values and human representations' do
       expect(TestEnumeration.to_a)
-        .to eq([['Hey, I am 1!', '1'], ['Hey, I am 2!', '2'], ['Hey, I am 3!', '3']])
+        .to eq([['Hey, I am 1!', '1'], ['Hey, I am 2!', '2'], ['Hey, I am 3!', '3'],
+                ['Héy, I ãm 2!', '4']])
     end
 
     it 'translates the available values' do
@@ -152,7 +160,7 @@ describe EnumerateIt::Base do
 
   describe '.to_range' do
     it "returns a Range object containing the enumeration's value interval" do
-      expect(TestEnumeration.to_range).to eq('1'..'3')
+      expect(TestEnumeration.to_range).to eq('1'..'4')
     end
   end
 
@@ -206,7 +214,7 @@ describe EnumerateIt::Base do
 
   describe '.keys' do
     it 'returns a list with the keys used to define the enumeration' do
-      expect(TestEnumeration.keys).to eq(%i[value_1 value_2 value_3])
+      expect(TestEnumeration.keys).to eq(%i[value_1 value_2 value_3 value_4])
     end
   end
 
@@ -220,6 +228,55 @@ describe EnumerateIt::Base do
     end
   end
 
+  describe '.custom_helpers' do
+    context 'when methods are defined inside the block' do
+      it 'become class methods on the enum' do
+        expect(TestEnumerationWithCustomHelpers.lookup('1')).to eq(:one)
+        expect(TestEnumerationWithCustomHelpers.lookup('2')).to eq(:two)
+        expect(TestEnumerationWithCustomHelpers.boolean?('1')).to be(true)
+        expect(TestEnumerationWithCustomHelpers.boolean?('2')).to be(false)
+      end
+    end
+
+    context 'when a custom helper name collides with a built-in method' do
+      let(:build_colliding_enum) do
+        proc do
+          Class.new(EnumerateIt::Base) do
+            associate_values :collision
+
+            custom_helpers do
+              def list
+                '...'
+              end
+            end
+          end
+        end
+      end
+
+      it 'raises an ArgumentError' do
+        expect(&build_colliding_enum).to raise_error(
+          ArgumentError,
+          "Custom helper(s) 'list' would override existing EnumerateIt::Base methods"
+        )
+      end
+    end
+  end
+
+  describe '.custom_helper_methods' do
+    context 'when methods are defined inside custom_helpers block' do
+      it 'returns the registered names' do
+        expect(TestEnumerationWithCustomHelpers.custom_helper_methods)
+          .to eq(%i[lookup boolean?])
+      end
+    end
+
+    context 'when there is no .custom_helpers block on an enum' do
+      it 'returns an empty array' do
+        expect(TestEnumeration.custom_helper_methods).to eq([])
+      end
+    end
+  end
+
   context 'associate values with a list' do
     it 'creates constants for each enumeration value' do
       expect(TestEnumerationWithList::FIRST).to  eq('first')
@@ -235,7 +292,7 @@ describe EnumerateIt::Base do
     subject(:enumeration) { create_enumeration_class_with_sort_mode(nil) }
 
     it 'does not sort' do
-      expect(enumeration.to_a).to eq([%w[xyz 1], %w[fgh 2], %w[abc 3], %w[jkl 0]])
+      expect(enumeration.to_a).to eq([%w[xyz 1], %w[fgh 2], %w[abc 3], %w[ábc 4], %w[jkl 0]])
     end
   end
 
@@ -245,25 +302,31 @@ describe EnumerateIt::Base do
     context 'by value' do
       let(:sort_mode) { :value }
 
-      it { expect(enumeration.to_a).to eq([%w[jkl 0], %w[xyz 1], %w[fgh 2], %w[abc 3]]) }
+      it { expect(enumeration.to_a).to eq([%w[jkl 0], %w[xyz 1], %w[fgh 2], %w[abc 3], %w[ábc 4]]) }
     end
 
     context 'by name' do
       let(:sort_mode) { :name }
 
-      it { expect(enumeration.to_a).to eq([%w[fgh 2], %w[xyz 1], %w[abc 3], %w[jkl 0]]) }
+      it { expect(enumeration.to_a).to eq([%w[fgh 2], %w[ábc 4], %w[xyz 1], %w[abc 3], %w[jkl 0]]) }
     end
 
     context 'by translation' do
       let(:sort_mode) { :translation }
 
-      it { expect(enumeration.to_a).to eq([%w[abc 3], %w[fgh 2], %w[jkl 0], %w[xyz 1]]) }
+      it { expect(enumeration.to_a).to eq([%w[abc 3], %w[fgh 2], %w[jkl 0], %w[xyz 1], %w[ábc 4]]) }
+    end
+
+    context 'by normalize translation' do
+      let(:sort_mode) { :normalize_translation }
+
+      it { expect(enumeration.to_a).to eq([%w[abc 3], %w[ábc 4], %w[fgh 2], %w[jkl 0], %w[xyz 1]]) }
     end
 
     context 'by nothing' do
       let(:sort_mode) { :none }
 
-      it { expect(enumeration.to_a).to eq([%w[xyz 1], %w[fgh 2], %w[abc 3], %w[jkl 0]]) }
+      it { expect(enumeration.to_a).to eq([%w[xyz 1], %w[fgh 2], %w[abc 3], %w[ábc 4], %w[jkl 0]]) }
     end
   end
 
@@ -275,11 +338,11 @@ describe EnumerateIt::Base do
         attr_accessor :bla
 
         class << self
-          def validates_inclusion_of(_attribute, _options)
+          def validates_inclusion_of(_attribute, _options) # rubocop:disable Naming/PredicateMethod
             true
           end
 
-          def validates_presence_of
+          def validates_presence_of # rubocop:disable Naming/PredicateMethod
             true
           end
         end

data/spec/enumerate_it_spec.rb

@@ -4,6 +4,7 @@ describe EnumerateIt do
   let :test_class do
     Class.new do
       extend EnumerateIt
+
       attr_accessor :foobar
 
       has_enumeration_for :foobar, with: TestEnumeration
@@ -41,6 +42,15 @@ describe EnumerateIt do
       expect(target).not_to respond_to(:value_1?)
     end
 
+    it 'defaults to not creating custom helper methods' do
+      klass = Class.new do
+        extend EnumerateIt
+
+        has_enumeration_for :foobar, with: TestEnumerationWithCustomHelpers
+      end
+      expect(klass.new).not_to respond_to(:lookup)
+    end
+
     it 'stores the enumeration class in a class-level hash' do
       expect(test_class.enumerations[:foobar]).to eq(TestEnumeration)
     end
@@ -71,6 +81,7 @@ describe EnumerateIt do
       let :test_class_for_enumeration_without_array do
         Class.new do
           extend EnumerateIt
+
           attr_accessor :foobar
 
           has_enumeration_for :foobar, with: TestEnumerationWithoutArray
@@ -102,6 +113,7 @@ describe EnumerateIt do
       let :foo_bar_class do
         Class.new do
           extend EnumerateIt
+
           attr_accessor :test_enumeration
 
           has_enumeration_for :test_enumeration
@@ -124,12 +136,13 @@ describe EnumerateIt do
             # rubocop:disable Lint/ConstantDefinitionInBlock
             # rubocop:disable RSpec/LeakyConstantDeclaration
             class NestedEnum < EnumerateIt::Base
-              associate_values foo: %w[1 Blerrgh], bar: ['2' => 'Blarghhh']
+              associate_values foo: %w[1 Blerrgh], bar: [{ '2' => 'Blarghhh' }]
             end
             # rubocop:enable RSpec/LeakyConstantDeclaration
             # rubocop:enable Lint/ConstantDefinitionInBlock
 
             extend EnumerateIt
+
             attr_accessor :nested_enum
 
             has_enumeration_for :nested_enum
@@ -151,6 +164,7 @@ describe EnumerateIt do
     let :test_class_with_helper do
       Class.new do
         extend EnumerateIt
+
         attr_accessor :foobar
 
         has_enumeration_for :foobar, with: TestEnumeration, create_helpers: true
@@ -192,6 +206,7 @@ describe EnumerateIt do
       let :test_class_with_prefixed_helper do
         Class.new do
           extend EnumerateIt
+
           attr_accessor :foobar
 
           has_enumeration_for :foobar, with: TestEnumeration, create_helpers: { prefix: true }
@@ -234,6 +249,7 @@ describe EnumerateIt do
       let :polymorphic_class do
         Class.new do
           extend EnumerateIt
+
           attr_accessor :foo
 
           has_enumeration_for :foo, with: PolymorphicEnum, create_helpers: { polymorphic: true }
@@ -260,6 +276,7 @@ describe EnumerateIt do
         let :polymorphic_class_with_suffix do
           Class.new do
             extend EnumerateIt
+
             attr_accessor :foo
 
             has_enumeration_for :foo, with: PolymorphicEnum,
@@ -280,6 +297,62 @@ describe EnumerateIt do
         end
       end
     end
+
+    context 'with custom_helpers defined on the enumeration' do
+      context 'creates methods that delegates to the enum' do
+        let :test_class_with_custom_helpers do
+          Class.new do
+            extend EnumerateIt
+
+            attr_accessor :foobar
+
+            has_enumeration_for :foobar, with: TestEnumerationWithCustomHelpers,
+              create_helpers: true
+
+            def initialize(foobar)
+              @foobar = foobar
+            end
+          end
+        end
+
+        it 'returns value respective to attribute value' do
+          target = test_class_with_custom_helpers.new(TestEnumerationWithCustomHelpers::VALUE_ONE)
+          expect(target.lookup).to eq(:one)
+          expect(target.boolean?).to be(true)
+        end
+
+        it 'returns nil when attribute is nil' do
+          target = test_class_with_custom_helpers.new(nil)
+          expect(target.lookup).to be_nil
+          expect(target.boolean?).to be_nil
+        end
+      end
+
+      context 'create methods with prefix that delegates to the enum' do
+        let :test_class_with_prefixed_custom_helpers do
+          Class.new do
+            extend EnumerateIt
+
+            attr_accessor :foobar
+
+            has_enumeration_for :foobar, with: TestEnumerationWithCustomHelpers,
+              create_helpers: { prefix: true }
+
+            def initialize(foobar)
+              @foobar = foobar
+            end
+          end
+        end
+
+        it 'method is prefixed with the attribute name' do
+          target = test_class_with_prefixed_custom_helpers.new(TestEnumerationWithCustomHelpers::VALUE_ONE)
+          expect(target.foobar_lookup).to eq(:one)
+          expect(target.foobar_boolean?).to be(true)
+          expect(target).not_to respond_to(:lookup)
+          expect(target).not_to respond_to(:boolean?)
+        end
+      end
+    end
   end
 
   describe 'using the :create_scopes option' do

data/spec/spec_helper.rb

@@ -2,6 +2,7 @@ $LOAD_PATH.unshift File.expand_path('../lib', __dir__)
 
 require 'enumerate_it'
 
+require 'logger' # Required by Rails 7.0 or older - https://stackoverflow.com/a/79385484/1445184
 require 'active_support/all'
 require 'active_record'
 

data/spec/support/test_classes.rb

@@ -2,7 +2,8 @@ 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_3: ['3', 'Hey, I am 3!'],
+    value_4: ['4', 'Héy, I ãm 2!']
   )
 end
 
@@ -72,7 +73,22 @@ def create_enumeration_class_with_sort_mode(sort_mode)
       foo:  %w[1 xyz],
       bar:  %w[2 fgh],
       omg:  %w[3 abc],
+      bra:  %w[4 ábc],
       zomg: %w[0 jkl]
     )
   end
 end
+
+class TestEnumerationWithCustomHelpers < EnumerateIt::Base
+  associate_values value_one: '1', value_two: '2'
+
+  custom_helpers do
+    def lookup(value)
+      { '1' => :one, '2' => :two }[value]
+    end
+
+    def boolean?(value)
+      value == '1'
+    end
+  end
+end

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: enumerate_it
 version: !ruby/object:Gem::Version
-  version: 4.0.0
+  version: 4.2.0
 platform: ruby
 authors:
 - Cássio Marques
 - Lucas Caton
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-04-26 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -155,18 +154,17 @@ dependencies:
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2'
+        version: '0'
 description: Enumerations for Ruby with some magic powers!
-email:
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -174,6 +172,7 @@ files:
 - ".github/dependabot.yml"
 - ".github/workflows/ci.yml"
 - ".gitignore"
+- ".prettierrc.json"
 - ".rspec"
 - ".rubocop.yml"
 - Appraisals
@@ -188,6 +187,9 @@ files:
 - gemfiles/rails_6.1.gemfile
 - gemfiles/rails_7.0.gemfile
 - gemfiles/rails_7.1.gemfile
+- gemfiles/rails_7.2.gemfile
+- gemfiles/rails_8.0.gemfile
+- gemfiles/rails_8.1.gemfile
 - lib/enumerate_it.rb
 - lib/enumerate_it/base.rb
 - lib/enumerate_it/class_methods.rb
@@ -209,7 +211,6 @@ metadata:
   source_code_uri: https://github.com/lucascaton/enumerate_it
   changelog_uri: https://github.com/lucascaton/enumerate_it/releases
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -224,8 +225,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.9
-signing_key:
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Ruby Enumerations
 test_files: []