enumerize 0.8.0 → 2.6.1

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

@@ -1,38 +1,60 @@
+# frozen_string_literal: true
+
 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
 
-          message
+        def with_scope(expected_scope)
+          self.expected_scope = expected_scope
+          self
+        end
+
+        def failure_message
+          "Expected #{expectation}"
+        end
+
+        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 +63,100 @@ 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 expectation
+          "#{subject.class.name} to #{description}"
+        end
+
+        def matches_attribute?
+          attributes.present?
+        end
 
-        def matches_attributes?
-          values == enumerized_values
+        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?("#{enumerized_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?
+          case expected_scope
+          when TrueClass
+            subject_class.respond_to?("with_#{expected_attr}")
+          when :shallow
+            enumerized_values.all? { |value| subject_class.respond_to?(value) }
+          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/integrations/rspec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+require 'rspec/matchers'
 require 'enumerize/integrations/rspec/matcher'
 
 module Enumerize

data/lib/enumerize/module.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Enumerize
   class Module < ::Module
     attr_reader :_class_methods

data/lib/enumerize/module_attributes.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Enumerize
   module ModuleAttributes
     def included(base)

data/lib/enumerize/mongoid.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Enumerize
+  module MongoidSupport
+    def enumerize(name, options={})
+      super
+
+      _enumerize_module.dependent_eval do
+        if self < ::Mongoid::Document
+          include InstanceMethods
+
+          after_initialize :_set_default_value_for_enumerized_attributes
+        end
+      end
+    end
+
+    module InstanceMethods
+      def reload
+        reloaded = super
+
+        reloaded.class.enumerized_attributes.each do |attr|
+          reloaded.send("#{attr.name}=", reloaded[attr.name])
+        end
+
+        reloaded
+      end
+
+      private
+
+      def _set_default_value_for_enumerized_attribute(attr)
+        super
+      rescue Mongoid::Errors::AttributeNotLoaded
+      end
+    end
+  end
+end

data/lib/enumerize/predicatable.rb

@@ -1,30 +1,23 @@
+# frozen_string_literal: true
+
 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)
-      method[-1] == '?' && @attr.values.include?(method[0..-2])
+    def predicate_method?(method)
+      method[-1] == '?' && @attr && @attr.value?(method[0..-2])
     end
   end
 end

data/lib/enumerize/predicates.rb

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

