enumerize 0.3.0 → 2.3.1

data/lib/enumerize/activerecord.rb

@@ -1,7 +1,132 @@
-require 'active_support/concern'
+# frozen_string_literal: true
 
 module Enumerize
-  module ActiveRecord
+  module ActiveRecordSupport
+    def enumerize(name, options={})
+      super
 
+      _enumerize_module.dependent_eval do
+        if self < ::ActiveRecord::Base
+          include InstanceMethods
+
+          const_get(:ActiveRecord_Relation).include(RelationMethods)
+          const_get(:ActiveRecord_AssociationRelation).include(RelationMethods)
+          const_get(:ActiveRecord_Associations_CollectionProxy).include(RelationMethods)
+
+          # Since Rails use `allocate` method on models and initializes them with `init_with` method.
+          # This way `initialize` method is not being called, but `after_initialize` callback always gets triggered.
+          after_initialize :_set_default_value_for_enumerized_attributes
+
+          # https://github.com/brainspec/enumerize/issues/111
+          require 'enumerize/hooks/uniqueness'
+
+          unless options[:multiple]
+            decorate_attribute_type(name, :enumerize) do |subtype|
+              Type.new(enumerized_attributes[name], subtype)
+            end
+          end
+        end
+      end
+    end
+
+    module InstanceMethods
+      # https://github.com/brainspec/enumerize/issues/74
+      def write_attribute(attr_name, value, *options)
+        if self.class.enumerized_attributes[attr_name]
+          _enumerized_values_for_validation[attr_name.to_s] = value
+        end
+
+        super
+      end
+
+      # Support multiple enumerized attributes
+      def becomes(klass)
+        became = super
+        klass.enumerized_attributes.each do |attr|
+          # Rescue when column associated to the enum does not exist.
+          begin
+            became.send("#{attr.name}=", send(attr.name))
+          rescue ActiveModel::MissingAttributeError
+          end
+        end
+
+        became
+      end
+
+      def reload(options = nil)
+        reloaded = super
+
+        reloaded.class.enumerized_attributes.each do |attr|
+          begin
+            # Checks first if the enumerized attribute is in ActiveRecord::Store
+            store_attr, _ = reloaded.class.stored_attributes.detect do |store_attr, keys|
+              keys.include?(attr.name)
+            end
+
+            if store_attr.present?
+              reloaded.send("#{attr.name}=", reloaded.send(store_attr).with_indifferent_access[attr.name])
+            else
+              reloaded.send("#{attr.name}=", reloaded[attr.name])
+            end
+          rescue ActiveModel::MissingAttributeError
+          end
+        end
+
+        reloaded
+      end
+    end
+
+    module RelationMethods
+      def update_all(updates)
+        if updates.is_a?(Hash)
+          enumerized_attributes.each do |attr|
+            next if updates[attr.name].blank? || attr.kind_of?(Enumerize::Multiple)
+            enumerize_value = attr.find_value(updates[attr.name])
+            updates[attr.name] = enumerize_value && enumerize_value.value
+          end
+        end
+
+        super(updates)
+      end
+    end
+
+    class Type < ActiveRecord::Type::Value
+      delegate :type, to: :@subtype
+
+      def initialize(attr, subtype)
+        @attr = attr
+        @subtype = subtype
+      end
+
+      def serialize(value)
+        v = @attr.find_value(value)
+        (v && v.value) || value
+      end
+
+      alias type_cast_for_database serialize
+
+      def deserialize(value)
+        @attr.find_value(value)
+      end
+
+      alias type_cast_from_database deserialize
+
+      def as_json(options = nil)
+        {attr: @attr.name, subtype: @subtype}.as_json(options)
+      end
+
+      def encode_with(coder)
+        coder[:class_name] = @attr.klass.name
+        coder[:attr_name] = @attr.name
+        coder[:subtype] = @subtype
+      end
+
+      def init_with(coder)
+        initialize(
+          coder[:class_name].constantize.enumerized_attributes[coder[:attr_name]],
+          coder[:subtype]
+        )
+      end
+    end
   end
 end

