enumerize 0.3.0 → 2.3.1

data/test/set_test.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'yaml'
+
+describe Enumerize::Set do
+  let(:kklass) do
+    Class.new do
+      extend Enumerize
+      enumerize :foo, :in => %w(a b c), :multiple => true
+    end
+  end
+
+  let(:object) { kklass.new }
+
+  def build_set(values)
+    @set = Enumerize::Set.new(object, kklass.foo, values)
+  end
+
+  def set
+    @set
+  end
+
+  def assert_called(object, method)
+    called = false
+
+    object.singleton_class.class_eval do
+      define_method method do |*args, &block|
+        called = true
+        super(*args, &block)
+      end
+    end
+
+    yield
+
+    assert called, "Expected ##{method} to be called"
+  end
+
+  before do
+    build_set %w(a)
+  end
+
+  it 'equals to other set' do
+    set.must_equal Enumerize::Set.new(nil, kklass.foo, %w(a))
+  end
+
+  it 'equals to array' do
+    set.must_equal %w(a)
+  end
+
+  it 'equals to array of symbols' do
+    set.must_equal [:a]
+  end
+
+  it 'has unique values' do
+    set << :a
+    set.must_equal %w(a)
+  end
+
+  it 'equals to array with different value order' do
+    set << :b
+    set.must_equal %w(b a)
+  end
+
+  it "isn't equal to a part of values" do
+    set << :b
+    set.wont_equal %w(a)
+  end
+
+  describe '#push' do
+    it 'appends values' do
+      set.push :b
+      set.must_include :b
+    end
+
+    it 'reassigns attribute' do
+      assert_called object, :foo= do
+        set.push :b
+      end
+    end
+  end
+
+  describe '#delete' do
+    it 'deletes value' do
+      set.delete :a
+      set.wont_include :a
+    end
+
+    it 'reassigns attribute' do
+      assert_called object, :foo= do
+        set.delete :a
+      end
+    end
+  end
+
+  describe '#inspect' do
+    it 'returns custom string' do
+      set << :b
+      set.inspect.must_equal '#<Enumerize::Set {a, b}>'
+    end
+  end
+
+  describe '#to_ary' do
+    it 'returns array' do
+      set.to_ary.must_be_instance_of Array
+    end
+  end
+
+  describe '#texts' do
+    it 'returns array of text values' do
+      set.texts.must_equal ['A']
+    end
+  end
+
+  describe '#join' do
+    it 'joins values' do
+      set << :b
+      set.join(', ').must_equal 'a, b'
+    end
+  end
+
+  describe 'boolean methods comparison' do
+    it 'returns true if value equals method' do
+      set << :a
+      set.a?.must_equal true
+    end
+
+    it 'returns false if value does not equal method' do
+      set << :a
+      set.b?.must_equal false
+    end
+
+    it 'raises NoMethodError if there are no values like boolean method' do
+      proc {
+        set.some_method?
+      }.must_raise NoMethodError
+    end
+
+    it 'raises ArgumentError if arguments are passed' do
+      proc {
+        set.a?('<3')
+      }.must_raise ArgumentError
+    end
+
+    it 'responds to methods for existing values' do
+      set.must_respond_to :a?
+      set.must_respond_to :b?
+      set.must_respond_to :c?
+    end
+
+    it 'returns a method object' do
+      set.method(:a?).must_be_instance_of Method
+    end
+
+    it 'does not respond to a method for not existing value' do
+      set.wont_respond_to :some_method?
+    end
+  end
+
+  describe 'serialization' do
+    it 'is serialized to yaml as array' do
+      set << :a
+      assert_equal YAML.dump(%w(a)), YAML.dump(set)
+    end
+  end
+end

data/test/simple_form_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 require 'simple_form/version'
 
@@ -5,11 +7,20 @@ class SimpleFormSpec < MiniTest::Spec
   include ViewTestHelper
   include SimpleForm::ActionViewExtensions::FormHelper
 
