enumerize 0.8.0 → 2.1.2

data/lib/enumerize/scope/activerecord.rb

@@ -0,0 +1,37 @@
+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)
+        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
+    end
+  end
+end

data/lib/enumerize/scope/mongoid.rb

@@ -0,0 +1,35 @@
+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)
+        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
+    end
+  end
+end

data/lib/enumerize/scope/sequel.rb

@@ -0,0 +1,40 @@
+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)
+        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
+    end
+  end
+end

data/lib/enumerize/sequel.rb

@@ -0,0 +1,57 @@
+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|
+          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,5 @@
+require 'active_support/core_ext/module/delegation'
+
 module Enumerize
   class Set
     include Enumerable
@@ -8,12 +10,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 +36,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 +62,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/value.rb

@@ -17,26 +17,27 @@ module Enumerize
       I18n.t(i18n_keys[0], :default => i18n_keys[1..-1])
     end
 
+    def ==(other)
+      super(other.to_s) || value == other
+    end
+
     def encode_with(coder)
       coder.represent_object(self.class.superclass, @value)
     end
 
     private
 
-    def define_query_method(value)
-      singleton_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def #{value}?
-          #{value == self}
-        end
-      RUBY
+    def predicate_call(value)
+      value == self
     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
+        i18n_keys << :"enumerize.defaults.#{@attr.name}.#{self}"
+        i18n_keys << :"enumerize.#{@attr.name}.#{self}"
+        i18n_keys << self.underscore.humanize # humanize value if there are no translations
+        i18n_keys
       end
     end
 

data/lib/enumerize/version.rb

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

data/lib/enumerize.rb

@@ -13,6 +13,14 @@ module Enumerize
   autoload :ModuleAttributes, 'enumerize/module_attributes'
 
   autoload :ActiveRecordSupport, 'enumerize/activerecord'
+  autoload :SequelSupport, 'enumerize/sequel'
+  autoload :MongoidSupport,      'enumerize/mongoid'
+
+  module Scope
+    autoload :ActiveRecord, 'enumerize/scope/activerecord'
+    autoload :Sequel, 'enumerize/scope/sequel'
+    autoload :Mongoid,      'enumerize/scope/mongoid'
+  end
 
   def self.included(base)
     ActiveSupport::Deprecation.warn '`include Enumerize` was deprecated. Please use `extend Enumerize`.', caller
@@ -22,7 +30,21 @@ module Enumerize
   def self.extended(base)
     base.send :include, Enumerize::Base
     base.extend Enumerize::Predicates
-    base.extend Enumerize::ActiveRecordSupport
+
+    if defined?(::ActiveRecord::Base)
+      base.extend Enumerize::ActiveRecordSupport
+      base.extend Enumerize::Scope::ActiveRecord
+    end
+
+    if defined?(::Mongoid::Document)
+      base.extend Enumerize::MongoidSupport
+      base.extend Enumerize::Scope::Mongoid
+    end
+
+    if defined?(::Sequel::Model)
+      base.extend Enumerize::SequelSupport
+      base.extend Enumerize::Scope::Sequel
+    end
 
     if defined?(::RailsAdmin)
       require 'enumerize/integrations/rails_admin'

data/spec/enumerize/integrations/rspec/matcher_spec.rb

