enum_ish 1.1.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3d5f4dc1bae786f87d0835e8a9148b0203ea05795366279a0fc5dfa44fffdb81
-  data.tar.gz: 735635b6dd325ad6a36d702c33c7dfc4b567a252a4d47b1b7a6848e2a1d2688b
+  metadata.gz: c81de716639aaef492be612f2f9d412889513785e61163a2d0e409dad03f883e
+  data.tar.gz: 8163a1339902881f9300cf582b852ca8e505c0cbe27b031b0e9e680cef5a1547
 SHA512:
-  metadata.gz: d0519566e727bc12540003a7a0f5f9c916e297a1732220ba3adddf635996ef812c882858c187107be9a14ee8eb157ca1e686e7623c326f2c3da54933475bb6f5
-  data.tar.gz: 692d5363b0cfeb5b52f7e5d46998835cf24b8e317743ac750d0c16cf6ee347f7bdd5d900f4d437bcb50e20f555ded080bab22d6aef75c00cdacab3710d403a35
+  metadata.gz: 689437f57eb521fe7b5458fde6ea43d2bfa86fba8b7cca2873c18e7d5ece8cbc5da72ea300ed8ac6ed373c113bc1e3e1ff48e1ecb8abc04e0712e7b7e4b28a88
+  data.tar.gz: 8269c8f1268008af6bedb3bec2eff776254430d440d9c71bd68243d1661f137392bfbfbe74d1ec5aaef78ce293637a080a3c713e2bcaaafcb4d0eff72887e213

data/.travis.yml

@@ -17,7 +17,7 @@ matrix:
     gemfile: gemfiles/rails60.gemfile
 before_script:
   - cd spec/dummy
-  - bundle exec rake db:migrate RAILS_ENV=test
+  - bundle exec rake db:create db:migrate db:seed RAILS_ENV=test
   - cd ../..
 script:
   - bundle exec rspec

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # CHANGELOG
 
+## 1.2.0
+
+* Register enum definitions in the class.
+* Add configuration for method name prefix and suffix.
+* Use ActiveRecord::Type for accessor definition.
+* Raise errors if scope is used for non ActiveRecord class.
+* Refactoring.
+
 ## 1.1.1
 
 * Fix lack of options when some enums have same translation.

data/README.md

@@ -5,6 +5,7 @@ A ruby and rails extension to generate enum-like methods.
 ## Dependencies
 
 * ruby 2.3+
+* activerecord 5.0+
 * activesupport 5.0+
 
 ## Installation
@@ -137,7 +138,22 @@ user.status              #=> :_enable
 user.status_raw          #=> "enable"
 ```
 
-### Scope (for ActiveRecord)
+### ActiveRecord features
+
+#### Accessor
+
+Generate accessor:
+
+```ruby
+class User < ActiveRecord::Base
+  extend EnumIsh
+  enum_ish :status, { _enable: 'enable', _disable: 'disable' }, accessor: true
+end
+
+User.where(status: :_enable)  #=> SELECT "users".* FROM "users" WHERE "users"."status" = "enable"
+```
+
+#### Scope
 
 Generate scope:
 
@@ -150,7 +166,7 @@ end
 User.with_status(:enable)  #=> SELECT "users".* FROM "users" WHERE "users"."status" = "enable"
 ```
 
-### Validation (for ActiveRecord)
+#### Validation
 
 Generate validation:
 

data/lib/enum_ish/active_record/definer.rb

@@ -0,0 +1,43 @@
+require_relative 'enum_type'
+
+module EnumIsh
+  module ActiveRecord
+    class Definer < EnumIsh::Definer
+      def define_default(enum)
+        method = "_enum_ish_init_#{enum.name}".to_sym
+
+        @klass.class_eval do
+          after_initialize method
+          define_method method do
+            if respond_to?(enum.name) && public_send(enum.name).nil?
+              default = enum.setting[:default]
+              default = instance_exec(&default) if default.kind_of?(Proc)
+              public_send("#{enum.name}=", default)
+            end
+          end
+        end
+      end
+
+      def define_accessor(enum)
+        @klass.class_eval do
+          define_method "#{Config.raw_prefix}#{enum.name}#{Config.raw_suffix}" do
+            value = read_attribute(enum.name)
+            enum.mapping.fetch(value, value)
+          end
+
+          decorate_attribute_type(enum.name, :enum) do |subtype|
+            EnumIsh::ActiveRecord::EnumType.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) {
+            where(enum.name => enum.mapping.fetch(value, value))
+          }
+        end
+      end
+    end
+  end
+end