data/lib/enumerize/scope/activerecord.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Enumerize
+  module Scope
+    module ActiveRecord
+      def enumerize(name, options={})
+        super
+
+        _enumerize_module.dependent_eval do
+          if self < ::ActiveRecord::Base
+            if options[:scope]
+              _define_activerecord_scope_methods!(name, options)
+            end
+          end
+        end
+      end
+
+      private
+
+      def _define_activerecord_scope_methods!(name, options)
+        return _define_activerecord_shallow_scopes!(name) if options[:scope] == :shallow
+
+        scope_name = options[:scope] == true ? "with_#{name}" : options[:scope]
+
+        define_singleton_method scope_name do |*values|
+          values = enumerized_attributes[name].find_values(*values).map(&:value)
+          values = values.first if values.size == 1
+
+          where(name => values)
+        end
+
+        if options[:scope] == true
+          define_singleton_method "without_#{name}" do |*values|
+            values = enumerized_attributes[name].find_values(*values).map(&:value)
+            where(arel_table[name].not_in(values))
+          end
+        end
+      end
+
+      def _define_activerecord_shallow_scopes!(attribute_name)
+        enumerized_attributes[attribute_name].each_value do |value_obj|
+          define_singleton_method(value_obj) do
+            where(attribute_name => value_obj.value)
+          end
+
+          define_singleton_method("not_#{value_obj}") do
+            where.not(attribute_name => value_obj.value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/enumerize/scope/mongoid.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Enumerize
+  module Scope
+    module Mongoid
+      def enumerize(name, options={})
+        super
+
+        _enumerize_module.dependent_eval do
+          if self < ::Mongoid::Document
+            if options[:scope]
+              _define_mongoid_scope_methods!(name, options)
+            end
+          end
+        end
+      end
+
+      private
+
+      def _define_mongoid_scope_methods!(name, options)
+        return _define_mongoid_shallow_scopes!(name) if options[:scope] == :shallow
+        scope_name = options[:scope] == true ? "with_#{name}" : options[:scope]
+
+        define_singleton_method scope_name do |*values|
+          values = enumerized_attributes[name].find_values(*values).map(&:value)
+          self.in(name => values)
+        end
+
+        if options[:scope] == true
+          define_singleton_method "without_#{name}" do |*values|
+            values = enumerized_attributes[name].find_values(*values).map(&:value)
+            not_in(name => values)
+          end
+        end
+      end
+
+      def _define_mongoid_shallow_scopes!(attribute_name)
+        enumerized_attributes[attribute_name].each_value do |value_obj|
+          define_singleton_method(value_obj) do
+            self.in(attribute_name => value_obj.value)
+          end
+
+          define_singleton_method("not_#{value_obj}") do
+            self.not_in(attribute_name => value_obj.value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/enumerize/scope/sequel.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Enumerize
+  module Scope
+    module Sequel
+      def enumerize(name, options={})
+        super
+
+        _enumerize_module.dependent_eval do
+          if defined?(::Sequel::Model) && self < ::Sequel::Model
+            if options[:scope]
+              _define_sequel_scope_methods!(name, options)
+            end
+
+            require 'enumerize/hooks/sequel_dataset'
+          end
+        end
+      end
+
+      private
+
+      def _define_sequel_scope_methods!(name, options)
+        return _define_sequel_shallow_scopes!(name) if options[:scope] == :shallow
+
+        klass = self
+        scope_name = options[:scope] == true ? "with_#{name}" : options[:scope]
+
+        def_dataset_method scope_name do |*values|
+          values = values.map { |value| klass.enumerized_attributes[name].find_value(value).value }
+          values = values.first if values.size == 1
+
+          where(name => values)
+        end
+
+        if options[:scope] == true
+          def_dataset_method "without_#{name}" do |*values|
+            values = values.map { |value| klass.enumerized_attributes[name].find_value(value).value }
+            exclude(name => values)
+          end
+        end
+      end
+
+      def _define_sequel_shallow_scopes!(attribute_name)
+        enumerized_attributes[attribute_name].each_value do |value_obj|
+          def_dataset_method(value_obj) do
+            where(attribute_name => value_obj.value.to_s)
+          end
+
+          def_dataset_method("not_#{value_obj}") do
+            exclude(attribute_name => value_obj.value.to_s)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/enumerize/sequel.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Enumerize
+  module SequelSupport
+    def enumerize(name, options={})
+      super
+
+      _enumerize_module.dependent_eval do
+        if defined?(::Sequel::Model) && self < ::Sequel::Model
+          include InstanceMethods
+
+          require 'enumerize/hooks/sequel_dataset'
+        end
+      end
+    end
+
+    private
+
+    module InstanceMethods
+      def validate
+        super
+
+        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, "is invalid" unless value.respond_to?(:all?) && value.all? { |v| v.blank? || attr.find_value(v) }
+          else
+            errors.add attr.name, "is not included in the list" unless attr.find_value(value)
+          end
+        end
+      end
+
+      def _set_default_value_for_enumerized_attributes
+        _enumerized_values_for_validation.delete_if do |k, v|
+          v.nil?
+        end
+
+        if defined?(Sequel::Plugins::Serialization::InstanceMethods)
+          modules = self.class.ancestors
+          plugin_idx = modules.index(Sequel::Plugins::Serialization::InstanceMethods)
+
+          if plugin_idx && plugin_idx < modules.index(Enumerize::SequelSupport::InstanceMethods)
+            abort "ERROR: You need to enable the Sequel serialization plugin before calling any enumerize methods on a model."
+          end
+
+          plugin_idx = modules.index(Sequel::Plugins::ValidationHelpers::InstanceMethods)
+
+          if plugin_idx && plugin_idx < modules.index(Enumerize::SequelSupport::InstanceMethods)
+            abort "ERROR: You need to enable the Sequel validation_helpers plugin before calling any enumerize methods on a model."
+          end
+        end
+
+        super
+      end
+    end
+  end
+end

data/lib/enumerize/set.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/module/delegation'
+
 module Enumerize
   class Set
     include Enumerable
@@ -8,12 +12,15 @@ module Enumerize
     def initialize(obj, attr, values)
       @obj    = obj
       @attr   = attr
-      @values = ::Set.new
+      @values = []
 
       if values.respond_to?(:each)
         values.each do |input|
           value = @attr.find_value(input)
-          @values << value if value
+
+          if value && !@values.include?(value)
+            @values << value
+          end
         end
       end
     end
@@ -31,9 +38,14 @@ module Enumerize
       @values.to_a
     end
 
+    def texts
+      @values.map(&:text)
+    end
+
     delegate :join, to: :to_ary
 
     def ==(other)
+      return false unless other.respond_to?(:each)
       other.size == size && other.all? { |v| @values.include?(@attr.find_value(v)) }
     end
 
@@ -52,14 +64,14 @@ module Enumerize
       "#<Enumerize::Set {#{join(', ')}}>"
     end
 
+    def encode_with(coder)
+      coder.represent_object(Array, @values)
+    end
+
     private
 
-    def define_query_method(value)
-      singleton_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def #{value}?
-          include?("#{value}")
-        end
-      RUBY
+    def predicate_call(value)
+      include?(value)
     end
 
     def mutate!

data/lib/enumerize/utils.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Enumerize
+  module Utils
+    class << self
+      def call_if_callable(value, param = nil)
+        return value unless value.respond_to?(:call)
+        value.arity == 0 ? value.call : value.call(param)
+      end
+    end
+  end
+end

data/lib/enumerize/value.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require 'i18n'
+require 'active_support/inflector'
 
 module Enumerize
   class Value < String
@@ -7,14 +10,28 @@ module Enumerize
     attr_reader :value
 
     def initialize(attr, name, value=nil)
+      if self.class.method_defined?("#{name}?")
+        warn("It's not recommended to use `#{name}` as a field value since `#{name}?` is defined. (#{attr.klass.name}##{attr.name})")
+      end
+
       @attr  = attr
       @value = value.nil? ? name.to_s : value
 
       super(name.to_s)
+
+      @i18n_keys = @attr.i18n_scopes.map { |s| :"#{s}.#{self}" }
+      @i18n_keys << :"enumerize.defaults.#{@attr.name}.#{self}"
+      @i18n_keys << :"enumerize.#{@attr.name}.#{self}"
+      @i18n_keys << ActiveSupport::Inflector.humanize(ActiveSupport::Inflector.underscore(self)) # humanize value if there are no translations
+      @i18n_keys
     end
 
     def text
-      I18n.t(i18n_keys[0], :default => i18n_keys[1..-1])
+      I18n.t(@i18n_keys[0], :default => @i18n_keys[1..-1]) if @i18n_keys
+    end
+
+    def ==(other)
+      super(other.to_s) || value == other
     end
 
     def encode_with(coder)
@@ -23,25 +40,8 @@ module Enumerize
 
     private
 
-    def define_query_method(value)
-      singleton_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def #{value}?
-          #{value == self}
-        end
-      RUBY
-    end
-
-    def i18n_keys
-      @i18n_keys ||= begin
-        i18n_keys = i18n_scopes
-        i18n_keys << [:"enumerize.#{@attr.name}.#{self}"]
-        i18n_keys << self.humanize # humanize value if there are no translations
-        i18n_keys.flatten
-      end
-    end
-
-    def i18n_scopes
-      @attr.i18n_scopes.map { |s| :"#{s}.#{self}" }
+    def predicate_call(value)
+      value == self
     end
   end
 end

data/lib/enumerize/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Enumerize
-  VERSION = "0.8.0"
+  VERSION = '2.6.1'
 end