enumerize 0.8.0 → 2.1.2

data/lib/enumerize/activerecord.rb

@@ -4,48 +4,34 @@ module Enumerize
       super
 
       _enumerize_module.dependent_eval do
-        if defined?(::ActiveRecord::Base) && self < ::ActiveRecord::Base
-          if options[:scope]
-            _define_scope_methods!(name, options)
-          end
-
+        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'
-        end
-      end
-    end
-
-    private
-
-    def _define_scope_methods!(name, options)
-      scope_name = options[:scope] == true ? "with_#{name}" : options[:scope]
-
-      define_singleton_method scope_name do |*values|
-        values = values.map { |value| enumerized_attributes[name].find_value(value).value }
-        values = values.first if values.size == 1
 
-        where(name => values)
-      end
-
-      if options[:scope] == true
-        define_singleton_method "without_#{name}" do |*values|
-          values = values.map { |value| enumerized_attributes[name].find_value(value).value }
-          where(arel_table[name].not_in(values))
+          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)
+      def write_attribute(attr_name, value, *options)
         if self.class.enumerized_attributes[attr_name]
-          _enumerized_values_for_validation[attr_name] = value
+          _enumerized_values_for_validation[attr_name.to_s] = value
         end
 
         super
@@ -55,13 +41,68 @@ module Enumerize
       def becomes(klass)
         became = super
         klass.enumerized_attributes.each do |attr|
-          if attr.is_a? Multiple
+          # 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
     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
+      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,15 +1,19 @@
 module Enumerize
   class Attribute
-    attr_reader :name, :values, :default_value, :i18n_scope
+    attr_reader :klass, :name, :values, :default_value, :i18n_scope
 
     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) }
+
+      value_class = options.fetch(:value_class, Value)
+      @values = Array(options[:in]).map { |v| value_class.new(self, *v) }
+
       @value_hash = Hash[@values.map { |v| [v.value.to_s, v] }]
       @value_hash.merge! Hash[@values.map { |v| [v.to_s, v] }]
 
@@ -36,6 +40,10 @@ module Enumerize
       @value_hash[value.to_s] unless value.nil?
     end
 
+    def find_values(*values)
+      values.map { |value| find_value(value) }.compact
+    end
+
     def i18n_scopes
       @i18n_scopes ||= if i18n_scope
         scopes = Array(i18n_scope)
@@ -67,6 +75,10 @@ module Enumerize
       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}
@@ -84,8 +96,6 @@ module Enumerize
         end
 
         def #{name}=(new_value)