data/lib/enum_ish/active_record/enum_type.rb

@@ -0,0 +1,29 @@
+module EnumIsh
+  module ActiveRecord
+    class EnumType < ::ActiveRecord::Type::Value
+      def initialize(name, mapping, subtype)
+        @name = name
+        @mapping = mapping
+        @subtype = subtype
+      end
+
+      def cast(value)
+        if @mapping.has_key?(value)
+          value
+        elsif @mapping.has_value?(value)
+          @mapping.key(value)
+        else
+          value
+        end
+      end
+
+      def deserialize(value)
+        @mapping.key(@subtype.deserialize(value))
+      end
+
+      def serialize(value)
+        @mapping.fetch(value, value)
+      end
+    end
+  end
+end

data/lib/enum_ish/config.rb

@@ -0,0 +1,30 @@
+module EnumIsh
+  class Config
+    @@options = {
+      text_prefix: '',
+      text_suffix: '_text',
+      options_prefix: '',
+      options_suffix: '_options',
+      raw_prefix: '',
+      raw_suffix: '_raw',
+      scope_prefix: 'with_',
+      scope_suffix: ''
+    }
+
+    @@options.keys.each do |key|
+      define_singleton_method "#{key}" do
+        @@options[key]
+      end
+
+      define_singleton_method "#{key}=" do |val|
+        @@options[key] = val
+      end
+    end
+
+    class << self
+      def configure
+        yield self
+      end
+    end
+  end
+end

data/lib/enum_ish/definer.rb

@@ -0,0 +1,83 @@
+module EnumIsh
+  class Definer
+    def initialize(klass)
+      @klass = klass
+    end
+
+    def define(enum)
+      [:text, :options, :predicate, :default, :accessor, :validate, :scope].each do |type|
+        send("define_#{type}", enum) if enum.setting[type]
+      end
+    end
+
+    private
+
+    def define_text(enum)
+      @klass.class_eval do
+        define_method "#{Config.text_prefix}#{enum.name}#{Config.text_suffix}" do |options = {}|
+          value = public_send(enum.name)
+          dic = Dictionary.new(self.class).load(enum, options)
+          dic[value] || value
+        end
+      end        
+    end
+
+    def define_options(enum)
+      @klass.class_eval do
+        define_singleton_method "#{Config.options_prefix}#{enum.name}#{Config.options_suffix}" do |options = {}|
+          dic = Dictionary.new(self).load(enum, options)
+          dic.to_a.map { |value, label| [label, value] }
+        end
+      end
+    end
+
+    def define_predicate(enum)
+      enum.mapping.each do |key, value|
+        @klass.class_eval do
+          define_method "#{enum.name}_#{key}?".tr('.', '_') do
+            public_send(enum.name) == value
+          end
+        end
+      end
+    end
+
+    def define_default(enum)
+      mod = Module.new
+      mod.module_eval do
+        define_method :initialize do |*args|
+          if respond_to?(enum.name) && public_send(enum.name).nil?
+            default = enum.setting[:default]
+            default = instance_exec(&default) if default.kind_of?(Proc)
+            public_send("#{enum.name}=", default)
+          end
+          super(*args)
+        end
+      end
+      @klass.prepend mod
+    end
+
+    def define_accessor(enum)
+      @klass.class_eval do
+        define_method "#{Config.raw_prefix}#{enum.name}#{Config.raw_suffix}" do
+          instance_variable_get("@#{enum.name}")
+        end
+        define_method "#{enum.name}" do
+          enum.mapping.invert[instance_variable_get("@#{enum.name}")]
+        end
+        define_method "#{enum.name}=" do |value|
+          instance_variable_set("@#{enum.name}", enum.mapping.fetch(value, value))
+        end
+      end
+    end
+
+    def define_validate(enum)
+      @klass.class_eval do
+        validates enum.name, inclusion: { in: enum.mapping.values }, allow_nil: true
+      end
+    end
+
+    def define_scope(enum)
+      raise EnumIsh::Error.new(':scope option can be used for ActiveRecord only.')
+    end
+  end
+end

