enumerize 0.3.0 → 2.3.1

data/lib/enumerize/value.rb

@@ -1,69 +1,42 @@
+# frozen_string_literal: true
+
 require 'i18n'
 
 module Enumerize
   class Value < String
+    include Predicatable
+
+    attr_reader :value
+
     def initialize(attr, name, value=nil)
       @attr  = attr
-      @value = value || name.to_s
+      @value = value.nil? ? name.to_s : value
 
       super(name.to_s)
-    end
 
-    def value
-      @value
+      @i18n_keys = @attr.i18n_scopes.map { |s| :"#{s}.#{self}" }
+      @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
 
     def text
-      I18n.t(i18n_keys[0], :default => i18n_keys[1..-1])
+      I18n.t(@i18n_keys[0], :default => @i18n_keys[1..-1])
     end
 
-    def method_missing(method, *args, &block)
-      if method[-1] == '?' && @attr.values.include?(method[0..-2])
-        define_query_methods
-        send(method, *args, &block)
-      else
-        super
-      end
+    def ==(other)
+      super(other.to_s) || value == other
     end
 
-    def respond_to?(method, include_private=false)
-      if super
-        true
-      elsif method[-1] == '?' && @attr.values.include?(method[0..-2])
-        define_query_methods
-        super
-      end
+    def encode_with(coder)
+      coder.represent_object(self.class.superclass, @value)
     end
 
     private
 
-    def define_query_methods
-      @attr.values.each do |value|
-        unless singleton_methods.include?(:"#{value}?")
-          singleton_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def #{value}?
-              #{value == self}
-            end
-          RUBY
-        end
-      end
-    end
-
-    def i18n_keys
-      @i18n_keys ||= begin
-        i18n_keys = []
-        i18n_keys << i18n_scope
-        i18n_keys << i18n_scope(i18n_suffix)
-        i18n_keys << self.humanize # humanize value if there are no translations
-      end
-    end
-
-    def i18n_scope(suffix = nil)
-      :"enumerize.#{suffix}#{@attr.name}.#{self}"
-    end
-
-    def i18n_suffix
-      "#{@attr.i18n_suffix}." if @attr.i18n_suffix
+    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.3.0"
+  VERSION = '2.3.1'
 end

data/lib/enumerize.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_support/concern'
 require 'enumerize/version'
 
@@ -5,17 +7,59 @@ module Enumerize
   autoload :Attribute,    'enumerize/attribute'
   autoload :AttributeMap, 'enumerize/attribute_map'
   autoload :Value,        'enumerize/value'
+  autoload :Set,          'enumerize/set'
   autoload :Base,         'enumerize/base'
-  autoload :ActiveRecord, 'enumerize/activerecord'
+  autoload :Module,       'enumerize/module'
+  autoload :Predicates,   'enumerize/predicates'
+  autoload :Predicatable, 'enumerize/predicatable'
+  autoload :Utils,        'enumerize/utils'
   autoload :ModuleAttributes, 'enumerize/module_attributes'
 
+  autoload :ActiveModelAttributesSupport, 'enumerize/activemodel'
+  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
+    extended(base)
+  end
+
+  def self.extended(base)
     base.send :include, Enumerize::Base
-    if defined?(::ActiveRecord::Base) && base < ::ActiveRecord::Base
-      base.extend Enumerize::ActiveRecord
+    base.extend Enumerize::Predicates
+
+    if defined?(::ActiveModel::Attributes)
+      base.extend Enumerize::ActiveModelAttributesSupport
     end
 
-    if Module === base
+    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'
+      base.extend Enumerize::Integrations::RailsAdmin
+    end
+
+    if ::Module === base
       base.extend Enumerize::Base::ClassMethods
       base.extend Enumerize::ModuleAttributes
     end
@@ -26,6 +70,7 @@ module Enumerize
   begin
     require 'simple_form'
     require 'enumerize/hooks/simple_form'
+    require 'enumerize/form_helper'
   rescue LoadError
   end
 
@@ -34,4 +79,11 @@ module Enumerize
     require 'enumerize/hooks/formtastic'
   rescue LoadError
   end
+
+  begin
+    require 'rspec/matchers'
+  rescue LoadError
+  else
+    require 'enumerize/integrations/rspec'
+  end
 end

data/lib/sequel/plugins/enumerize.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Sequel
+  module Plugins
+    module Enumerize
+      # Depend on the def_dataset_method plugin
+      def self.apply(model)
+        model.plugin(:def_dataset_method) unless model.respond_to?(:def_dataset_method)
+      end
+
+      module InstanceMethods
+        def self.included(base)
+          base.extend ::Enumerize
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+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,30 @@
+# frozen_string_literal: true
+
+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

data/test/activemodel_test.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+if defined?(::ActiveModel::Attributes)
+
+describe Enumerize do
+  class ActiveModelUser
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+    extend Enumerize
+
+    attribute :name, :string
+    enumerize :sex, :in => %w[male female]
+    enumerize :role, :in => %w[admin user], :default => 'user'
+    enumerize :interests, :in => [:music, :sports, :dancing, :programming], :multiple => true
+  end
+
+  class InterestsRequiredActiveModelUser < ActiveModelUser
+    validates :interests, presence: true
+  end
+
+  let(:model) { ActiveModelUser }
+
+  it 'initialize value' do
+    user = model.new(:name => 'active_model_user', :sex => :male, :role => :user, :interests => [:music, :programming])
+    user.sex.must_equal 'male'
+    user.sex_text.must_equal 'Male'
+    user.role.must_equal 'user'
+    user.role_text.must_equal 'User'
+    user.interests.must_equal %w(music programming)
+  end
+
+  it 'sets nil if invalid value is passed' do
+    user = model.new
+    user.sex = :invalid
+    user.sex.must_be_nil
+  end
+
+  it 'stores value' do
+    user = model.new
+    user.sex = :female
+    user.sex.must_equal 'female'
+  end
+
+  it 'has default value' do
+    model.new.role.must_equal 'user'
+  end
+
+  it 'validates inclusion' do
+    user = model.new
+    user.role = 'wrong'
+    user.wont_be :valid?
+  end
+
+  it 'supports multiple attributes' do
+    user = ActiveModelUser.new
+    user.interests.must_be_instance_of Enumerize::Set
+    user.interests.must_be_empty
+    user.interests << :music
+    user.interests.must_equal %w(music)
+    user.interests << :sports
+    user.interests.must_equal %w(music sports)
+
+    user.interests = []
+    interests = user.interests
+    interests << :music
+    interests.must_equal %w(music)
+    interests << :dancing
+    interests.must_equal %w(music dancing)
+  end
+
+  it 'returns invalid multiple value for validation' do
+    user = ActiveModelUser.new
+    user.interests << :music
+    user.interests << :invalid
+    values = user.read_attribute_for_validation(:interests)
+    values.must_equal %w(music invalid)
+  end
+
+  it 'validates multiple attributes' do
+    user = ActiveModelUser.new
+    user.interests << :invalid
+    user.wont_be :valid?
+
+    user.interests = Object.new
+    user.wont_be :valid?
+
+    user.interests = ['music', '']
+    user.must_be :valid?
+  end
+
+  it 'validates presence with multiple attributes' do
+    user = InterestsRequiredActiveModelUser.new
+    user.interests = []
+    user.valid?
+
+    user.errors[:interests].wont_be :empty?
+
+    user.interests = ['']
+    user.valid?
+
+    user.errors[:interests].wont_be :empty?
+
+    user.interests = [:dancing, :programming]
+    user.valid?
+
+    user.errors[:interests].must_be_empty
+  end
+end
+
+else
+  # Skip
+end