enum_ish 1.4.1 → 1.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 34d21d01c11cb32143d1ce656228165fc93059f820b60f2cc109668a61e70680
-  data.tar.gz: a26baa4da8d0ae6e5ad1dce8cdf169f24fbe79ec8ddc88acf5fb2180db817b6f
+  metadata.gz: 8fb31764431d97fa544b90f3d7534f3c96d2fc1acbbfb7d3d44fcaa73da3064e
+  data.tar.gz: 84897de0db79b886700f9d061159798aab16dbc120ec52d87d94677a8417de49
 SHA512:
-  metadata.gz: cc05a7517f723a1df0f521e031d2c171ed6a3ad0614974326c52464ce5ecf7f89b5e591f0da34a15fac70212ab44ab883f64b7dff45b67ba865c153c2ebd3dd9
-  data.tar.gz: 8cb363ef8d2f7988dee963d3baef608b076484afa46268f1d08a7b21fe5ef12c736d09cb05ba3e6efaa01ce8b6acbf85f0748aef6d39a407338b499aa94f22c4
+  metadata.gz: 9130d50fa059e0a1a0e9237e07b73ad7564a55e500a712ea7c15efdd232cfe69ef67cc09e222b124a819a44b57b2e9da078d9b9bb590c08b8f21e6980392cfac
+  data.tar.gz: 204ae64789c49108e1e9faa137aa6737c5f1d7a1c5f79cf55e354e8a80ae4fb11c89235f4dfb5f018ec89a7a7b9c50141f9a2777235a90bced4d946444e9038f

data/.github/workflows/ci.yml

@@ -4,27 +4,41 @@ on: [push, pull_request]
 
 jobs:
   test:
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-20.04
     strategy:
       fail-fast: false
       matrix:
-        ruby: [2.3, 2.4, 2.5, 2.6, 2.7, 3.0]
-        gemfile: ['rails50', 'rails51', 'rails52', 'rails60', 'rails61']
+        ruby: [2.3, 2.4, 2.5, 2.6, 2.7, '3.0', 3.1]
+        gemfile: ['rails50', 'rails51', 'rails52', 'rails60', 'rails61', 'rails70']
         exclude:
           - ruby: 2.3
             gemfile: rails60
           - ruby: 2.3
             gemfile: rails61
+          - ruby: 2.3
+            gemfile: rails70
           - ruby: 2.4
             gemfile: rails60
           - ruby: 2.4
             gemfile: rails61
+          - ruby: 2.4
+            gemfile: rails70
+          - ruby: 2.5
+            gemfile: rails70
+          - ruby: 2.6
+            gemfile: rails70
           - ruby: 3.0
             gemfile: rails50
           - ruby: 3.0
             gemfile: rails51
           - ruby: 3.0
             gemfile: rails52
+          - ruby: 3.1
+            gemfile: rails50
+          - ruby: 3.1
+            gemfile: rails51
+          - ruby: 3.1
+            gemfile: rails52
 
     name: ruby ${{ matrix.ruby }}, ${{ matrix.gemfile }}
 

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 # CHANGELOG
 
+## 1.6.1
+
+* Support activerecord 7.0.
+
+## 1.6.0
+
+* Add `EnumIsh.config.defaults` which allows to set default options for `enum_ish`.
+* Don't convert dictionary value to string.
+
+## 1.5.1
+
+* Fix wrong cache lookup.
+
+## 1.5.0
+
+* Add dictionary cache feature.
+* Change module inclusion. Use 'include EnumIsh::Base' instead of 'extend EnumIsh'.
+* Move configuration method to `EnumIsh`. Use `EnumIsh.configure` instead of 'EnumIsh::Config.configure'.
+
 ## 1.4.1
 
 * Avoid overwrite of superclass's `_enum_ish_enums`.

data/README.md

@@ -26,7 +26,7 @@ Extend your class using EnumIsh and define an enum-like field:
 
 ```ruby
 class User
-  extend EnumIsh
+  include EnumIsh::Base
   attr_accessor :status                    # status is a string field
   enum_ish :status, ['enable', 'disable']  # status has 'enable' or 'disable'
 end
@@ -82,7 +82,7 @@ Set default value:
 
 ```ruby
 class User