-          _enumerized_values_for_validation[:#{name}] = new_value.nil? ? nil : new_value.to_s
-
           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?
 
@@ -96,6 +106,10 @@ module Enumerize
           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
@@ -107,9 +121,27 @@ module Enumerize
         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 define_methods!(mod)
       mod.module_eval <<-RUBY, __FILE__, __LINE__ + 1
         def #{name}
@@ -131,19 +163,19 @@ module Enumerize
         end
 
         def #{name}=(values)
-          _enumerized_values_for_validation[:#{name}] = values.respond_to?(:map) ? values.map(&:to_s) : values
-
           @_#{name}_enumerized_set = Enumerize::Set.new(self, self.class.enumerized_attributes[:#{name}], values)
-          string_values = #{name}.values.map(&:to_str)
+          raw_values = #{name}.values.map(&:value)
 
           if defined?(super)
-            super string_values
+            super raw_values
           elsif respond_to?(:write_attribute, true)
-            write_attribute '#{name}', string_values
+            write_attribute '#{name}', raw_values
           else
-            @#{name} = string_values
+            @#{name} = raw_values
           end
 
+          _enumerized_values_for_validation['#{name}'] = values.respond_to?(:map) ? values.reject(&:blank?).map(&:to_s) : values
+
           #{name}
         end
       RUBY

data/lib/enumerize/base.rb

@@ -2,6 +2,7 @@ module Enumerize
   module Base
     def self.included(base)
       base.extend ClassMethods
+      base.singleton_class.prepend ClassMethods::Hook
 
       if base.respond_to?(:validate)
         base.validate :_validate_enumerized_attributes
@@ -28,9 +29,11 @@ module Enumerize
         @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
@@ -50,10 +53,14 @@ module Enumerize
     end
 
     def read_attribute_for_validation(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
 
@@ -78,22 +85,26 @@ module Enumerize
 
     def _set_default_value_for_enumerized_attributes
       self.class.enumerized_attributes.each do |attr|
-        # remove after dropping support for Rails 3.x
-        # https://github.com/brainspec/enumerize/issues/101
-        attr_value = begin
-          public_send(attr.name)
-        rescue ActiveModel::MissingAttributeError
-          nil
-        end
+        next if attr.default_value.nil?
+        begin
+          if respond_to?(attr.name)
+            attr_value = public_send(attr.name)
+          else
+            next
+          end
 
-        if !attr_value && !_enumerized_values_for_validation.key?(attr.name)
-          value = attr.default_value
+          value_for_validation = _enumerized_values_for_validation[attr.name.to_s]
 
-          if value.respond_to?(:call)
-            value = value.arity == 0 ? value.call : value.call(self)
-          end
+          if (!attr_value || attr_value.empty?) && (!value_for_validation || value_for_validation.empty?)
+            value = attr.default_value
+
+            if value.respond_to?(:call)
+              value = value.arity == 0 ? value.call : value.call(self)
+            end
 
-          public_send("#{attr.name}=", value)
+            public_send("#{attr.name}=", value)
+          end
+        rescue ActiveModel::MissingAttributeError
         end
       end
     end

data/lib/enumerize/hooks/formtastic.rb

@@ -3,13 +3,8 @@ require 'active_support/concern'
 module Enumerize
   module Hooks
     module FormtasticFormBuilderExtension
-      extend ActiveSupport::Concern
 
-      included do
-        alias_method_chain :input, :enumerize
-      end
-
-      def input_with_enumerize(method, options={})
+      def input(method, options={})
         klass = object.class
 
         if klass.respond_to?(:enumerized_attributes) && (attr = klass.enumerized_attributes[method])
@@ -20,10 +15,10 @@ module Enumerize
           end
         end
 
-        input_without_enumerize(method, options)
+        super(method, options)
       end
     end
   end
 end
 
-::Formtastic::FormBuilder.send :include, Enumerize::Hooks::FormtasticFormBuilderExtension
+::Formtastic::FormBuilder.send :prepend, Enumerize::Hooks::FormtasticFormBuilderExtension

data/lib/enumerize/hooks/sequel_dataset.rb

@@ -0,0 +1,15 @@
+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

@@ -3,21 +3,15 @@ require 'active_support/concern'
 module Enumerize
   module Hooks
     module SimpleFormBuilderExtension
-      extend ActiveSupport::Concern
 
-      included do
-        alias_method_chain :input, :enumerize
-        alias_method_chain :input_field, :enumerize
-      end
-
-      def input_with_enumerize(attribute_name, options={}, &block)
+      def input(attribute_name, options={}, &block)
         add_input_options_for_enumerized_attribute(attribute_name, options)
-        input_without_enumerize(attribute_name, options, &block)
+        super(attribute_name, options, &block)
       end
 
-      def input_field_with_enumerize(attribute_name, options={})
+      def input_field(attribute_name, options={})
         add_input_options_for_enumerized_attribute(attribute_name, options)
-        input_field_without_enumerize(attribute_name, options)
+        super(attribute_name, options)
       end
 
       private
@@ -37,4 +31,4 @@ module Enumerize
   end
 end
 
-::SimpleForm::FormBuilder.send :include, Enumerize::Hooks::SimpleFormBuilderExtension
+::SimpleForm::FormBuilder.send :prepend, Enumerize::Hooks::SimpleFormBuilderExtension

data/lib/enumerize/hooks/uniqueness.rb

@@ -3,21 +3,16 @@ require 'active_support/concern'
 module Enumerize
   module Hooks
     module UniquenessValidator
-      extend ActiveSupport::Concern
 
-      included do
-        alias_method_chain :validate_each, :enumerize
-      end
-
-      def validate_each_with_enumerize(record, name, value)
+      def validate_each(record, name, value)
         if record.class.respond_to?(:enumerized_attributes) && (attr = record.class.enumerized_attributes[name])
           value = attr.find_value(value).try(:value)
         end
 
-        validate_each_without_enumerize(record, name, value)
+        super(record, name, value)
       end
     end
   end
 end
 
-::ActiveRecord::Validations::UniquenessValidator.send :include, Enumerize::Hooks::UniquenessValidator
+::ActiveRecord::Validations::UniquenessValidator.send :prepend, Enumerize::Hooks::UniquenessValidator

data/lib/enumerize/integrations/rspec/matcher.rb

@@ -2,37 +2,57 @@ module Enumerize
   module Integrations
     module RSpec
       class Matcher
-        attr_accessor :attr, :values, :subject, :default
 
-        def initialize(attr)
-          self.attr = attr
+        def initialize(expected_attr)
+          self.expected_attr = expected_attr
         end
 
-        def in(*values)
-          self.values = values.map(&:to_s).sort
+        def in(*expected_values)
+          self.expected_values = expected_values.flatten
           self
         end
 
-        def with_default(default)
-          self.default = default.to_s
+        def with_default(expected_default)
+          self.expected_default = expected_default.to_s
           self
         end
 
-        def failure_message
-          message  = " expected :#{attr} to allow value#{values.size == 1 ? nil : 's'}: #{quote_values(values)},"
-          message += " but it allows #{quote_values(enumerized_values)} instead"
+        def with_i18n_scope(expected_i18n_scope)
+          self.expected_i18n_scope = expected_i18n_scope
+          self
+        end
 
-          if default && !matches_default_value?
-            message  = " expected :#{attr} to have #{default.inspect} as default value,"
-            message += " but it sets #{enumerized_default.inspect} instead"
-          end
+        def with_predicates(expected_predicates)
+          self.expected_predicates = expected_predicates
+          self
+        end
+
+        def with_multiple(expected_multiple)
+          self.expected_multiple = expected_multiple
+          self
+        end
+
+        def with_scope(expected_scope)
+          self.expected_scope = expected_scope
+          self
+        end
+
+        def failure_message
+          "Expected #{expectation}"
+        end
 
-          message
+        def failure_message_when_negated
+          "Did not expect #{expectation}"
         end
 
         def description
-          description  = "enumerize :#{attr} in: #{quote_values(values)}"
-          description += " with #{default.inspect} as default value" if default
+          description  = "define enumerize :#{expected_attr}"
+          description += " in: #{quote_values(expected_values)}" if expected_values
+          description += " with #{expected_default.inspect} as default value" if expected_default
+          description += " i18n_scope: #{expected_i18n_scope.inspect}" if expected_i18n_scope
+          description += " predicates: #{expected_predicates.inspect}" if expected_predicates
+          description += " multiple: #{expected_multiple.inspect}" if expected_multiple
+          description += " scope: #{expected_scope.inspect}" if expected_scope
 
           description
         end
@@ -41,36 +61,97 @@ module Enumerize
           self.subject = subject
           matches      = true
 
-          matches &= matches_attributes?
-          matches &= matches_default_value? if default
+          matches &= matches_attribute?
+          matches &= matches_values? if expected_values
+          matches &= matches_default_value? if expected_default
+          matches &= matches_i18n_scope? if expected_i18n_scope
+          matches &= matches_predicates? if expected_predicates
+          matches &= matches_multiple? if expected_multiple
+          matches &= matches_scope? if expected_scope
 
           matches
         end
 
         private
+        attr_accessor :expected_attr, :expected_values, :subject, :expected_default,
+                      :expected_i18n_scope, :expected_predicates, :expected_multiple,
+                      :expected_scope
 
-        def matches_attributes?
-          values == enumerized_values
+        def expectation
+          "#{subject.class.name} to #{description}"
+        end
+
+        def matches_attribute?
+          attributes.present?
+        end
+
+        def matches_values?
+          matches_array_values? || matches_hash_values?
+        end
+
+        def matches_array_values?
+          sorted_values == enumerized_values
+        end
+
+        def matches_hash_values?
+          return unless expected_values.first.is_a?(Hash)
+          expected_values.first.all? { |k, v| enumerized_value_hash[k.to_s] == v; }
         end
 
         def matches_default_value?
-          default == enumerized_default
+          expected_default == enumerized_default
+        end
+
+        def matches_i18n_scope?
+          attributes.i18n_scope == expected_i18n_scope
+        end
+
+        def matches_predicates?
+          if expected_predicates.is_a?(TrueClass)
+            subject.respond_to?("#{sorted_values.first}?")
+          else
+            subject.respond_to?("#{expected_attr}_#{attributes.values.first}?")
+          end
+        end
+
+        def matches_multiple?
+          subject.public_send(expected_attr).is_a?(Enumerize::Set)
+        end
+
+        def matches_scope?
+          if expected_scope.is_a?(TrueClass)
+            subject_class.respond_to?("with_#{expected_attr}")
+          else
+            subject_class.respond_to?(expected_scope[:scope])
+          end
+        end
+
+        def sorted_values
+          @sorted_values ||=expected_values.map(&:to_s).sort
         end
 
         def enumerized_values
-          @enumerized_values ||= attributes[attr.to_s].values.sort
+          @enumerized_values ||= attributes.values.sort
         end
 
         def enumerized_default
-          @enumerized_default ||= attributes[attr.to_s].default_value
+          @enumerized_default ||= attributes.default_value
+        end
+
+        def enumerized_value_hash
+          @enumerized_value_hash ||= attributes.instance_variable_get('@value_hash')
         end
 
         def attributes
-          subject.class.enumerized_attributes.attributes
+          subject_class.enumerized_attributes.attributes[expected_attr.to_s]
+        end
+
+        def subject_class
+          @subject_class ||= subject.class
         end
 
         def quote_values(values)
-          values.map(&:inspect).join(', ')
+          sorted_values.map(&:inspect).join(', ')
         end
       end
     end

data/lib/enumerize/mongoid.rb

@@ -0,0 +1,13 @@
+module Enumerize
+  module MongoidSupport
+    def enumerize(name, options={})
+      super
+
+      _enumerize_module.dependent_eval do
+        if self < ::Mongoid::Document
+          after_initialize :_set_default_value_for_enumerized_attributes
+        end
+      end
+    end
+  end
+end

data/lib/enumerize/predicatable.rb

@@ -1,29 +1,20 @@
 module Enumerize
   module Predicatable
-    def method_missing(method, *args, &block)
-      if boolean_method?(method)
-        define_query_methods
-        send(method, *args, &block)
-      else
-        super
-      end
-    end
-
     def respond_to_missing?(method, include_private=false)
-      boolean_method?(method)
+      predicate_method?(method) || super
     end
 
     private
 
-    def define_query_methods
-      @attr.values.each do |value|
-        unless singleton_methods.include?(:"#{value}?")
-          define_query_method(value)
-        end
+    def method_missing(method, *args, &block)
+      if predicate_method?(method)
+        predicate_call(method[0..-2], *args, &block)
+      else
+        super
       end
     end
 
-    def boolean_method?(method)
+    def predicate_method?(method)
       method[-1] == '?' && @attr.values.include?(method[0..-2])
     end
   end

data/lib/enumerize/predicates.rb

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/module/delegation'
+
 module Enumerize
   # Predicate methods.
   #
@@ -61,7 +63,7 @@ module Enumerize
       end
 
       def names
-        values.map { |v| "#{v}?" }
+        values.map { |v| "#{v.tr('-', '_')}?" }
       end
 
       def build(klass)