data/lib/enum_ish/dictionary.rb

@@ -0,0 +1,49 @@
+module EnumIsh
+  class Dictionary
+    def initialize(klass)
+      @klass = klass
+    end
+
+    def load(enum, options = {})
+      translated = translate(enum, options)
+      filter(translated, options)
+    end
+
+    private
+
+    def translate(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.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: [:"enum_ish.defaults.#{key}", enum.mapping.invert])
+    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) }
+      end
+      translated
+    end
+  end
+end

data/lib/enum_ish/enum.rb

@@ -0,0 +1,34 @@
+module EnumIsh
+  class Enum
+    attr_accessor :name
+    attr_accessor :mapping
+    attr_accessor :setting
+
+    def initialize(name, mapping, setting)
+      @name = name
+      @mapping = init_mapping(mapping)
+      @setting = init_setting(setting)
+    end
+
+    private
+
+    def init_mapping(mapping)
+      if mapping.is_a?(Array)
+        mapping.map do |v|
+          k = v.to_s.to_sym
+          v = v.to_s if v.is_a?(Symbol)
+          [k, v]
+        end.to_h
+      else
+        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

@@ -0,0 +1,4 @@
+module EnumIsh
+  class Error < StandardError
+  end
+end

data/lib/enum_ish/version.rb

@@ -1,3 +1,3 @@
 module EnumIsh
-  VERSION = '1.1.1'
+  VERSION = '1.2.0'
 end

data/lib/enum_ish.rb

@@ -1,18 +1,24 @@
 require 'active_support'
 require 'enum_ish/version'
-require 'enum_ish/builder'
-require 'enum_ish/builder/active_record' if defined?(ActiveRecord::Base)
+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)
 
 module EnumIsh
-  def enum_ish(attr, enum, config = {})
-    [:text, :options].each do |key|
-      config[key] = true unless config.key?(key)
-    end
+  def enum_ish(name, map, config = {})
+    enum = Enum.new(name, map, config)
+
+    self.class_attribute :_enum_ish_enums unless self.respond_to?(:_enum_ish_enums)
+    self._enum_ish_enums ||= []
+    self._enum_ish_enums << enum
 
-    if defined?(ActiveRecord::Base) && self.ancestors.include?(ActiveRecord::Base)
-      Builder::ActiveRecord.new(self).build(attr, enum, config)
+    if defined?(::ActiveRecord::Base) && self.ancestors.include?(::ActiveRecord::Base)
+      ActiveRecord::Definer.new(self).define(enum)
     else
-      Builder.new(self).build(attr, enum, config)
+      Definer.new(self).define(enum)
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: enum_ish
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.2.0
 platform: ruby
 authors:
 - Yoshikazu Kaneta
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-08-31 00:00:00.000000000 Z
+date: 2019-09-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -115,8 +115,13 @@ files:
 - gemfiles/rails52.gemfile
 - gemfiles/rails60.gemfile
 - lib/enum_ish.rb
-- lib/enum_ish/builder.rb
-- lib/enum_ish/builder/active_record.rb
+- lib/enum_ish/active_record/definer.rb
+- lib/enum_ish/active_record/enum_type.rb
+- lib/enum_ish/config.rb
+- lib/enum_ish/definer.rb
+- lib/enum_ish/dictionary.rb
+- lib/enum_ish/enum.rb
+- lib/enum_ish/errors.rb
 - lib/enum_ish/version.rb
 homepage: https://github.com/kanety/enum_ish
 licenses: []

data/lib/enum_ish/builder/active_record.rb

@@ -1,51 +0,0 @@
-module EnumIsh
-  class Builder
-    class ActiveRecord < Builder
-      private
-
-      def define_default_value(attr, enum, config)
-        method = "_enum_ish_init_#{attr}".to_sym
-
-        @klass.class_eval do
-          after_initialize method
-          define_method method do
-            if respond_to?(attr) && public_send(attr).nil?
-              default = if config[:default].kind_of?(Proc)
-                          instance_exec(&config[:default])
-                        else
-                          config[:default]
-                        end
-              public_send("#{attr}=", default)
-            end
-          end
-        end
-      end
-
-      def define_accessor(attr, enum, config)
-        method = "#{attr}_raw"
-
-        @klass.class_eval do
-          define_method method do
-            read_attribute(attr)
-          end
-          define_method "#{attr}" do
-            enum.invert[read_attribute(attr)]
-          end
-          define_method "#{attr}=" do |value|
-            write_attribute(attr, enum[value])
-          end
-        end
-      end
-
-      def define_scope(attr, enum, config)
-        method = "with_#{attr}"
-
-        @klass.class_eval do
-          scope method, ->(value) {
-            where(attr => (enum[value] || value))
-          }
-        end
-      end
-    end
-  end
-end