-  extend EnumIsh
+  include EnumIsh::Base
   attr_accessor :status
   enum_ish :status, ['enable', 'disable'], default: 'enable'
 end
@@ -95,7 +95,7 @@ Use default value with block:
 
 ```ruby
 class User
-  extend EnumIsh
+  include EnumIsh::Base
   attr_accessor :status, :flag
   enum_ish :status, ['enable', 'disable'], default: -> { flag ? 'enable' : 'disable' }
 end
@@ -110,7 +110,7 @@ Generate predicate methods:
 
 ```ruby
 class User
-  extend EnumIsh
+  include EnumIsh::Base
   attr_accessor :status
   enum_ish :status, ['enable', 'disable'], predicate: true
 end
@@ -125,7 +125,7 @@ Without prefix:
 
 ```ruby
 class User
-  extend EnumIsh
+  include EnumIsh::Base
   attr_accessor :status
   enum_ish :status, ['enable', 'disable'], predicate: { prefix: false }
 end
@@ -142,7 +142,7 @@ Generate getter and setter for aliased symbols instead of raw values:
 
 ```ruby
 class User
-  extend EnumIsh
+  include EnumIsh::Base
   attr_accessor :status
   enum_ish :status, { _enable: 'enable', _disable: 'disable' }, accessor: true
 end
@@ -161,7 +161,7 @@ Generate accessor:
 
 ```ruby
 class User < ActiveRecord::Base
-  extend EnumIsh
+  include EnumIsh::Base
   enum_ish :status, { _enable: 'enable', _disable: 'disable' }, accessor: true
 end
 
@@ -174,7 +174,7 @@ Generate scope:
 
 ```ruby
 class User < ActiveRecord::Base
-  extend EnumIsh
+  include EnumIsh::Base
   enum_ish :status, ['enable', 'disable'], scope: true
 end
 
@@ -188,7 +188,7 @@ Generate validation:
 
 ```ruby
 class User < ActiveRecord::Base
-  extend EnumIsh
+  include EnumIsh::Base
   enum_ish :status, ['enable', 'disable'], validate: true
 end
 
@@ -197,6 +197,17 @@ user.status = 'INVALID'
 user.valid?  #=> false
 ```
 
+### Dictionary cache
+
+You can enable dictionary cache using rack middleware:
+
+```ruby
+Rails.application.config.middleware.use EnumIsh::DictionaryCache
+```
+
+This middleware enables dictionary cache for each request.
+Performance of dictionary lookup will be improved in case one dictionary is used repeatedly in the same request.
+
 ## Contributing
 
 Bug reports and pull requests are welcome at https://github.com/kanety/enum_ish.

data/gemfiles/rails60.gemfile

@@ -1,5 +1,6 @@
 source 'https://rubygems.org'
 
 gem "rails", "~> 6.0.0"
+gem "psych", "~> 3.3.0"
 
 gemspec path: "../"

data/gemfiles/rails70.gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gem "rails", "~> 7.0.1"
+
+gemspec path: "../"

data/lib/enum_ish/active_record_definer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'active_record_enum_type'
 
 module EnumIsh
@@ -9,7 +11,7 @@ module EnumIsh
         after_initialize method
         define_method method do
           if respond_to?(enum.name) && public_send(enum.name).nil?
-            default = enum.setting[:default]
+            default = enum.default
             default = instance_exec(&default) if default.kind_of?(Proc)
             public_send("#{enum.name}=", default)
           end
@@ -19,29 +21,33 @@ module EnumIsh
 
     def define_accessor(enum)
       @klass.class_eval do
-        define_method "#{Config.raw_prefix}#{enum.name}#{Config.raw_suffix}" do
+        define_method enum.raw_method do
           value = read_attribute(enum.name)
           enum.mapping.fetch(value, value)
         end
 
