active_enum 1.1.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e3ba1613a53b9f8ba7fcf13ff5b109f8c5e6ed02916fda74124dc9fdbac5055
-  data.tar.gz: 1da9d43ebd9a40564e7e7c46624d85f15216fe9906cf1ac85272cdc6454f1218
+  metadata.gz: 66c4c41a89eb9ab6b433bd74195b5da31f5e6f77ffd2bf6e4d71152f6f37ff43
+  data.tar.gz: 78f1bfd4039e743136f0258c84a042f13397f89629fd7fb324e501db15068b3d
 SHA512:
-  metadata.gz: d88b6864c8b46a21f02823989e90156f7a3aa631d45f5cebee5dd9aa448b6f5370a1614263fe144b8b497bbdae667a692421fb6583496fd04ed8fa75622b9a85
-  data.tar.gz: '09e15b242df5668932babded2d1a675831071474656b8368ddd6456638be509169fafb7136700d6a168fce4e690a6b9b12d730f665f98ce34af3bf9fa02aa934'
+  metadata.gz: cb0f30bd0ea8655166dc74c44f7e8748d49c131676fb5ebea4e5529d2c2117a305f806601a770fc659bef3254a9f9b324e0eac89f94738dd2221c4a80def2707
+  data.tar.gz: 91ed0d9875049d3453ea00e745f4e594c0fb7e7c36cb018d2e170da24e4b4a00007e856d2146d0fa07840d81941a34a830832817269e2f69ca55753ce72b1778

data/lib/active_enum/acts_as_enum.rb

@@ -6,7 +6,7 @@ module ActiveEnum
       def acts_as_enum(options={})
         extend ClassMethods
         class_attribute :active_enum_options
-        self.active_enum_options = options.reverse_merge(:name_column => 'name')
+        self.active_enum_options = options.reverse_merge(name_column: 'name')
         scope :enum_values, proc { select(Arel.sql("#{primary_key}, #{active_enum_options[:name_column]}")).
                                    where(active_enum_options[:conditions]).
                                    order(Arel.sql("#{primary_key} #{active_enum_options[:order]}")) }
@@ -33,14 +33,19 @@ module ActiveEnum
       end
 
       def [](index)
-        row = get_value(index)
+        get(index)
+      end
+
+      def get(index, raise_on_not_found: ActiveEnum.raise_on_not_found)
+        row = get_value(index, raise_on_not_found)
         return if row.nil?
         index.is_a?(Integer) ? row.send(active_enum_options[:name_column]) : row.id
       end
 
       # Access any meta data defined for a given id or name. Returns a hash.
-      def meta(index)
+      def meta(index, raise_on_not_found: ActiveEnum.raise_on_not_found)
         row = lookup_relation(index).unscope(:select).first
+        raise(ActiveEnum::NotFound, "#{self} value for '#{index}' was not found") if raise_on_not_found
         row&.attributes.except(primary_key.to_s, active_enum_options[:name_column].to_s)
       end
 
@@ -53,12 +58,12 @@ module ActiveEnum
 
       private
 
-      def get_value(index)
+      def get_value(index, raise_on_not_found = ActiveEnum.raise_on_not_found)
         lookup_relation(index).first || begin
-          raise(ActiveEnum::NotFound, "#{self} value for '#{index}' was not found") if ActiveEnum.raise_on_not_found
+          raise(ActiveEnum::NotFound, "#{self} value for '#{index}' was not found") if raise_on_not_found
         end
       end
-      
+
       def lookup_relation(index)
         if index.is_a?(Integer)
           enum_values.where(id: index)

data/lib/active_enum/base.rb

@@ -4,8 +4,6 @@ module ActiveEnum
   class NotFound < StandardError; end
 
   class Base
-    DEFAULT_GROUPED_SELECT_TRANSFORM = proc { |group| group&.html_safe }
-
     class << self
       attr_accessor :store
 
@@ -24,10 +22,12 @@ module ActiveEnum
         store.set(*id_and_name_and_meta(enum_value))
       end
 
-      # Specify order enum values are returned. 
+      # Specify order enum values are returned.
       # Allowed values are :asc, :desc or :natural
       #
       def order(order)
+        raise "Invalid order '#{order}' in #{self}" unless order.in?([:asc, :desc, :as_defined, :natural])
+
         if order == :as_defined
           ActiveSupport::Deprecation.warn("You are using the order :as_defined which has been deprecated. Use :natural.")
           order = :natural
@@ -56,12 +56,12 @@ module ActiveEnum
       end
 
       # Return enum values in an array suitable to pass to a Rails form select helper.
-      def to_select
-        store.values.map { |v| [v[1].html_safe, v[0]] }
+      def to_select(value_transform: ActiveEnum.default_select_value_transform)
+        store.values.map(&value_transform)
       end
 
       # Return enum values in a nested array suitable to pass to a Rails form grouped select helper.