data/lib/enum_ish/builder.rb

@@ -1,137 +0,0 @@
-module EnumIsh
-  class Builder
-    def initialize(klass)
-      @klass = klass
-    end
-
-    def build(attr, enum, config = {})
-      if enum.is_a?(Array)
-        enum = enum.map { |v|
-          k = v.to_s.to_sym
-          v = v.to_s if v.is_a?(Symbol)
-          [k, v]
-        }.to_h
-      end
-
-      [:text, :options, :predicate, :accessor, :validate, :scope].each do |key|
-        if config[key]
-          send("define_#{key}", attr, enum, config)
-        end
-      end
-
-      if config.key?(:default)
-        define_default_value(attr, enum, config)
-      end
-    end
-
-    private
-
-    def define_text(attr, enum, config)
-      method = "#{attr}_text"
-
-      @klass.class_eval do
-        define_method method do |options = {}|
-          value = public_send(attr)
-          dic = EnumIsh::Dictionary.new(self.class).load(attr, enum, config, options)
-          dic[value] || value
-        end
-      end        
-    end
-
-    def define_options(attr, enum, config)
-      method = "#{attr}_options"
-
-      @klass.class_eval do
-        define_singleton_method method do |options = {}|
-          dic = EnumIsh::Dictionary.new(self).load(attr, enum, config, options)
-          dic.to_a.map { |value, label| [label, value] }
-        end
-      end
-    end
-
-    def define_predicate(attr, enum, config)
-      enum.each do |key, value|
-        method = "#{attr}_#{key}?".tr('.', '_')
-        @klass.class_eval do
-          define_method method do
-            public_send(attr) == value
-          end
-        end
-      end
-    end
-
-    def define_default_value(attr, enum, config)
-      mod = Module.new
-      mod.module_eval do
-        define_method :initialize do |*args|
-          if respond_to?(attr) && public_send(attr).nil?
-            default = if config[:default].kind_of?(Proc)
-                        instance_exec(&config[:default])
-                      else
-                        config[:default]
-                      end
-            public_send("#{attr}=", default)
-          end
-          super(*args)
-        end
-      end
-      @klass.prepend mod
-    end
-
-    def define_accessor(attr, enum, config)
-      method = "#{attr}_raw"
-
-      @klass.class_eval do
-        define_method method do
-          instance_variable_get("@#{attr}")
-        end
-        define_method "#{attr}" do
-          enum.invert[instance_variable_get("@#{attr}")]
-        end
-        define_method "#{attr}=" do |value|
-          instance_variable_set("@#{attr}", enum[value])
-        end
-      end
-    end
-
-    def define_validate(attr, enum, config)
-      @klass.class_eval do
-        validates attr, inclusion: { in: enum.values }, allow_nil: true
-      end
-    end
-  end
-
-  class Dictionary
-    def initialize(klass)
-      @klass = klass
-    end
-
-    def load(attr, enum, config, options)
-      dict = load_i18n(attr, enum, options)
-
-      translated = enum.map { |k, v| dict[k] ? [k, dict[k]] : [k, v.to_s] }.to_h
-      translated = translated.map { |k, v| [enum[k], v] }.to_h unless config[:accessor]
-
-      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) }
-      end
-
-      translated
-    end
-
-    private
-
-    def load_i18n(attr, enum, options)
-      attr_key = [attr, options[:format]].compact.join('/')
-      i18n_options = (options[:i18n_options] || {}).merge(default: [:"enum_ish.defaults.#{attr_key}", enum.invert])
-
-      dict = I18n.t("enum_ish.#{@klass.name.underscore}.#{attr_key}", i18n_options)
-      dict.map { |k, v| [k.to_s.to_sym, v.to_s] }.to_h
-    end
-  end
-end