@@ -0,0 +1,258 @@
+require 'active_record'
+
+silence_warnings do
+  ActiveRecord::Migration.verbose = false
+  ActiveRecord::Base.logger = Logger.new(nil)
+  ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+end
+
+ActiveRecord::Base.connection.instance_eval do
+  create_table :users do |t|
+    t.string :sex
+    t.string :role
+    t.string :account_type
+  end
+end
+
+class User < ActiveRecord::Base
+  extend Enumerize
+
+  enumerize :sex, :in => [:male, :female], scope: true
+  enumerize :role, :in => [:user, :admin], scope: :having_role
+  enumerize :account_type, :in => [:basic, :premium]
+end
+
+RSpec.describe Enumerize::Integrations::RSpec::Matcher do
+
+  let(:model) do
+    Class.new do
+      extend Enumerize
+
+      def self.name
+        'Model'
+      end
+    end
+  end
+
+  subject do
+    model.new
+  end
+
+  describe 'without qualifier' do
+
+    it 'accepts when has defined a enumerize' do
+      model.enumerize(:sex, :in => [:male, :female])
+      expect(subject).to enumerize(:sex)
+    end
+
+    it 'rejects when has not defined a enumerize' do
+      message = 'Expected Model to define enumerize :sex'
+      expect do
+        expect(subject).to enumerize(:sex)
+      end.to fail_with(message)
+    end
+  end
+
+  describe '#in' do
+
+    context 'defined as array' do
+
+      before do
+        model.enumerize(:sex, :in => [:male, :female])
+      end
+
+      it 'accepts the right params as an array' do
+        expect(subject).to enumerize(:sex).in([:male, :female])
+      end
+
+      it 'accepts the right params as regular params' do
+        expect(subject).to enumerize(:sex).in(:male, :female)
+      end
+
+      it 'accepts the the right params in a different order' do
+        expect(subject).to enumerize(:sex).in(:female, :male)
+      end
+
+      it 'rejects wrong params' do
+        message = 'Expected Model to define enumerize :sex in: "boy", "girl"'
+        expect do
+          expect(subject).to enumerize(:sex).in(:boy, :girl)
+        end.to fail_with(message)
+      end
+
+      it 'has the right message when negated' do
+        message = 'Did not expect Model to define enumerize :sex in: "female", "male"'
+        expect do
+          expect(subject).to_not enumerize(:sex).in(:male, :female)
+        end.to fail_with(message)
+      end
+    end
+
+    context 'defined as hash' do
+
+      before do
+        model.enumerize(:sex, :in => { male: 0, female: 1 })
+      end
+
+      it 'accepts the right params as an array' do
+        expect(subject).to enumerize(:sex).in(:male, :female)
+      end
+
+      it 'accepts the right params as a hash' do
+        expect(subject).to enumerize(:sex).in(male: 0, female: 1)
+      end
+
+      it 'accepts the right params as a hash in a different order' do
+        expect(subject).to enumerize(:sex).in(female: 1, male: 0)
+      end
+
+      it 'rejects wrong keys' do
+        message = 'Expected Model to define enumerize :sex in: "{:boy=>0, :girl=>1}"'
+        expect do
+          expect(subject).to enumerize(:sex).in(boy: 0, girl: 1)
+        end.to fail_with(message)
+      end
+
+      it 'rejects wrong values' do
+        message = 'Expected Model to define enumerize :sex in: "{:male=>2, :female=>3}"'
+        expect do
+        expect(subject).to enumerize(:sex).in(male: 2, female: 3)
+        end.to fail_with(message)
+      end
+    end
+
+    it 'has the right description' do
+      matcher = enumerize(:sex).in(:male, :female)
+      expect(matcher.description).to eq('define enumerize :sex in: "female", "male"')
+    end
+  end
+
+  describe '#with_default' do
+
+    before do
+      model.enumerize(:sex, :in => [:male, :female], default: :female)
+    end
+
+    it 'accepts the right default value' do
+      expect(subject).to enumerize(:sex).in(:male, :female).with_default(:female)
+    end
+
+    it 'rejects the wrong default value' do
+      message = 'Expected Model to define enumerize :sex in: "female", "male" with "male" as default value'
+      expect do
+        expect(subject).to enumerize(:sex).in(:male, :female).with_default(:male)
+      end.to fail_with(message)
+    end
+
+    it 'rejects if the `in` is wrong with a correct default value' do
+      message = 'Expected Model to define enumerize :sex in: "boy", "girl" with "female" as default value'
+      expect do
+        expect(subject).to enumerize(:sex).in(:boy, :girl).with_default(:female)
+      end.to fail_with(message)
+    end
+
+    it 'has the right description' do
+      matcher = enumerize(:sex).in(:male, :female).with_default(:female)
+      message = 'define enumerize :sex in: "female", "male" with "female" as default value'
+      expect(matcher.description).to eq(message)
+    end
+  end
+
+  describe '#with_i18n_scope' do
+
+    context 'defined as string' do
+
+      before do
+        model.enumerize(:sex, :in => [:male, :female], i18n_scope: 'sex')
+      end
+
+      it 'accepts the right i18n_scope' do
+        expect(subject).to enumerize(:sex).in(:male, :female).with_i18n_scope('sex')
+      end
+
+      it 'rejects the wrong i18n_scope' do
+        message = 'Expected Model to define enumerize :sex in: "female", "male" i18n_scope: "gender"'
+        expect do
+          expect(subject).to enumerize(:sex).in(:male, :female).with_i18n_scope('gender')
+        end.to fail_with(message)
+      end
+    end
+
+    context 'defined as array' do
+
+      before do
+        model.enumerize(:sex, :in => [:male, :female], i18n_scope: ['sex', 'more.sex'])
+      end
+
+      it 'accepts the wrong i18n_scope' do
+        expect(subject).to enumerize(:sex).in(:male, :female).with_i18n_scope(['sex', 'more.sex'])
+      end
+
+      it 'rejects the wrong i18n_scope' do
+        message = 'Expected Model to define enumerize :sex in: "female", "male" i18n_scope: ["sex"]'
+        expect do
+          expect(subject).to enumerize(:sex).in(:male, :female).with_i18n_scope(['sex'])
+        end.to fail_with(message)
+      end
+    end
+  end
+
+  describe '#with_predicates' do
+
+    it 'accepts when predicates is defined as a boolean' do
+      model.enumerize(:sex, :in => [:male, :female], predicates: true)
+      expect(subject).to enumerize(:sex).in(:male, :female).with_predicates(true)
+    end
+
+    it 'accepts when predicates is defined as a hash' do
+      model.enumerize(:sex, :in => [:male, :female], predicates: { prefix: true })
+      expect(subject).to enumerize(:sex).in(:male, :female).with_predicates(prefix: true)
+    end
+
+    it 'rejects when predicates is not defined' do
+      model.enumerize(:sex, :in => [:male, :female])
+      message = 'Expected Model to define enumerize :sex in: "female", "male" predicates: true'
+      expect do
+        expect(subject).to enumerize(:sex).in(:male, :female).with_predicates(true)
+      end.to fail_with(message)
+    end
+  end
+
+  describe '#with_multiple' do
+
+    it 'accepts when has defined the multiple' do
+      model.enumerize(:sex, :in => [:male, :female], multiple: true)
+      expect(subject).to enumerize(:sex).in(:male, :female).with_multiple(true)
+    end
+
+    it 'rejects when has not defined the multiple' do
+      model.enumerize(:sex, :in => [:male, :female])
+      message = 'Expected Model to define enumerize :sex in: "female", "male" multiple: true'
+      expect do
+        expect(subject).to enumerize(:sex).in(:male, :female).with_multiple(true)
+      end.to fail_with(message)
+    end
+  end
+
+  describe '#with_scope' do
+
+    subject do
+      User.new
+    end
+
+    it 'accepts when scope is defined as a boolean' do
+      expect(subject).to enumerize(:sex).in(:male, :female).with_scope(true)
+    end
+
+    it 'accepts when scope is defined as a hash' do
+      expect(subject).to enumerize(:role).in(:user, :admin).with_scope(scope: :having_role)
+    end
+
+    it 'rejects when scope is not defined' do
+      message = 'Expected User to define enumerize :account_type in: "basic", "premium" scope: true'
+      expect do
+        expect(subject).to enumerize(:account_type).in(:basic, :premium).with_scope(true)
+      end.to fail_with(message)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+require 'rails'
+require 'enumerize'
+require 'rspec/matchers/fail_matchers'
+
+RSpec.configure do |config|
+  config.disable_monkey_patching!
+  config.order = :random
+  Kernel.srand config.seed
+  config.filter_run focus: true
+  config.run_all_when_everything_filtered = true
+
+  config.expect_with :rspec do |expectations|
+    expectations.syntax = :expect
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.syntax = :expect
+    mocks.verify_partial_doubles = true
+  end
+
+  if config.files_to_run.one?
+    config.default_formatter = 'doc'
+  end
+
+  config.warnings = true
+  config.include RSpec::Matchers::FailMatchers
+end