-      def to_grouped_select(group_by, group_transform: DEFAULT_GROUPED_SELECT_TRANSFORM)
+      def to_grouped_select(group_by, group_transform: ActiveEnum.default_select_group_transform, value_transform: ActiveEnum.default_select_value_transform)
         store.values.group_by { |(_id, _name, meta)| (meta || {})[group_by] }.map { |group, collection|
           [ group_transform.call(group), collection.map { |(id, name, _meta)| [ name.html_safe, id ] } ]
         }
@@ -82,20 +82,23 @@ module ActiveEnum
 
       # Access id or name value. Pass an id number to retrieve the name or
       # a symbol or string to retrieve the matching id.
-      def get(index)
-        row = get_value(index)
+      def get(index, raise_on_not_found:  ActiveEnum.raise_on_not_found)
+        row = get_value(index, raise_on_not_found)
         return if row.nil?
         index.is_a?(Integer) ? row[1] : row[0]
       end
-      alias_method :[], :get
+
+      def [](index)
+        get(index)
+      end
 
       def include?(value)
         !get_value(value, false).nil?
       end
 
       # Access any meta data defined for a given id or name. Returns a hash.
-      def meta(index)
-        row = get_value(index)
+      def meta(index, raise_on_not_found: ActiveEnum.raise_on_not_found)
+        row = get_value(index, raise_on_not_found)
         row[2] || {} if row
       end
 

data/lib/active_enum/extensions.rb

@@ -41,7 +41,7 @@ module ActiveEnum
             attribute = attribute.to_sym
             attributes_enum[attribute] = enum
 
-            define_active_enum_methods_for_attribute(attribute)
+            define_active_enum_methods_for_attribute(attribute, options) unless options[:skip_accessors]
           rescue NameError => e
             raise e unless e.message =~ /uninitialized constant/
             raise ActiveEnum::EnumNotFound, "Enum class could not be found for attribute '#{attribute}' in class #{self}. Specify the enum class using the :with option."
@@ -54,10 +54,10 @@ module ActiveEnum
         enumerated_attributes && enumerated_attributes[attribute.to_sym]
       end
 
-      def define_active_enum_methods_for_attribute(attribute)
-        define_active_enum_read_method(attribute)
-        define_active_enum_write_method(attribute)
-        define_active_enum_question_method(attribute)
+      def define_active_enum_methods_for_attribute(attribute, options={})
+        define_active_enum_read_method(attribute) unless options[:skip_read]
+        define_active_enum_write_method(attribute) unless options[:skip_write]
+        define_active_enum_question_method(attribute) unless options[:skip_predicate]
       end
 
       def define_implicit_enum_class_for_attribute(attribute, block)
@@ -90,11 +90,11 @@ module ActiveEnum
             when nil
               #{ActiveEnum.use_name_as_value ? 'enum[value]' : 'value' }
             when :id
-              value if enum[value]
+              value if enum.get(value, raise_on_not_found: false)
             when :name
-              enum[value].dup
+              enum.get(value, raise_on_not_found: false).dup
             when Symbol
-              (enum.meta(value) || {})[arg].try(:dup)
+              (enum.meta(value, raise_on_not_found: false) || {})[arg].try(:dup)
             end
           end
         DEF

data/lib/active_enum/storage/i18n_store.rb

@@ -22,7 +22,7 @@ module ActiveEnum
       end
 
       def translate(key)
-        I18n.translate key, :scope => i18n_scope, :default => key
+        I18n.translate key, scope: i18n_scope, default: key
       end
 
     end

data/lib/active_enum/version.rb

@@ -1,3 +1,3 @@
 module ActiveEnum
-  VERSION = '1.1.0'
+  VERSION = '1.2.1'
 end

data/lib/active_enum.rb

@@ -20,6 +20,12 @@ module ActiveEnum
   mattr_accessor :storage_options
   @@storage_options = {}
 
+  mattr_accessor :default_select_value_transform
+  @@default_select_value_transform = proc { |value| [ value[1].html_safe, value[0] ] }
+
+  mattr_accessor :default_select_group_transform
+  @@default_select_group_transform = proc { |group| group&.html_safe }
+
   def storage=(*args)
     @@storage_options = args.extract_options!
     @@storage = args.first

data/spec/active_enum/acts_as_enum_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 describe ActiveEnum::ActsAsEnum do
   class Person < ActiveRecord::Base
-    acts_as_enum :name_column => 'first_name'
+    acts_as_enum name_column: 'first_name'
   end
 
   class TestPerson < ActiveRecord::Base
@@ -14,14 +14,14 @@ describe ActiveEnum::ActsAsEnum do
   end
 
   class SortedPerson < ActiveRecord::Base
-    acts_as_enum :name_column => 'first_name', :order => :desc
+    acts_as_enum name_column: 'first_name', order: :desc
   end
 
   before(:all) do
-    Person.create!(:first_name => 'Dave', :last_name => 'Smith')
-    Person.create!(:first_name => 'John', :last_name => 'Doe')
-    SortedPerson.create!(:first_name => 'Dave', :last_name => 'Smith')
-    SortedPerson.create!(:first_name => 'John', :last_name => 'Doe')
+    Person.create!(first_name: 'Dave', last_name: 'Smith')
+    Person.create!(first_name: 'John', last_name: 'Doe')
+    SortedPerson.create!(first_name: 'Dave', last_name: 'Smith')
+    SortedPerson.create!(first_name: 'John', last_name: 'Doe')
   end
 
   it "should mixin enum class methods only when act_as_enum defined" do