-        args =
-          if ActiveRecord.version > Gem::Version.new('6.1.0.a')
-            [enum.name]
-          else
-            [enum.name, :enum]
+        if ActiveRecord.version > Gem::Version.new('7.0.0.a')
+          attribute(enum.name) do |subtype|
+            EnumIsh::ActiveRecordEnumType.new(enum.name, enum.mapping, subtype)
+          end
+        elsif ActiveRecord.version > Gem::Version.new('6.1.0.a')
+          decorate_attribute_type(enum.name) do |subtype|
+            EnumIsh::ActiveRecordEnumType.new(enum.name, enum.mapping, subtype)
+          end
+        else
+          decorate_attribute_type(enum.name, :enum) do |subtype|
+            EnumIsh::ActiveRecordEnumType.new(enum.name, enum.mapping, subtype)
           end
-        decorate_attribute_type(*args) do |subtype|
-          EnumIsh::ActiveRecordEnumType.new(enum.name, enum.mapping, subtype)
         end
       end
     end
 
     def define_scope(enum)
       @klass.class_eval do
-        scope "#{Config.scope_prefix}#{enum.name}#{Config.scope_suffix}", ->(*value) {
+        scope enum.scope_method, ->(*value) {
           where(enum.name => enum.mapping.fetch(value, value))
         }
-        scope "#{Config.scope_prefix}#{enum.name}_not#{Config.scope_suffix}", ->(*value) {
+        scope enum.scope_method(:negative), ->(*value) {
           where.not(enum.name => enum.mapping.fetch(value, value))
         }
       end

data/lib/enum_ish/active_record_enum_type.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module EnumIsh
   class ActiveRecordEnumType < ActiveRecord::Type::Value
     def initialize(name, mapping, subtype)

data/lib/enum_ish/base.rb

@@ -0,0 +1,29 @@
+require_relative 'enum'
+require_relative 'dictionary'
+require_relative 'errors'
+require_relative 'definer'
+require_relative 'active_record_definer' if defined?(ActiveRecord::Base)
+
+module EnumIsh
+  module Base
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :_enum_ish_enums
+      self._enum_ish_enums = {}
+    end
+
+    class_methods do
+      def enum_ish(name, map, setting = {})
+        enum = Enum.new(name, map, Config.defaults.merge(setting))
+        self._enum_ish_enums = _enum_ish_enums.merge(name.to_sym => enum)
+
+        if defined?(ActiveRecord::Base) && ancestors.include?(ActiveRecord::Base)
+          ActiveRecordDefiner.new(self).define(enum)
+        else
+          Definer.new(self).define(enum)
+        end
+      end
+    end
+  end
+end

data/lib/enum_ish/config.rb

@@ -1,6 +1,11 @@
+# frozen_string_literal: true
+
 module EnumIsh
   class Config
-    @@options = {
+    class_attribute :data
+
+    self.data = {
+      defaults: { text: true, options: true },
       text_prefix: '',
       text_suffix: '_text',
       options_prefix: '',
@@ -11,19 +16,13 @@ module EnumIsh
       scope_suffix: ''
     }
 
-    @@options.keys.each do |key|
+    data.keys.each do |key|
       define_singleton_method "#{key}" do
-        @@options[key]
+        data[key]
       end
 
       define_singleton_method "#{key}=" do |val|
-        @@options[key] = val
-      end
-    end
-
-    class << self
-      def configure
-        yield self
+        data[key] = val
       end
     end
   end

data/lib/enum_ish/definer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module EnumIsh
   class Definer
     def initialize(klass)
@@ -5,8 +7,8 @@ module EnumIsh
     end
 
     def define(enum)
-      [:text, :options, :predicate, :default, :accessor, :validate, :scope].each do |type|
-        send("define_#{type}", enum) if enum.setting[type]
+      enum.features.each do |feature|
+        send("define_#{feature}", enum)
       end
     end
 
@@ -14,7 +16,7 @@ module EnumIsh
 
     def define_text(enum)
       @klass.class_eval do
-        define_method "#{Config.text_prefix}#{enum.name}#{Config.text_suffix}" do |options = {}|
+        define_method enum.text_method do |options = {}|
           dict = Dictionary.new(self.class, enum, options)
           dict.translate_value(public_send(enum.name))
         end
@@ -23,7 +25,7 @@ module EnumIsh
 
     def define_options(enum)
       @klass.class_eval do
-        define_singleton_method "#{Config.options_prefix}#{enum.name}#{Config.options_suffix}" do |options = {}|
+        define_singleton_method enum.options_method do |options = {}|
           dict = Dictionary.new(self, enum, options)
           dict.translate_options
         end
@@ -31,24 +33,14 @@ module EnumIsh
     end
 
     def define_predicate(enum)
-      enum.mapping.each do |enum_key, enum_value|
-        method_name = if enum.setting[:predicate].is_a?(Hash) && enum.setting[:predicate][:prefix] == false
-          "#{enum_key}?"
-        else
-          "#{enum.name}_#{enum_key}?"
-        end
-        target_value = if enum.setting[:accessor]
-          enum_key
-        else
-          enum_value
-        end
+      enum.mapping.keys.each do |key|
         @klass.class_eval do
-          define_method method_name.tr('.', '_') do
+          define_method enum.predicate_method(key) do
             value = public_send(enum.name)
             if value.is_a?(Array)
-              value == [target_value]
+              value == [enum.value(key)]
             else
-              value == target_value
+              value == enum.value(key)
             end
           end
         end
@@ -61,7 +53,7 @@ module EnumIsh
         define_method :initialize do |*args|
           super(*args)
           if respond_to?(enum.name) && public_send(enum.name).nil?
-            default = enum.setting[:default]
+            default = enum.default
             default = instance_exec(&default) if default.kind_of?(Proc)
             public_send("#{enum.name}=", default)
           end
@@ -72,7 +64,7 @@ module EnumIsh
 
     def define_accessor(enum)
       @klass.class_eval do
-        define_method "#{Config.raw_prefix}#{enum.name}#{Config.raw_suffix}" do
+        define_method enum.raw_method do
           instance_variable_get("@#{enum.name}")
         end
         define_method "#{enum.name}" do
@@ -85,13 +77,8 @@ module EnumIsh
     end
 
     def define_validate(enum)
-      targets = if enum.setting[:accessor]
-        enum.mapping.keys
-      else
-        enum.mapping.values
-      end
       @klass.class_eval do
-        validates enum.name, inclusion: { in: targets }, allow_nil: true
+        validates enum.name, inclusion: { in: enum.values }, allow_nil: true
       end
     end
 

data/lib/enum_ish/dictionary.rb

@@ -1,10 +1,14 @@
+# frozen_string_literal: true
+
+require_relative 'dictionary_lookup'
+
 module EnumIsh
   class Dictionary
     def initialize(klass, enum, options = {})
       @klass = klass
       @enum = enum
       @options = options
-      @dict = load_dict
+      @dict = cache { DictionaryLookup.new(@klass, @enum, @options).call }
     end
 
     def translate_value(value)
@@ -16,57 +20,20 @@ module EnumIsh
     end
 
     def translate_options
-      @dict.to_a.map { |value, label| [label, value] }
+      @dict.to_a.map { |value, text| [text, value] }
     end
 
     private
 
-    def load_dict
-      i18n = load_from_i18n.transform_keys { |k| k.to_s.to_sym }
-
-      dict = {}
-      if @enum.setting[:accessor]
-        @enum.mapping.each { |k, v| dict[k] = i18n[k].to_s }
+    def cache
+      if (cache = EnumIsh::DictionaryCache.cache) != nil
+        cache[I18n.locale] ||= {}
+        cache[I18n.locale][@klass] ||= {}
+        cache[I18n.locale][@klass][@enum] ||= {}
+        cache[I18n.locale][@klass][@enum][@options] ||= yield
       else
-        @enum.mapping.each { |k, v| dict[v] = i18n[k].to_s }
-      end
-
-      filter(dict)
-    end
-
-    def load_from_i18n
-      key = [@enum.name, @options[:format]].compact.join('/')
-      options = (@options[:i18n_options] || {}).merge(default: nil)
-      dict = I18n.t(:"enum_ish.#{@klass.name.underscore}.#{key}", **options)
-      return dict if dict
-
-      i18n_ancestors.each do |ancestor|
-        dict = I18n.t(:"enum_ish.#{ancestor.name.underscore}.#{key}", **options)
-        return dict if dict
-      end
-
-      dict = I18n.t(:"enum_ish.defaults.#{key}", **options)
-      return dict if dict
-
-      @enum.mapping.invert
-    end
-
-    def i18n_ancestors
-      @klass.ancestors.drop(1)
-            .take_while { |a| a.name != 'ActiveRecord::Base' && a.name != 'Object' }
-            .select { |a| a.is_a?(Class) && !a.name.empty? }
-    end
-
-    def filter(dict)
-      if @options[:except]
-        except = Array(@options[:except])
-        dict.reject! { |k, v| except.include?(k) }
-      end
-      if @options[:only]
-        only = Array(@options[:only])
-        dict.select! { |k, v| only.include?(k) }
+        yield
       end
-      dict
     end
   end
 end

data/lib/enum_ish/dictionary_cache.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module EnumIsh
+  class DictionaryCache
+    def initialize(app)
+      @app = app
+    end
+  
+    def call(env)
+      EnumIsh::DictionaryCache.enable do
+        @app.call(env)
+      end
+    end
+
+    class << self
+      class_attribute :cache_key
+      self.cache_key = :_enum_ish_dictionary_cache
+
+      def cache
+        Thread.current[cache_key]
+      end
+
+      def enable
+        Thread.current[cache_key] = {}
+        yield
+      ensure
+        Thread.current[cache_key] = nil
+      end
+    end
+  end
+end

data/lib/enum_ish/dictionary_lookup.rb

@@ -0,0 +1,51 @@
+module EnumIsh
+  class DictionaryLookup
+    def initialize(klass, enum, options = {})
+      @klass = klass
+      @enum = enum
+      @options = options
+    end
+
+    def call
+      i18n = lookup_for(@klass).transform_keys { |k| k.to_s.to_sym }
+
+      dict = {}
+      if @enum.use?(:accessor)
+        @enum.mapping.each { |k, v| dict[k] = i18n[k] }
+      else
+        @enum.mapping.each { |k, v| dict[v] = i18n[k] }
+      end
+
+      filter(dict)
+    end
+
+    private
+
+    def lookup_for(klass)
+      if klass.name.blank? || !klass.is_a?(Class)
+        return lookup_for(klass.superclass)
+      end
+
+      key = [@enum.name, @options[:format]].compact.join('/')
+      options = (@options[:i18n_options] || {}).merge(default: nil)
+
+      if klass.name.to_s.in?(['ActiveRecord::Base', 'Object'])
+        I18n.t(:"enum_ish.defaults.#{key}", **options) || @enum.mapping
+      else
+        I18n.t(:"enum_ish.#{klass.name.underscore}.#{key}", **options) || lookup_for(klass.superclass)
+      end
+    end
+
+    def filter(dict)
+      if @options[:except]
+        except = Array(@options[:except])
+        dict.reject! { |k, v| except.include?(k) }
+      end
+      if @options[:only]
+        only = Array(@options[:only])
+        dict.select! { |k, v| only.include?(k) }
+      end
+      dict
+    end
+  end
+end

data/lib/enum_ish/enum.rb

@@ -1,5 +1,10 @@
+# frozen_string_literal: true
+
 module EnumIsh
   class Enum
+    class_attribute :features
+    self.features = [:text, :options, :predicate, :default, :accessor, :validate, :scope]
+
     attr_accessor :name
     attr_accessor :mapping
     attr_accessor :setting
@@ -7,7 +12,37 @@ module EnumIsh
     def initialize(name, mapping, setting)
       @name = name
       @mapping = init_mapping(mapping)
-      @setting = init_setting(setting)
+      @setting = setting
+    end
+
+    features.each do |feature|
+      define_method feature do
+        setting.fetch(feature)
+      end
+    end
+
+    def use?(feature)
+      @setting.key?(feature)
+    end
+
+    def features
+      self.class.features.select { |feature| use?(feature) }
+    end
+
+    def values
+      if use?(:accessor)
+        @mapping.keys
+      else
+        @mapping.values
+      end
+    end
+
+    def value(key)
+      if use?(:accessor)
+        key
+      else
+        @mapping[key]
+      end
     end
 
     def to_raw(value)
@@ -27,6 +62,35 @@ module EnumIsh
       end
     end
 
+    def text_method
+      "#{Config.text_prefix}#{@name}#{Config.text_suffix}"
+    end
+
+    def options_method
+      "#{Config.options_prefix}#{@name}#{Config.options_suffix}"
+    end
+
+    def predicate_method(key)
+      key = key.to_s.tr('.', '_')
+      if predicate.is_a?(Hash) && predicate[:prefix] == false
+        "#{key}?"
+      else
+        "#{@name}_#{key}?"
+      end
+    end
+
+    def raw_method
+      "#{Config.raw_prefix}#{@name}#{Config.raw_suffix}"
+    end
+
+    def scope_method(type = nil)
+      if type == :negative
+        "#{Config.scope_prefix}#{@name}_not#{Config.scope_suffix}"
+      else
+        "#{Config.scope_prefix}#{@name}#{Config.scope_suffix}"
+      end
+    end
+
     private
 
     def init_mapping(mapping)
@@ -40,12 +104,5 @@ module EnumIsh
         mapping
       end
     end
-
-    def init_setting(setting)
-      [:text, :options].each do |key|
-        setting[key] = true unless setting.key?(key)
-      end
-      setting
-    end
   end
 end

data/lib/enum_ish/errors.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module EnumIsh
   class Error < StandardError
   end

data/lib/enum_ish/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module EnumIsh
-  VERSION = '1.4.1'
+  VERSION = '1.6.1'
 end

data/lib/enum_ish.rb

@@ -1,36 +1,19 @@
+# frozen_string_literal: true
+
 require 'active_support'
 require 'enum_ish/version'
-require 'enum_ish/errors'
 require 'enum_ish/config'
-require 'enum_ish/enum'
-require 'enum_ish/dictionary'
-require 'enum_ish/definer'
-require 'enum_ish/active_record_definer' if defined?(ActiveRecord::Base)
+require 'enum_ish/base'
+require 'enum_ish/dictionary_cache'
 
 module EnumIsh
-  def enum_ish(name, map, config = {})
-    enum = Enum.new(name, map, config)
-
-    self._enum_ish_enums ||= {}
-    self._enum_ish_enums[name.to_sym] = enum
-
-    if defined?(ActiveRecord::Base) && self.ancestors.include?(ActiveRecord::Base)
-      ActiveRecordDefiner.new(self).define(enum)
-    else
-      Definer.new(self).define(enum)
+  class << self
+    def configure
+      yield Config
     end
-  end
-
-  def self.extended(klass)
-    super
-    klass.class_attribute :_enum_ish_enums
-    klass.extend ClassMethods
-  end
 
-  module ClassMethods
-    def inherited(subclass)
-      super
-      subclass._enum_ish_enums = self._enum_ish_enums.dup
+    def config
+      Config
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: enum_ish
 version: !ruby/object:Gem::Version
-  version: 1.4.1
+  version: 1.6.1
 platform: ruby
 authors:
 - Yoshikazu Kaneta
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-05-25 00:00:00.000000000 Z
+date: 2022-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -115,12 +115,16 @@ files:
 - gemfiles/rails52.gemfile
 - gemfiles/rails60.gemfile
 - gemfiles/rails61.gemfile
+- gemfiles/rails70.gemfile
 - lib/enum_ish.rb
 - lib/enum_ish/active_record_definer.rb
 - lib/enum_ish/active_record_enum_type.rb
+- lib/enum_ish/base.rb
 - lib/enum_ish/config.rb
 - lib/enum_ish/definer.rb
 - lib/enum_ish/dictionary.rb
+- lib/enum_ish/dictionary_cache.rb
+- lib/enum_ish/dictionary_lookup.rb
 - lib/enum_ish/enum.rb
 - lib/enum_ish/errors.rb
 - lib/enum_ish/version.rb