+  class Thing < Struct.new(:name)
+    extend ActiveModel::Naming
+    include ActiveModel::Conversion
+
+    def persisted?
+      false
+    end
+  end
+
   class User < Struct.new(:sex, :age)
     extend ActiveModel::Naming
     include ActiveModel::Conversion
 
-    include Enumerize
+    extend Enumerize
 
     enumerize :sex, :in => [:male, :female]
 
@@ -18,7 +29,36 @@ class SimpleFormSpec < MiniTest::Spec
     end
   end
 
+  class Post < Struct.new(:category, :title)
+    extend ActiveModel::Naming
+    include ActiveModel::Conversion
+
+    extend Enumerize
+
+    enumerize :categories, :in => [:music, :games], :multiple => true
+
+    def persisted?
+      false
+    end
+  end
+
+  class Registration < Struct.new(:sex)
+    extend Enumerize
+
+    enumerize :sex, in: [:male, :female]
+  end
+
   let(:user) { User.new }
+  let(:post) { Post.new }
+
+  it 'renders select with enumerized values using input_field' do
+    concat(simple_form_for(user) do |f|
+      f.input_field(:sex)
+    end)
+
+    assert_select 'select option[value=male]'
+    assert_select 'select option[value=female]'
+  end
 
   it 'renders select with enumerized values' do
     concat(simple_form_for(user) do |f|
@@ -29,11 +69,52 @@ class SimpleFormSpec < MiniTest::Spec
     assert_select 'select option[value=female]'
   end
 
-  it 'renders radio buttons with enumerated values' do
-    as = SimpleForm::VERSION > '2.0' ? :radio_buttons : :radio
+  it 'renders multiple select with enumerized values' do
+    concat(simple_form_for(post) do |f|
+      f.input(:categories)
+    end)
+
+    assert_select 'select[multiple=multiple]'
+    assert_select 'select option[value=music]'
+    assert_select 'select option[value=games]'
+  end
 
+  it 'renders multiple select with selected enumerized value' do
+    post.categories << :music
+
+    concat(simple_form_for(post) do |f|
+      f.input(:categories)
+    end)
+
+    assert_select 'select[multiple=multiple]'
+    assert_select 'select option[value=music][selected=selected]'
+    assert_select 'select option[value=games][selected=selected]', count: 0
+  end
+
+  it 'renders checkboxes with enumerized values' do
+    concat(simple_form_for(post) do |f|
+      f.input(:categories, as: :check_boxes)
+    end)
+
+    assert_select 'select[multiple=multiple]', count: 0
+    assert_select 'input[type=checkbox][value=music]'
+    assert_select 'input[type=checkbox][value=games]'
+  end
+
+  it 'renders checkboxes with selected enumerized value' do
+    post.categories << :music
+
+    concat(simple_form_for(post) do |f|
+      f.input(:categories, as: :check_boxes)
+    end)
+
+    assert_select 'input[type=checkbox][value=music][checked=checked]'
+    assert_select 'input[type=checkbox][value=games][checked=checked]', count: 0
+  end
+
+  it 'renders radio buttons with enumerated values' do
     concat(simple_form_for(user) do |f|
-      f.input(:sex, :as => as)
+      f.input(:sex, :as => :radio_buttons)
     end)
 
     assert_select 'input[type=radio][value=male]'
@@ -47,4 +128,29 @@ class SimpleFormSpec < MiniTest::Spec
 
     assert_select 'input.string'
   end
+
+  it 'does not affect not enumerized classes' do
+    concat(simple_form_for(Thing.new) do |f|
+      f.input(:name)
+    end)
+
+    assert_select 'input.string'
+  end
+
+  it 'renders select with enumerized values for non-ActiveModel object' do
+    concat(simple_form_for(Registration.new, as: 'registration', url: '/') do |f|
+      f.input(:sex)
+    end)
+
+    assert_select 'select option[value=male]'
+    assert_select 'select option[value=female]'
+  end
+
+  it 'does not affect forms without object' do
+    concat(simple_form_for('') do |f|
+      f.input(:name)
+    end)
+
+    assert_select 'input.string'
+  end
 end

data/test/support/mock_controller.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class MockController
   attr_writer :action_name
 
@@ -17,5 +19,13 @@ class MockController
     self
   end
 
-  def hash_for_users_path(*args); end
+  def url_options
+    {}
+  end
+
+  def hash_for_users_path(*); end
+
+  def polymorphic_mappings
+    {}
+  end
 end

data/test/support/shared_enums.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'active_record'
+require 'sequel'
+
+module EnumerizeExtention
+  def self.included(base)
+    case
+    when base < ActiveRecord::Base
+      base.extend Enumerize
+    when base < Sequel::Model
+      base.plugin :enumerize
+    end
+  end
+end
+
+module SkipValidationsEnum
+  def self.included(base)
+    base.include EnumerizeExtention
+    base.enumerize :foo, :in => [:bar, :baz], :skip_validations => true
+  end
+end
+
+module DoNotSkipValidationsEnum
+  def self.included(base)
+    base.include EnumerizeExtention
+    base.enumerize :foo, :in => [:bar, :baz], :skip_validations => false
+  end
+end
+
+module SkipValidationsLambdaEnum
+  def self.included(base)
+    base.include EnumerizeExtention
+    base.enumerize :foo, :in => [:bar, :baz], :skip_validations => lambda { true }
+  end
+end
+
+module SkipValidationsLambdaWithParamEnum
+  def self.included(base)
+    base.include EnumerizeExtention
+    base.enumerize :foo, :in => [:bar, :baz], :skip_validations => lambda { |record| true }
+  end
+end

data/test/support/view_test_helper.rb

@@ -1,6 +1,12 @@
+# frozen_string_literal: true
+
 require 'active_support/concern'
 require 'active_support/testing/setup_and_teardown'
 
+if defined?(ActionView::RoutingUrlFor)
+  ActionView::RoutingUrlFor.send(:include, ActionDispatch::Routing::UrlFor)
+end
+
 module ViewTestHelper
   extend ActiveSupport::Concern
 

data/test/test_helper.rb

@@ -1,17 +1,36 @@
+# frozen_string_literal: true
+
 require 'minitest/autorun'
 require 'minitest/spec'
 require 'active_support/core_ext/kernel/reporting'
+require 'active_model'
+require 'rails'
+begin
+  require 'mongoid'
+rescue LoadError
+end
 
-$VERBOSE=true
+module RailsAdmin
+end
 
-module SimpleForm
-  module Rails
-    def self.env
-      ActiveSupport::StringInquirer.new("test")
-    end
+require 'simple_form'
+SimpleForm.setup {}
+
+require 'formtastic'
+
+module EnumerizeTest
+  class Application < Rails::Application
+    config.active_support.deprecation = :stderr
+    config.active_support.test_order = :random
+    config.eager_load = false
+    config.secret_key_base = 'secret'
   end
 end
 
+EnumerizeTest::Application.initialize!
+
+$VERBOSE=true
+
 require 'enumerize'
 
 Dir["#{File.dirname(__FILE__)}/support/*.rb"].each do |file|

data/test/value_test.rb

@@ -1,49 +1,138 @@
+# frozen_string_literal: true
+
 require 'test_helper'
+require 'yaml'
 
 describe Enumerize::Value do
-  let(:attr)  { Struct.new(:values).new([]) }
-  let(:value) { Enumerize::Value.new(attr, 'test_value') }
+  class Attr < Struct.new(:values, :name, :i18n_scopes)
+  end
+
+  let(:attr) { Attr.new([], "attribute_name", []) }
+  let(:val) { Enumerize::Value.new(attr, 'test_value', 1) }
 
   it 'is a string' do
-    value.must_be_kind_of String
+    val.must_be_kind_of String
+  end
+
+  describe 'equality' do
+    it 'is compared to string' do
+      val.must_be :==, 'test_value'
+      val.wont_be :==, 'not_value'
+    end
+
+    it 'is compared to symbol' do
+      val.must_be :==, :test_value
+      val.wont_be :==, :not_value
+    end
+
+    it 'is compared to integer' do
+      val.must_be :==, 1
+      val.wont_be :==, 2
+    end
   end
 
-  it 'is compared to string' do
-    value.must_be :==, 'test_value'
+  describe 'translation' do
+
+    it 'uses common translation' do
+      store_translations(:en, :enumerize => {:attribute_name => {:test_value => "Common translation"}}) do
+        val.text.must_be :==, "Common translation"
+      end
+    end
+
+    it 'uses default translation from the "default" section if its present' do
+      store_translations(:en, :enumerize => {:defaults => {:attribute_name => {:test_value => "Common translation"}}}) do
+        val.text.must_be :==, "Common translation"
+      end
+    end
+
+    it 'uses model specific translation' do
+      attr.i18n_scopes = ["enumerize.model_name.attribute_name"]
+
+      store_translations(:en, :enumerize => {:model_name => {:attribute_name => {:test_value => "Model Specific translation"}}}) do
+        val.text.must_be :==, "Model Specific translation"
+      end
+    end
+
+    it 'uses model specific translation rather than common translation' do
+      attr.i18n_scopes = ["enumerize.model_name.attribute_name"]
+
+      store_translations(:en, :enumerize => {:attribute_name => {:test_value => "Common translation"}, :model_name => {:attribute_name => {:test_value => "Model Specific translation"}}}) do
+        val.text.must_be :==, "Model Specific translation"
+      end
+    end
+
+    it 'uses simply humanized value when translation is undefined' do
+      store_translations(:en, :enumerize => {}) do
+        val.text.must_be :==, "Test value"
+      end
+    end
+
+    it 'uses specified in options translation scope' do
+      attr.i18n_scopes = ["other.scope"]
+
+      store_translations(:en, :other => {:scope => {:test_value => "Scope specific translation"}}) do
+        val.text.must_be :==, "Scope specific translation"
+      end
+    end
+
+    it 'uses first found translation scope from options' do
+      attr.i18n_scopes = ["nonexistent.scope", "other.scope"]
+
+      store_translations(:en, :other => {:scope => {:test_value => "Scope specific translation"}}) do
+        val.text.must_be :==, "Scope specific translation"
+      end
+    end
   end
 
   describe 'boolean methods comparison' do
     before do
-      attr.values = [value, Enumerize::Value.new(attr, 'other_value')]
+      attr.values = [val, Enumerize::Value.new(attr, 'other_value')]
     end
 
     it 'returns true if value equals method' do
-      value.test_value?.must_equal true
+      val.test_value?.must_equal true
     end
 
     it 'returns false if value does not equal method' do
-      value.other_value?.must_equal false
+      val.other_value?.must_equal false
     end
 
     it 'raises NoMethodError if there are no values like boolean method' do
       proc {
-        value.some_method?
+        val.some_method?
       }.must_raise NoMethodError
     end
 
     it 'raises ArgumentError if arguments are passed' do
       proc {
-        value.other_value?('<3')
+        val.other_value?('<3')
       }.must_raise ArgumentError
     end
 
     it 'responds to methods for existing values' do
-      value.must_respond_to :test_value?
-      value.must_respond_to :other_value?
+      val.must_respond_to :test_value?
+      val.must_respond_to :other_value?
+    end
+
+    it 'returns a method object' do
+      val.method(:test_value?).must_be_instance_of Method
     end
 
     it "doesn't respond to a method for not existing value" do
-      value.wont_respond_to :some_method?
+      val.wont_respond_to :some_method?
+    end
+  end
+
+  describe 'serialization' do
+    let(:val) { Enumerize::Value.new(attr, 'test_value') }
+
+    it 'should be serialized to yaml as string value' do
+      assert_equal YAML.dump('test_value'), YAML.dump(val)
+    end
+
+    it 'serializes with Marshal' do
+      dump_value = Marshal.dump(val)
+      Marshal.load(dump_value).must_equal 'test_value'
     end
   end
 end