@@ -31,20 +31,43 @@ describe ActiveEnum::ActsAsEnum do
   end
 
   context "#[]" do
-    it "should return name column value when passing id to [] method" do
+    it "should return name column value when passed id" do
       expect(Person[1]).to eq('Dave')
     end
 
-    it "should return id column value when passing string name to [] method" do
+    it "should return id column value when passed string name" do
       expect(Person['Dave']).to eq(1)
       expect(Person['dave']).to eq(1)
     end
 
-    it "should return id column value when passing symbol name to [] method" do
+    it "should return id column value when passed symbol name" do
       expect(Person[:dave]).to eq(1)
     end
   end
 
+  context '#get' do
+    it "should return name column value when passed id" do
+      expect(Person.get(1)).to eq('Dave')
+    end
+
+    it "should return id column value when passed string name" do
+      expect(Person.get('Dave')).to eq(1)
+      expect(Person.get('dave')).to eq(1)
+    end
+
+    it "should return id column value when passed symbol name" do
+      expect(Person.get(:dave)).to eq(1)
+    end
+
+    it "should not raise for missing id when raise_on_not_found is false" do
+      expect { Person.get(0, raise_on_not_found: false) }.to_not raise_error
+    end
+
+    it "should raise for missing id when raise_on_not_found is true" do
+      expect { Person.get(0, raise_on_not_found: true) }.to raise_error(ActiveEnum::NotFound)
+    end
+  end
+
   context '#values' do
     it "should return array of arrays containing id and name column values" do
       expect(Person.values).to eq([[1, 'Dave'], [2, 'John']])

data/spec/active_enum/base_spec.rb

@@ -31,8 +31,8 @@ describe ActiveEnum::Base do
 
     it 'should return an array of arrays with all values defined as [id, name]' do
       enum = define_enum do
-        value :name => 'Name 1'
-        value :name => 'Name 2'
+        value name: 'Name 1'
+        value name: 'Name 2'
       end
       expect(enum.values).to eq([[1,'Name 1'], [2, 'Name 2']])
     end
@@ -41,14 +41,14 @@ describe ActiveEnum::Base do
   describe ".value" do
     it 'should allow me to define a value with an id and name' do
       enum = define_enum do
-        value :id => 1, :name => 'Name'
+        value id: 1, name: 'Name'
       end
       expect(enum.values).to eq([[1,'Name']])
     end
 
     it 'should allow me to define a value with a name only' do
       enum = define_enum do
-        value :name => 'Name'
+        value name: 'Name'
       end
       expect(enum.values).to eq([[1,'Name']])
     end
@@ -62,15 +62,15 @@ describe ActiveEnum::Base do
 
     it 'should allow to define meta data value with extra key value pairs' do
       enum = define_enum do
-        value :id => 1, :name => 'Name', :description => 'extra'
+        value id: 1, name: 'Name', description: 'extra'
       end
-      expect(enum.values).to eq([[1,'Name',{:description => 'extra'}]])
+      expect(enum.values).to eq([[1,'Name',{description: 'extra'}]])
     end
 
     it 'should increment value ids when defined without ids' do
       enum = define_enum do
-        value :name => 'Name 1'
-        value :name => 'Name 2'
+        value name: 'Name 1'
+        value name: 'Name 2'
       end
       expect(enum.values).to eq([[1,'Name 1'], [2, 'Name 2']])
     end
@@ -78,8 +78,8 @@ describe ActiveEnum::Base do
     it 'should raise error if the id is a duplicate' do
       expect {
         define_enum do
-          value :id => 1, :name => 'Name 1'
-          value :id => 1, :name => 'Name 2'
+          value id: 1, name: 'Name 1'
+          value id: 1, name: 'Name 2'
         end
       }.to raise_error(ActiveEnum::DuplicateValue)
     end
@@ -87,8 +87,8 @@ describe ActiveEnum::Base do
     it 'should raise error if the name is a duplicate' do
       expect {
         define_enum do
-          value :id => 1, :name => 'Name'
-          value :id => 2, :name => 'Name'
+          value id: 1, name: 'Name'
+          value id: 2, name: 'Name'
         end
       }.to raise_error(ActiveEnum::DuplicateValue)
     end
@@ -97,25 +97,40 @@ describe ActiveEnum::Base do
   describe ".meta" do
     it 'should return meta values hash for a given index value' do
       enum = define_enum do
-        value :id => 1, :name => 'Name', :description => 'extra'
+        value id: 1, name: 'Name', description: 'extra'
       end
-      expect(enum.meta(1)).to eq({:description => 'extra'})
+      expect(enum.meta(1)).to eq({description: 'extra'})
     end
 
     it 'should return empty hash for index with no meta defined' do
       enum = define_enum do
