enum_ish 1.4.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 53a6b89fe82d91b0ae54a440f3ba3a4908af751b3b22064f3ddd085257f975d9
-  data.tar.gz: 033b3df71e3286482f86ad0cce38084cc7c745cf13c5c06ad3cec146c3a577ac
+  metadata.gz: 9578ab7ba6e720321c8706fabc463af41bcd7244e24d65ff736943a197abdc9b
+  data.tar.gz: 69b73002c3b790e6a737db306fadfb411e418c1ed5e25faf53a96c57f9f44582
 SHA512:
-  metadata.gz: f55c27359c26b39c6500357594e318da8027198b45073bfd772d9ae9047f295d53e2c23ffabf54118cb308c399b8dce546e4db0a23e6564534a7a28c9f18bdfc
-  data.tar.gz: ca8144b132543120f9fb810398df2252ad8e1051c76e32242fef1d6029ab9a458b988902271c779580c6673fe1f6ac2cada24dd4b8ce7edf499669991721d21a
+  metadata.gz: 955eb532c9bc238d8721589240bf600412e679f97b6d0c782f2b34916db04dbd757b389f551fa32605516216a5031730ac37c9778df9ff947cd81825c74e7cf7
+  data.tar.gz: ba5eabfa271493a71ea0d08950b674662535df79a37386b4b59b46000e365ed95f8175946edbd2236310de21b16fb6de3af827766b61db35f3d16820e56cdaf9

data/.github/workflows/ci.yml

@@ -4,7 +4,7 @@ on: [push, pull_request]
 
 jobs:
   test:
-    runs-on: ubuntu-16.04
+    runs-on: ubuntu-18.04
     strategy:
       fail-fast: false
       matrix:

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # CHANGELOG
 
+## 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`.
+* Filter ancestors for dictionary lookup.
+
 ## 1.4.0
 
 * Generate `not` scope for activerecord class.

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/lib/enum_ish.rb

@@ -1,27 +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)
-    klass.class_attribute :_enum_ish_enums
+    def config
+      Config
+    end
   end
 end

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,7 +21,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
           value = read_attribute(enum.name)
           enum.mapping.fetch(value, value)
         end
@@ -38,10 +40,10 @@ module EnumIsh
 
     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,8 +1,14 @@
+# frozen_string_literal: true
+
+require_relative 'dictionary_lookup'
+
 module EnumIsh
   class Dictionary
     def initialize(klass, enum, options = {})
       @klass = klass
-      @dict = load(enum, options)
+      @enum = enum
+      @options = options
+      @dict = cache { DictionaryLookup.new(@klass, @enum, @options).call }
     end
 
     def translate_value(value)
@@ -11,57 +17,23 @@ module EnumIsh
       else
         @dict[value] || value
       end
-   end
+    end
 
     def translate_options
-      @dict.to_a.map { |value, label| [label, value] }
+      @dict.to_a.map { |value, text| [text, value] }
     end
 
     private
 
-    def load(enum, options)
-      dict = translate_dict(enum, options)
-      filter(dict, options)
-    end
-
-    def translate_dict(enum, options)
-      dict = load_dict(enum, options)
-      translated = enum.mapping.map { |k, v| dict[k] ? [k, dict[k]] : [k, v.to_s] }.to_h
-      translated = translated.map { |k, v| [enum.mapping[k], v] }.to_h unless enum.setting[:accessor]
-      translated
-    end
-
-    def load_dict(enum, options)
-      key = i18n_key(enum, options)
-      dict = I18n.t("enum_ish.#{@klass.name.to_s.underscore}.#{key}", **i18n_options(enum, options))
-      dict.map { |k, v| [k.to_s.to_sym, v.to_s] }.to_h
-    end
-
-    def i18n_key(enum, options)
-      [enum.name, options[:format]].compact.join('/')
-    end
-
-    def i18n_options(enum, options)
-      key = i18n_key(enum, options)
-      opts = options[:i18n_options] || {}
-      opts.merge(default: i18n_ancestors(key) + [:"enum_ish.defaults.#{key}", enum.mapping.invert])
-    end
-
-    def i18n_ancestors(key)
-      ancestors = @klass.ancestors.drop(1).select { |a| a.is_a?(Class) && !a.name.empty? }
-      ancestors.map { |a| :"enum_ish.#{a.name.underscore}.#{key}" }
-    end
-
-    def filter(translated, options)
-      if options[:except]
-        except = Array(options[:except])
-        translated.reject! { |k, v| except.include?(k) }
-      end
-      if options[:only]
-        only = Array(options[:only])
-        translated.select! { |k, v| only.include?(k) }
+    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
+        yield
       end
-      translated
     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.0'
+  VERSION = '1.6.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: enum_ish
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.6.0
 platform: ruby
 authors:
 - Yoshikazu Kaneta
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-05-05 00:00:00.000000000 Z
+date: 2021-08-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -118,9 +118,12 @@ files:
 - 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
@@ -142,7 +145,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: A ruby and rails extension to generate enum-like methods