data/lib/enumerize/attribute.rb

@@ -1,32 +1,192 @@
+# frozen_string_literal: true
+
 module Enumerize
   class Attribute
-    attr_reader :name, :values, :default_value
+    attr_reader :klass, :name, :values, :default_value, :i18n_scope, :skip_validations_value
 
     def initialize(klass, name, options={})
       raise ArgumentError, ':in option is required' unless options[:in]
+      raise ArgumentError, ':scope option does not work with option :multiple' if options[:multiple] && options[:scope]
+
+      extend Multiple if options[:multiple]
 
       @klass  = klass
       @name   = name.to_sym
-      @values = Array(options[:in]).map { |v| Value.new(self, *v) }
+
+      if options[:i18n_scope]
+        raise ArgumentError, ':i18n_scope option accepts only String or Array of strings' unless Array(options[:i18n_scope]).all? { |s| s.is_a?(String) }
+        @i18n_scope = options[:i18n_scope]
+      end
+
+      value_class = options.fetch(:value_class, Value)
+      @values = Array(options[:in]).map { |v| value_class.new(self, *v).freeze }
+
       @value_hash = Hash[@values.map { |v| [v.value.to_s, v] }]
       @value_hash.merge! Hash[@values.map { |v| [v.to_s, v] }]
 
       if options[:default]
-        @default_value = find_value(options[:default])
+        @default_value = find_default_value(options[:default])
         raise ArgumentError, 'invalid default value' unless @default_value
       end
+
+      @skip_validations_value = options.fetch(:skip_validations, false)
+    end
+
+    def find_default_value(value)
+      if value.respond_to?(:call)
+        value
+      else
+        find_value(value)
+      end
     end
 
     def find_value(value)
       @value_hash[value.to_s] unless value.nil?
     end
 