-        value :id => 1, :name => 'Name'
+        value id: 1, name: 'Name'
       end
       expect(enum.meta(1)).to eq({})
     end
 
+    context "with raise_on_not_found: false" do
+      let(:enum) {
+        define_enum do
+          value id: 1, name: 'Name', description: 'extra'
+        end
+      }
+
+      it "should raise ActiveEnum::NotFound for missing id" do
+        expect { enum.meta(0, raise_on_not_found: true) }.to raise_error(ActiveEnum::NotFound)
+      end
+
+      it "should raise ActiveEnum::NotFound for missing name" do
+        expect { enum.meta('Not a value', raise_on_not_found: true) }.to raise_error(ActiveEnum::NotFound)
+      end
+    end
   end
 
   context "sorting" do
     it 'should return values ascending by default' do
       enum = define_enum do
-        value :id => 2, :name => 'Name 2'
-        value :id => 1, :name => 'Name 1'
+        value id: 2, name: 'Name 2'
+        value id: 1, name: 'Name 1'
       end
       expect(enum.values).to eq([[1,'Name 1'], [2, 'Name 2']])
     end
@@ -123,8 +138,8 @@ describe ActiveEnum::Base do
     it 'should return sorted values by id using order setting' do
       enum = define_enum do
         order :desc
-        value :id => 1, :name => 'Name 1'
-        value :id => 2, :name => 'Name 2'
+        value id: 1, name: 'Name 1'
+        value id: 2, name: 'Name 2'
       end
       expect(enum.values).to eq([[2, 'Name 2'], [1,'Name 1']])
     end
@@ -132,9 +147,9 @@ describe ActiveEnum::Base do
     it 'should return sorted values by id using order setting' do
       enum = define_enum do
         order :natural
-        value :id => 3, :name => 'Name 3'
-        value :id => 1, :name => 'Name 1'
-        value :id => 2, :name => 'Name 2'
+        value id: 3, name: 'Name 3'
+        value id: 1, name: 'Name 1'
+        value id: 2, name: 'Name 2'
       end
       expect(enum.values).to eq([[3,'Name 3'], [1,'Name 1'], [2, 'Name 2']])
     end
@@ -143,8 +158,8 @@ describe ActiveEnum::Base do
   describe ".ids" do
     it 'should return array of ids' do
       enum = define_enum do
-        value :id => 1, :name => 'Name 1'
-        value :id => 2, :name => 'Name 2'
+        value id: 1, name: 'Name 1'
+        value id: 2, name: 'Name 2'
       end
       expect(enum.ids).to eq([1,2])
     end
@@ -153,8 +168,8 @@ describe ActiveEnum::Base do
   describe ".names" do
     it 'should return array of names' do
       enum = define_enum do
-        value :id => 1, :name => 'Name 1'
-        value :id => 2, :name => 'Name 2'
+        value id: 1, name: 'Name 1'
+        value id: 2, name: 'Name 2'
       end
       expect(enum.names).to eq(['Name 1', 'Name 2'])
     end
@@ -163,8 +178,8 @@ describe ActiveEnum::Base do
   context "element reference method" do
     let(:enum) {
       define_enum do
-        value :id => 1, :name => 'Name 1'
-        value :id => 2, :name => 'Name 2'
+        value id: 1, name: 'Name 1'
+        value id: 2, name: 'Name 2'
       end
     }
 
@@ -190,7 +205,7 @@ describe ActiveEnum::Base do
         expect(enum[0]).to eq nil
       end
 
-      context "with raise_on_not_found" do
+      context "with config raise_on_not_found" do
         with_config :raise_on_not_found, true
 
         it "should raise ActiveEnum::NotFound for missing id" do
@@ -204,11 +219,32 @@ describe ActiveEnum::Base do
     end
   end
 
+  describe '.get' do
+    with_config :raise_on_not_found, false
+
+    let(:enum) {
+      define_enum do
+        value id: 1, name: 'Name 1'
+        value id: 2, name: 'Name 2'
+      end
+    }
+
+    context "with raise_on_not_found: false" do
+      it "should raise ActiveEnum::NotFound for missing id" do
+        expect { enum.get('Not a value', raise_on_not_found: true) }.to raise_error(ActiveEnum::NotFound)
+      end
+
+      it "should raise ActiveEnum::NotFound for missing name" do
+        expect { enum.get(0, raise_on_not_found: true) }.to raise_error(ActiveEnum::NotFound)
+      end
+    end
+  end
+
   describe ".include?" do
     let(:enum) {
       define_enum do
-        value :id => 1, :name => 'Name 1'
-        value :id => 2, :name => 'Name 2'
+        value id: 1, name: 'Name 1'
+        value id: 2, name: 'Name 2'
       end
     }
 
@@ -232,8 +268,8 @@ describe ActiveEnum::Base do
   describe ".to_select" do
     it 'should return array for select helpers' do
       enum = define_enum do
-        value :id => 1, :name => 'Name 1'
-        value :id => 2, :name => 'Name 2'
+        value id: 1, name: 'Name 1'
+        value id: 2, name: 'Name 2'
       end
       expect(enum.to_select).to eq([['Name 1',1], ['Name 2',2]])
     end
@@ -241,8 +277,8 @@ describe ActiveEnum::Base do
     it 'should return array sorted using order setting' do
       enum = define_enum do
         order :desc
-        value :id => 1, :name => 'Name 1'
-        value :id => 2, :name => 'Name 2'
+        value id: 1, name: 'Name 1'
+        value id: 2, name: 'Name 2'
       end
       expect(enum.to_select).to eq([['Name 2',2], ['Name 1',1]])
     end
@@ -251,8 +287,8 @@ describe ActiveEnum::Base do
   describe ".to_grouped_select" do
     it 'should return array for grouped select helpers grouped by meta key value' do
       enum = define_enum do
-        value :id => 1, :name => 'Name 1', :category => 'Foo'
-        value :id => 2, :name => 'Name 2', :category => 'Bar'
+        value id: 1, name: 'Name 1', category: 'Foo'
+        value id: 2, name: 'Name 2', category: 'Bar'
       end
 
       expect(enum.to_grouped_select(:category)).to eq([
@@ -263,8 +299,8 @@ describe ActiveEnum::Base do
 
     it 'should group any value missing the group_by key by nil' do
       enum = define_enum do
-        value :id => 1, :name => 'Name 1', :category => 'Foo'
-        value :id => 2, :name => 'Name 2'
+        value id: 1, name: 'Name 1', category: 'Foo'
+        value id: 2, name: 'Name 2'
       end
 
       expect(enum.to_grouped_select(:category)).to eq([
@@ -275,8 +311,8 @@ describe ActiveEnum::Base do
 
     it 'shoud transform group name with custom group transform proc' do
       enum = define_enum do
-        value :id => 1, :name => 'Name 1', :category => 'Foo'
-        value :id => 2, :name => 'Name 2'
+        value id: 1, name: 'Name 1', category: 'Foo'
+        value id: 2, name: 'Name 2'
       end
 
       expect(enum.to_grouped_select(:category, group_transform: proc { |group| group.to_s.upcase })).to eq([
@@ -289,8 +325,8 @@ describe ActiveEnum::Base do
   describe ".to_h" do
     it 'should return hash of ids as keys and names as values' do
       enum = define_enum do
-        value :id => 1, :name => 'Name 1'
-        value :id => 2, :name => 'Name 2'
+        value id: 1, name: 'Name 1'
+        value id: 2, name: 'Name 2'
       end
       expect(enum.to_h).to eq({ 1 => 'Name 1', 2 => 'Name 2' })
     end
@@ -299,8 +335,8 @@ describe ActiveEnum::Base do
   describe ".length" do
     it 'should return number of values defined' do
       enum = define_enum do
-        value :id => 1, :name => 'Name 1'
-        value :id => 2, :name => 'Name 2'
+        value id: 1, name: 'Name 1'
+        value id: 2, name: 'Name 2'
       end
       expect(enum.length).to eq 2
     end
@@ -312,8 +348,8 @@ describe ActiveEnum::Base do
 
     it 'should be aliased as size' do
       enum = define_enum do
-        value :id => 1, :name => 'Name 1'
-        value :id => 2, :name => 'Name 2'
+        value id: 1, name: 'Name 1'
+        value id: 2, name: 'Name 2'
       end
       expect(enum.size).to eq enum.length
     end

data/spec/active_enum/extensions_spec.rb

@@ -2,14 +2,14 @@ require "spec_helper"
 
 describe ActiveEnum::Extensions do
   class Sex < ActiveEnum::Base
-    value :id => 1, :name => 'Male'
-    value :id => 2, :name => 'Female'
+    value id: 1, name: 'Male'
+    value id: 2, name: 'Female'
   end
 
   class Accepted < ActiveEnum::Base
-    value :id => 0, :name => 'No'
-    value :id => 1, :name => 'Definitely'
-    value :id => 2, :name => 'Maybe'
+    value id: 0, name: 'No'
+    value id: 1, name: 'Definitely'
+    value id: 2, name: 'Maybe'
   end
 
   it 'should add class :enumerate method to ActiveRecord' do
@@ -21,17 +21,17 @@ describe ActiveEnum::Extensions do
   end
 
   it 'should allow multiple attributes to be enumerated with same enum' do
-    Person.enumerate :attending, :staying, :with => Accepted
+    Person.enumerate :attending, :staying, with: Accepted
 
     expect(Person.active_enum_for(:attending)).to eq(Accepted)
     expect(Person.active_enum_for(:staying)).to eq(Accepted)
   end
 
   it 'should allow multiple attributes to be enumerated with different enums' do
-    Person.enumerate :sex, :with => Sex
-    Person.enumerate :attending, :with => Accepted
+    Person.enumerate :sex, with: Sex
+    Person.enumerate :attending, with: Accepted
 
-    expect(Person.active_enum_for(:sex)).to eq(Sex) 
+    expect(Person.active_enum_for(:sex)).to eq(Sex)
     expect(Person.active_enum_for(:attending)).to eq(Accepted)
   end
 
@@ -43,7 +43,7 @@ describe ActiveEnum::Extensions do
 
   it 'should create enum namespaced enum class from block' do
     Person.enumerate :sex do
-      value :id => 1, :name => 'Male'
+      value id: 1, name: 'Male'
     end
     expect(Person.active_enum_for(:sex)).to eq(::Person::Sex)
   end
@@ -55,11 +55,11 @@ describe ActiveEnum::Extensions do
   end
 
   context "attribute" do
-    let(:person) { Person.new(:sex => 1) }
+    let(:person) { Person.new(sex: 1) }
 
     before(:all) do
       reset_class Person do
-        enumerate :sex, :with => Sex
+        enumerate :sex, with: Sex
       end
     end
 
@@ -82,7 +82,7 @@ describe ActiveEnum::Extensions do
     end
 
     context "with nil value" do
-      let(:person) { Person.new(:sex => nil) }
+      let(:person) { Person.new(sex: nil) }
 
       it 'should return nil with no arg' do
         expect(person.sex).to be_nil
@@ -100,7 +100,7 @@ describe ActiveEnum::Extensions do
         expect(person.sex(:enum)).to eq(Sex)
       end
 
-      context "and raise_on_not_found" do
+      context "and global raise_on_not_found set to true" do
         with_config :raise_on_not_found, true
 
         it "should not raise error when attribute is nil" do
@@ -110,7 +110,7 @@ describe ActiveEnum::Extensions do
     end
 
     context "with undefined value" do
-      let(:person) { Person.new(:sex => -1) }
+      let(:person) { Person.new(sex: -1) }
 
       it 'should return value with no arg' do
         expect(person.sex).to eq(-1)
@@ -127,16 +127,24 @@ describe ActiveEnum::Extensions do
       it 'should return enum class for attribute' do
         expect(person.sex(:enum)).to eq(Sex)
       end
+
+      context "and global raise_on_not_found set to true" do
+        with_config :raise_on_not_found, true
+
+        it "should not raise error when attribute value is invalid" do
+          expect { person.sex(:id) }.to_not raise_error
+        end
+      end
     end
 
     context "with meta data" do
-      let(:person) { Person.new(:sex =>1) }
+      let(:person) { Person.new(sex: 1) }
 
       before(:all) do
         reset_class Person do
           enumerate :sex do
-            value :id => 1, :name => 'Male',   :description => 'Man'
-            value :id => 2, :name => 'Female', :description => 'Woman'
+            value id: 1, name: 'Male',   description: 'Man'
+            value id: 2, name: 'Female', description: 'Woman'
           end
         end
       end
@@ -153,6 +161,15 @@ describe ActiveEnum::Extensions do
         person.sex = nil
         expect(person.sex(:description)).to be_nil
       end
+
+      context "and global raise_on_not_found set to true" do
+        let(:person) { Person.new(sex: -1) }
+        with_config :raise_on_not_found, true
+
+        it "should not raise error when attribute value is invalid" do
+          expect { person.sex(:nonexistent) }.to_not raise_error
+        end
+      end
     end
 
     context "question method" do
@@ -201,11 +218,11 @@ describe ActiveEnum::Extensions do
       before(:all) { ActiveEnum.use_name_as_value = true }
       let(:person) { Person.new(:sex =>1) }
 
-      before do 
+      before do
         reset_class Person do
-          enumerate :sex, :with => Sex
+          enumerate :sex, with: Sex
         end
-      end 
+      end
 
       it 'should return text name value for attribute' do
         expect(person.sex).to eq('Male')
@@ -218,6 +235,27 @@ describe ActiveEnum::Extensions do
       after(:all) { ActiveEnum.use_name_as_value = false }
     end
 
+    context "with skip_accessors: true" do
+      before(:all) do
+        reset_class Person do
+          enumerate :sex, with: Sex, skip_accessors: true
+        end
+      end
+
+      it 'read method should not accept arg' do
+        expect{ person.sex(:name) }.to raise_error ArgumentError
+      end
+
+      it 'write method should not accept name' do
+        person.sex = :male
+        expect(person.sex).to_not eq Sex[:male]
+      end
+
+      it 'question method should not accept arg' do
+        expect{ person.sex?(:male) }.to raise_error ArgumentError
+      end
+    end
+
   end
 
 end

data/spec/active_enum/form_helpers/simple_form_spec.rb

@@ -3,87 +3,87 @@ require "spec_helper"
 require 'simple_form'
 require 'active_enum/form_helpers/simple_form'
 
-describe ActiveEnum::FormHelpers::SimpleForm, :type => :helper do
+describe ActiveEnum::FormHelpers::SimpleForm, type: :helper do
   include SimpleForm::ActionViewExtensions::FormHelper
 
   before do
     allow(controller).to receive(:action_name).and_return('new')
     reset_class Person do
       enumerate :sex do
-        value :id => 1, :name => 'Male'
-        value :id => 2, :name => 'Female'
+        value id: 1, name: 'Male'
+        value id: 2, name: 'Female'
       end
 
       enumerate :employment_status do
-        value :id => 1, :name => 'Full-time', group: 'Waged'
-        value :id => 3, :name => 'Part-time', group: 'Waged'
-        value :id => 4, :name => 'Casual', group: 'Waged'
-        value :id => 5, :name => 'Student', group: 'Un-waged'
-        value :id => 6, :name => 'Retired', group: 'Un-waged'
-        value :id => 7, :name => 'Unemployed', group: 'Un-waged'
-        value :id => 8, :name => 'Carer', group: 'Un-waged'
+        value id: 1, name: 'Full-time', group: 'Waged'
+        value id: 3, name: 'Part-time', group: 'Waged'
+        value id: 4, name: 'Casual', group: 'Waged'
+        value id: 5, name: 'Student', group: 'Un-waged'
+        value id: 6, name: 'Retired', group: 'Un-waged'
+        value id: 7, name: 'Unemployed', group: 'Un-waged'
+        value id: 8, name: 'Carer', group: 'Un-waged'
       end
     end
   end
 
   it "should use enum input type for enumerated attribute" do
-    output = simple_form_for(Person.new, :url => people_path) do |f|
+    output = simple_form_for(Person.new, url: people_path) do |f|
       concat f.input(:sex)
     end
     expect(output).to have_selector('select#person_sex')
-    expect(output).to have_xpath('//option[@value=1]', :text => 'Male')
-    expect(output).to have_xpath('//option[@value=2]', :text => 'Female')
+    expect(output).to have_xpath('//option[@value=1]', text: 'Male')
+    expect(output).to have_xpath('//option[@value=2]', text: 'Female')
   end
 
   it "should use explicit :enum input type" do
-    output = simple_form_for(Person.new, :url => people_path) do |f|
-      concat f.input(:sex, :as => :enum)
+    output = simple_form_for(Person.new, url: people_path) do |f|
+      concat f.input(:sex, as: :enum)
     end
     expect(output).to have_selector('select#person_sex')
-    expect(output).to have_xpath('//option[@value=1]', :text => 'Male')
-    expect(output).to have_xpath('//option[@value=2]', :text => 'Female')
+    expect(output).to have_xpath('//option[@value=1]', text: 'Male')
+    expect(output).to have_xpath('//option[@value=2]', text: 'Female')
   end
 
   it "should use explicit :grouped_enum input type" do
-    output = simple_form_for(Person.new, :url => people_path) do |f|
-      concat f.input(:employment_status, :as => :grouped_enum, :group_by => :group)
+    output = simple_form_for(Person.new, url: people_path) do |f|
+      concat f.input(:employment_status, as: :grouped_enum, group_by: :group)
     end
     expect(output).to have_selector('select#person_employment_status')
-    expect(output).to have_xpath('//optgroup[@label="Waged"]/option[@value=1]', :text => 'Full-time')
-    expect(output).to have_xpath('//optgroup[@label="Un-waged"]/option[@value=8]', :text => 'Carer')
+    expect(output).to have_xpath('//optgroup[@label="Waged"]/option[@value=1]', text: 'Full-time')
+    expect(output).to have_xpath('//optgroup[@label="Un-waged"]/option[@value=8]', text: 'Carer')
   end
 
   it "should not use enum input type if :as option indicates other type" do
-    output = simple_form_for(Person.new, :url => people_path) do |f|
-      concat f.input(:sex, :as => :string)
+    output = simple_form_for(Person.new, url: people_path) do |f|
+      concat f.input(:sex, as: :string)
     end
     expect(output).to have_selector('input#person_sex')
   end
 
   it "should raise error if attribute for enum input is not enumerated" do
     expect {
-      simple_form_for(Person.new, :url => people_path) do |f|
-        f.input(:attending, :as => :enum)
+      simple_form_for(Person.new, url: people_path) do |f|
+        f.input(:attending, as: :enum)
       end
     }.to raise_error "Attribute 'attending' has no enum class"
   end
 
   it "should not use enum input type if class does not support ActiveEnum" do
-    output = simple_form_for(NotActiveRecord.new, :as => :not_active_record, :url => people_path) do |f|
+    output = simple_form_for(NotActiveRecord.new, as: :not_active_record, url: people_path) do |f|
       concat f.input(:name)
     end
     expect(output).to have_selector('input#not_active_record_name')
   end
 
   it "should allow non-enum fields to use default input determination" do
-    output = simple_form_for(Person.new, :url => people_path) do |f|
+    output = simple_form_for(Person.new, url: people_path) do |f|
       concat f.input(:first_name)
     end
     expect(output).to have_selector('input#person_first_name')
   end
 
   it "should allow models without enumerated attributes to behave normally" do
-    output = simple_form_for(NoEnumPerson.new, :url => people_path) do |f|
+    output = simple_form_for(NoEnumPerson.new, url: people_path) do |f|
       concat f.input(:first_name)
     end
     expect(output).to have_selector('input#no_enum_person_first_name')

data/spec/active_enum/storage/i18n_store_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 describe ActiveEnum::Storage::I18nStore do
   class TestI18nStoreEnum < ActiveEnum::Base; end
-  
+
   let(:enum_class) { TestI18nStoreEnum }
   let(:enum_key) { enum_class.name.underscore }
   let(:store) { ActiveEnum::Storage::I18nStore.new(enum_class, :asc) }
@@ -31,8 +31,8 @@ describe ActiveEnum::Storage::I18nStore do
     end
 
     it 'should store value of id, name and meta hash' do
-      store.set 1, 'test name', :description => 'meta'
-      expect(store.send(:_values)).to eq([[1, 'test name', {:description => 'meta'}]])
+      store.set 1, 'test name', description: 'meta'
+      expect(store.send(:_values)).to eq([[1, 'test name', { description: 'meta' }]])
     end
 
     it 'should raise error if duplicate id' do
@@ -59,8 +59,8 @@ describe ActiveEnum::Storage::I18nStore do
 
   describe "#values" do
     before do
-      I18n.backend.store_translations :en, :active_enum => { enum_key => { :thanks => 'Thanks' } }
-      I18n.backend.store_translations :fr, :active_enum => { enum_key => { :thanks => 'Merce' } }
+      I18n.backend.store_translations :en, active_enum: { enum_key => { thanks: 'Thanks' } }
+      I18n.backend.store_translations :fr, active_enum: { enum_key => { thanks: 'Merce' } }
     end
 
     it 'should return array of stored values for current locale' do
@@ -77,7 +77,7 @@ describe ActiveEnum::Storage::I18nStore do
 
   describe "#get_by_id" do
     before do
-      I18n.backend.store_translations :en, :active_enum => { enum_key => { 'test' => 'Testing' } }
+      I18n.backend.store_translations :en, active_enum: { enum_key => { 'test' => 'Testing' } }
       I18n.locale = :en
     end
 
@@ -87,8 +87,8 @@ describe ActiveEnum::Storage::I18nStore do
     end
 
     it 'should return the value with meta for a given id' do
-      store.set 1, 'test', :description => 'meta'
-      expect(store.get_by_id(1)).to eq([1, 'Testing', { :description => 'meta' }])
+      store.set 1, 'test', description: 'meta'
+      expect(store.get_by_id(1)).to eq([1, 'Testing', { description: 'meta' }])
     end
 
     it 'should return nil when id not found' do
@@ -104,7 +104,7 @@ describe ActiveEnum::Storage::I18nStore do
 
   describe "#get_by_name" do
     before do
-      I18n.backend.store_translations :en, :active_enum => { enum_key => { 'test' => 'Testing' } }
+      I18n.backend.store_translations :en, active_enum: { enum_key => { 'test' => 'Testing' } }
       I18n.locale = :en
     end
 
@@ -114,8 +114,8 @@ describe ActiveEnum::Storage::I18nStore do
     end
 
     it 'should return the value with meta for a given name' do
-      store.set 1, 'test', :description => 'meta'
-      expect(store.get_by_name('test')).to eq([1, 'Testing', { :description => 'meta' }])
+      store.set 1, 'test', description: 'meta'
+      expect(store.get_by_name('test')).to eq([1, 'Testing', { description: 'meta' }])
     end
 
     it 'should return nil when name not found' do
@@ -125,7 +125,7 @@ describe ActiveEnum::Storage::I18nStore do
 
   describe "#sort!" do
     before do
-      I18n.backend.store_translations :en, :active_enum => { enum_key => { 
+      I18n.backend.store_translations :en, active_enum: { enum_key => {
         'name1' => 'Name 1',
         'name2' => 'Name 2',
         'name3' => 'Name 3',

data/spec/active_enum/storage/memory_store_spec.rb

@@ -13,8 +13,8 @@ describe ActiveEnum::Storage::MemoryStore do
     end
 
     it 'should store value of id, name and meta hash' do
-      store.set 1, 'test name', :description => 'meta'
-      expect(store.values).to eq([[1, 'test name', {:description => 'meta'}]])
+      store.set 1, 'test name', description: 'meta'
+      expect(store.values).to eq([[1, 'test name', {description: 'meta'}]])
     end
 
     it 'should raise error if duplicate id' do
@@ -54,8 +54,8 @@ describe ActiveEnum::Storage::MemoryStore do
 
   describe "#get_by_id" do
     it 'should return the value for a given id' do
-      store.set 1, 'test name', :description => 'meta'
-      expect(store.get_by_id(1)).to eq([1, 'test name', {:description => "meta"}])
+      store.set 1, 'test name', description: 'meta'
+      expect(store.get_by_id(1)).to eq([1, 'test name', {description: "meta"}])
     end
 
     it 'should return nil when id not found' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_enum
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.1
 platform: ruby
 authors:
 - Adam Meehan
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-07-04 00:00:00.000000000 Z
+date: 2024-03-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -87,7 +87,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3.1
+rubygems_version: 3.5.6
 signing_key:
 specification_version: 4
 summary: Define enum classes in Rails and use them to enumerate ActiveRecord attributes