-    def i18n_suffix
-      @klass.model_name.i18n_key if @klass.respond_to?(:model_name)
+    def find_values(*values)
+      values.map { |value| find_value(value) }.compact
+    end
+
+    def each_value
+      values.each { |value| yield value }
+    end
+
+    def i18n_scopes
+      @i18n_scopes ||= if i18n_scope
+        Array(i18n_scope)
+      elsif @klass.respond_to?(:model_name)
+        ["enumerize.#{@klass.model_name.i18n_key}.#{name}"]
+      else
+        []
+      end
+    end
+
+    def options(options = {})
+      values = if options.empty?
+        @values
+      else
+        raise ArgumentError, 'Options cannot have both :only and :except' if options[:only] && options[:except]
+
+        only = Array(options[:only]).map(&:to_s)
+        except = Array(options[:except]).map(&:to_s)
+
+        @values.reject do |value|
+          if options[:only]
+            !only.include?(value)
+          elsif options[:except]
+            except.include?(value)
+          end
+        end
+      end
+
+      values.map { |v| [v.text, v.to_s] }
+    end
+
+    def respond_to_missing?(method, include_private=false)
+      @value_hash.include?(method.to_s) || super
+    end
+
+    def define_methods!(mod)
+      mod.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{name}
+          if defined?(super)
+            self.class.enumerized_attributes[:#{name}].find_value(super)
+          elsif respond_to?(:read_attribute)
+            self.class.enumerized_attributes[:#{name}].find_value(read_attribute(:#{name}))
+          else
+            if defined?(@#{name})
+              self.class.enumerized_attributes[:#{name}].find_value(@#{name})
+            else
+              @#{name} = nil
+            end
+          end
+        end
+
+        def #{name}=(new_value)
+          allowed_value_or_nil = self.class.enumerized_attributes[:#{name}].find_value(new_value)
+          allowed_value_or_nil = allowed_value_or_nil.value unless allowed_value_or_nil.nil?
+
+          if defined?(super)
+            super allowed_value_or_nil
+          elsif respond_to?(:write_attribute, true)
+            write_attribute '#{name}', allowed_value_or_nil
+          else
+            @#{name} = allowed_value_or_nil
+          end
+
+          _enumerized_values_for_validation['#{name}'] = new_value.nil? ? nil : new_value.to_s
+
+          allowed_value_or_nil
+        end
+
+        def #{name}_text
+          self.#{name} && self.#{name}.text
+        end
+
+        def #{name}_value
+          self.#{name} && self.#{name}.value
+        end
+      RUBY
+    end
+
+    private
+
+    def method_missing(method)
+      if @value_hash.include?(method.to_s)
+        find_value(method)
+      else
+        super
+      end
+    end
+  end
+
+  module Multiple
+    def find_default_value(value)
+      if value.respond_to?(:call)
+        value
+      else
+        find_values(*value)
+      end
     end
 
-    def options
-      @values.map { |v| [v.text, v.to_s] }
+    def define_methods!(mod)
+      mod.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{name}
+          unless defined?(@_#{name}_enumerized_set)
+            if defined?(super)
+              self.#{name} = super
+            elsif respond_to?(:read_attribute)
+              self.#{name} = read_attribute(:#{name})
+            else
+              if defined?(@#{name})
+                self.#{name} = @#{name}
+              else
+                self.#{name} = []
+              end
+            end
+          end
+
+          @_#{name}_enumerized_set
+        end
+
+        def #{name}=(values)
+          @_#{name}_enumerized_set = Enumerize::Set.new(self, self.class.enumerized_attributes[:#{name}], values)
+          raw_values = #{name}.values.map(&:value)
+
+          if defined?(super)
+            super raw_values
+          elsif respond_to?(:write_attribute, true)
+            write_attribute '#{name}', raw_values
+          else
+            @#{name} = raw_values
+          end
+
+          _enumerized_values_for_validation['#{name}'] = values.respond_to?(:map) ? values.reject(&:blank?).map(&:to_s) : values
+
+          #{name}
+        end
+      RUBY
     end
   end
 end

data/lib/enumerize/attribute_map.rb

@@ -1,5 +1,9 @@
+# frozen_string_literal: true
+
 module Enumerize
   class AttributeMap
+    attr_reader :attributes
+
     def initialize
       @attributes = {}
       @dependants = []

data/lib/enumerize/base.rb

@@ -1,8 +1,15 @@
-require 'active_support/concern'
+# frozen_string_literal: true
 
 module Enumerize
   module Base
-    extend ActiveSupport::Concern
+    def self.included(base)
+      base.extend ClassMethods
+      base.singleton_class.prepend ClassMethods::Hook
+
+      if base.respond_to?(:validate)
+        base.validate :_validate_enumerized_attributes
+      end
+    end
 
     module ClassMethods
       def enumerize(name, options={})
@@ -17,90 +24,45 @@ module Enumerize
           RUBY
         end
 
-        _define_enumerize_attribute(attr)
-
-        _enumerize_module.module_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def #{attr.name}_text
-            #{attr.name} && #{attr.name}.text
-          end
-        RUBY
-
-        if respond_to?(:validates)
-          validates name, :inclusion => {:in => enumerized_attributes[name].values.map(&:to_s), :allow_nil => true, :allow_blank => true}
-        end
+        attr.define_methods!(_enumerize_module)
       end
 
       def enumerized_attributes
         @enumerized_attributes ||= AttributeMap.new
       end
 
-      def inherited(subclass)
-        enumerized_attributes.add_dependant subclass.enumerized_attributes
-        super
+      module Hook
+        def inherited(subclass)
+          enumerized_attributes.add_dependant subclass.enumerized_attributes
+          super subclass
+        end
       end
 
       private
 
       def _enumerize_module
         @_enumerize_module ||= begin
-          mod = Module.new do
-            @_class_methods = Module.new
-            class << self
-              attr_reader :_class_methods
-            end
-          end
+          mod = Module.new
           include mod
-          extend mod._class_methods
           mod
         end
       end
-
-      def _define_enumerize_attribute(attr)
-        _enumerize_module.module_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def #{attr.name}
-            if defined?(super)
-              self.class.enumerized_attributes[:#{attr.name}].find_value(super)
-            elsif respond_to?(:read_attribute, true)
-              self.class.enumerized_attributes[:#{attr.name}].find_value(read_attribute(:#{attr.name}))
-            else
-              if defined?(@#{attr.name})
-                self.class.enumerized_attributes[:#{attr.name}].find_value(@#{attr.name})
-              else
-                @#{attr.name} = nil
-              end
-            end
-          end
-
-          def #{attr.name}=(new_value)
-            _enumerized_values_for_validation[:#{attr.name}] = new_value.nil? ? nil : new_value.to_s
-
-            allowed_value_or_nil = self.class.enumerized_attributes[:#{attr.name}].find_value(new_value)
-            allowed_value_or_nil = allowed_value_or_nil.value unless allowed_value_or_nil.nil?
-
-            if defined?(super)
-              super allowed_value_or_nil
-            elsif respond_to?(:write_attribute, true)
-              write_attribute :#{attr.name}, allowed_value_or_nil
-            else
-              @#{attr.name} = allowed_value_or_nil
-            end
-          end
-        RUBY
-      end
     end
 
     def initialize(*)
       super
-      self.class.enumerized_attributes.each do |attr|
-        public_send("#{attr.name}=", attr.default_value) unless _enumerized_values_for_validation.key?(attr.name)
-      end
+      _set_default_value_for_enumerized_attributes
     end
 
     def read_attribute_for_validation(key)
-      if self.class.enumerized_attributes[key].instance_of?(Enumerize::Attribute) && _enumerized_values_for_validation.has_key?(key)
+      key = key.to_s
+
+      if _enumerized_values_for_validation.has_key?(key)
         _enumerized_values_for_validation[key]
-      else
+      elsif defined?(super)
         super
+      else
+        send(key)
       end
     end
 
@@ -109,5 +71,42 @@ module Enumerize
     def _enumerized_values_for_validation
       @_enumerized_values_for_validation ||= {}
     end
+
+    def _validate_enumerized_attributes
+      self.class.enumerized_attributes.each do |attr|
+        skip_validations = Utils.call_if_callable(attr.skip_validations_value, self)
+        next if skip_validations
+
+        value = read_attribute_for_validation(attr.name)
+        next if value.blank?
+
+        if attr.kind_of? Multiple
+          errors.add attr.name unless value.respond_to?(:all?) && value.all? { |v| v.blank? || attr.find_value(v) }
+        else
+          errors.add attr.name, :inclusion unless attr.find_value(value)
+        end
+      end
+    end
+
+    def _set_default_value_for_enumerized_attributes
+      self.class.enumerized_attributes.each do |attr|
+        next if attr.default_value.nil?
+        begin
+          if respond_to?(attr.name)
+            attr_value = public_send(attr.name)
+          else
+            next
+          end
+
+          value_for_validation = _enumerized_values_for_validation[attr.name.to_s]
+
+          if (!attr_value || attr_value.empty?) && (!value_for_validation || value_for_validation.empty?)
+            value = Utils.call_if_callable(attr.default_value, self)
+            public_send("#{attr.name}=", value)
+          end
+        rescue ActiveModel::MissingAttributeError
+        end
+      end
+    end
   end
 end

data/lib/enumerize/hooks/formtastic.rb

@@ -1,28 +1,27 @@
+# frozen_string_literal: true
+
 require 'active_support/concern'
 
 module Enumerize
   module Hooks
     module FormtasticFormBuilderExtension
-      extend ActiveSupport::Concern
 
-      included do
-        alias_method_chain :input, :enumerize
-      end
+      def input(method, options={})
+        enumerized_object = convert_to_model(object)
+        klass = enumerized_object.class
 
-      def input_with_enumerize(method, options={})
-        klass = object.class
         if klass.respond_to?(:enumerized_attributes) && (attr = klass.enumerized_attributes[method])
           options[:collection] ||= attr.options
+
+          if attr.kind_of?(Enumerize::Multiple) && options[:as] != :check_boxes
+            options[:input_html] = options.fetch(:input_html, {}).merge(:multiple => true)
+          end
         end
 
-        input_without_enumerize(method, options)
+        super(method, options)
       end
     end
   end
 end
 
-if defined? ::Formtastic::SemanticFormBuilder
-  ::Formtastic::SemanticFormBuilder.send :include, Enumerize::Hooks::FormtasticFormBuilderExtension
-else
-  ::Formtastic::FormBuilder.send :include, Enumerize::Hooks::FormtasticFormBuilderExtension
-end
+::Formtastic::FormBuilder.send :prepend, Enumerize::Hooks::FormtasticFormBuilderExtension

data/lib/enumerize/hooks/sequel_dataset.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Enumerize
+  module Hooks
+    module SequelDataset
+      def literal_append(sql, v)
+        if v.is_a?(Enumerize::Value)
+          super(sql, v.value)
+        else
+          super(sql, v)
+        end
+      end
+    end
+  end
+end
+
+::Sequel::Dataset.send :prepend, Enumerize::Hooks::SequelDataset

data/lib/enumerize/hooks/simple_form.rb

@@ -1,24 +1,37 @@
+# frozen_string_literal: true
+
 require 'active_support/concern'
 
 module Enumerize
   module Hooks
     module SimpleFormBuilderExtension
-      extend ActiveSupport::Concern
 
-      included do
-        alias_method_chain :input, :enumerize
+      def input(attribute_name, options={}, &block)
+        add_input_options_for_enumerized_attribute(attribute_name, options)
+        super(attribute_name, options, &block)
+      end
+
+      def input_field(attribute_name, options={})
+        add_input_options_for_enumerized_attribute(attribute_name, options)
+        super(attribute_name, options)
       end
 
-      def input_with_enumerize(attribute_name, options={}, &block)
-        klass = object.class
+      private
+
+      def add_input_options_for_enumerized_attribute(attribute_name, options)
+        enumerized_object = convert_to_model(object)
+        klass = enumerized_object.class
+
         if klass.respond_to?(:enumerized_attributes) && (attr = klass.enumerized_attributes[attribute_name])
           options[:collection] ||= attr.options
-        end
 
-        input_without_enumerize(attribute_name, options, &block)
+          if attr.kind_of?(Enumerize::Multiple) && options[:as] != :check_boxes
+            options[:input_html] = options.fetch(:input_html, {}).merge(:multiple => true)
+          end
+        end
       end
     end
   end
 end
 
-::SimpleForm::FormBuilder.send :include, Enumerize::Hooks::SimpleFormBuilderExtension
+::SimpleForm::FormBuilder.send :prepend, Enumerize::Hooks::SimpleFormBuilderExtension

data/lib/enumerize/hooks/uniqueness.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+
+module Enumerize
+  module Hooks
+    module UniquenessValidator
+
+      def validate_each(record, name, value)
+        klass = record.to_model.class
+
+        if klass.respond_to?(:enumerized_attributes) && (attr = klass.enumerized_attributes[name])
+          value = attr.find_value(value).try(:value)
+        end
+
+        super(record, name, value)
+      end
+    end
+  end
+end
+
+::ActiveRecord::Validations::UniquenessValidator.send :prepend, Enumerize::Hooks::UniquenessValidator

data/lib/enumerize/integrations/rails_admin.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Enumerize
+  module Integrations
+    module RailsAdmin
+
+      def enumerize(name, options={})
+        super
+
+        _enumerize_module.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{name}_enum
+            self.class.enumerized_attributes[:#{name}].options
+          end
+        RUBY
+      end
+    end
+  end
+end