careacademy-enumerize 2.8.0

data/test/attribute_map_test.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module Enumerize
+  class AttributeMapTest < MiniTest::Spec
+    subject { AttributeMap.new }
+
+    def make_attr(name)
+      Attribute.new(nil, name, :in => %[a b])
+    end
+
+    it 'empty when no attrs' do
+      expect(subject).must_be_empty
+    end
+
+    it 'not empty when attr added' do
+      subject << make_attr(:a)
+      expect(subject).wont_be_empty
+    end
+
+    it 'iterates over added attrs' do
+      attr_1 = make_attr(:a)
+      attr_2 = make_attr(:b)
+
+      subject << attr_1
+      subject << attr_2
+
+      count  = 0
+      actual = []
+
+      subject.each do |element|
+        count += 1
+        actual << element
+      end
+
+      expect(count).must_equal 2
+      expect(actual).must_equal [attr_1, attr_2]
+    end
+
+    it 'reads attribute by name' do
+      attr = make_attr(:a)
+      subject << attr
+      expect(subject[:a]).must_equal attr
+    end
+
+    it 'reads attribute by name using string' do
+      attr = make_attr(:a)
+      subject << attr
+      expect(subject['a']).must_equal attr
+    end
+
+    it 'updates dependants' do
+      attr = make_attr(:a)
+      dependant = MiniTest::Mock.new
+      dependant.expect(:<<, nil, [attr])
+      subject.add_dependant dependant
+      subject << attr
+      dependant.verify
+    end
+
+    it 'adds attrs to dependant' do
+      attr = make_attr(:a)
+      subject << attr
+      dependant = AttributeMap.new
+      subject.add_dependant dependant
+      expect(dependant[:a]).must_equal attr
+    end
+  end
+end

data/test/attribute_test.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+describe Enumerize::Attribute do
+  def attr
+    @attr ||= nil
+  end
+
+  def build_attr(*args, &block)
+    @attr = Enumerize::Attribute.new(*args, &block)
+  end
+
+  it 'returns values' do
+    build_attr nil, :foo, :in => [:a, :b]
+    expect(attr.values).must_equal %w[a b]
+  end
+
+  it 'returns frozen values' do
+    build_attr nil, :foo, :in => [:a, :b]
+    expect(attr.values.map(&:frozen?)).must_equal [true, true]
+  end
+
+  it 'converts name to symbol' do
+    build_attr nil, 'foo', :in => %w[a b]
+    expect(attr.name).must_equal :foo
+  end
+
+  it 'uses custom value class' do
+    value_class = Class.new(Enumerize::Value)
+    build_attr nil, 'foo', :in => %w[a b], :value_class => value_class
+    expect(attr.values.first).must_be_instance_of value_class
+  end
+
+  describe 'i18n scopes' do
+    it 'returns scopes from options' do
+      build_attr nil, 'foo', :in => %w[a b], :i18n_scope => %w[bar buzz]
+      expect(attr.i18n_scopes).must_equal %w[bar buzz]
+    end
+
+    it 'accepts only string scopes' do
+      expect(proc { build_attr nil, 'foo', :in => %w[a b], :i18n_scope => [%w[bar buzz], "bar.buzz"] }).must_raise ArgumentError
+    end
+  end
+
+  describe 'options for select' do
+    it 'returns all options for select' do
+      store_translations(:en, :enumerize => {:foo => {:a => 'a text', :b => 'b text'}}) do
+        build_attr nil, :foo, :in => %w[a b]
+        expect(attr.options).must_equal [['a text', 'a'], ['b text', 'b']]
+      end
+    end
+
+    it 'returns requested options for select via :only' do
+      store_translations(:en, :enumerize => {:foo => {:a => 'a text', :b => 'b text'}}) do
+        build_attr nil, :foo, :in => %w[a b]
+        expect(attr.options(:only => :a)).must_equal [['a text', 'a']]
+        expect(attr.options(:only => [:b])).must_equal [['b text', 'b']]
+        expect(attr.options(:only => [])).must_equal []
+      end
+    end
+
+    it 'returns requested options for select via :except' do
+      store_translations(:en, :enumerize => {:foo => {:a => 'a text', :b => 'b text'}}) do
+        build_attr nil, :foo, :in => %w[a b]
+        expect(attr.options(:except => :a)).must_equal [['b text', 'b']]
+        expect(attr.options(:except => :b)).must_equal [['a text', 'a']]
+        expect(attr.options(:except => [])).must_equal [['a text', 'a'], ['b text', 'b']]
+      end
+    end
+
+    it 'does not work with both :only and :except' do
+      store_translations(:en, :enumerize => {:foo => {:a => 'a text', :b => 'b text'}}) do
+        build_attr nil, :foo, :in => %w[a b]
+        expect(proc { attr.options(:except => [], :only => []) }).must_raise ArgumentError
+      end
+    end
+  end
+
+  describe 'values hash' do
+    before do
+      build_attr nil, :foo, :in => {:a => 1, :b => 2}
+    end
+
+    it 'returns hash keys as values' do
+      expect(attr.values).must_equal %w[a b]
+    end
+
+    it 'finds values by hash values' do
+      expect(attr.find_value(1)).must_equal 'a'
+      expect(attr.find_value(2)).must_equal 'b'
+    end
+  end
+
+  it 'sets up shortcut methods for each value' do
+    build_attr nil, :foo, :in => {:a => 1, :b => 2}
+
+    expect(attr).must_respond_to :a
+    expect(attr).must_respond_to :b
+
+    expect(attr.a.value).must_equal 1
+    expect(attr.b.value).must_equal 2
+    expect(attr.a.text).must_equal 'A'
+    expect(attr.b.text).must_equal 'B'
+  end
+
+  describe 'values hash with zero' do
+    before do
+      build_attr nil, :foo, :in => {:a => 1, :b => 2, :c => 0}
+    end
+
+    it 'returns hash keys as values' do
+      expect(attr.values).must_equal %w[a b c]
+    end
+
+    it 'finds values by hash values' do
+      expect(attr.find_value(1)).must_equal 'a'
+      expect(attr.find_value(2)).must_equal 'b'
+      expect(attr.find_value(0)).must_equal 'c'
+    end
+
+    it 'finds all values by hash values' do
+      expect(attr.find_values(1, 2, 0)).must_equal ['a', 'b', 'c']
+    end
+  end
+
+  describe 'boolean values hash' do
+    before do
+      build_attr nil, :foo, :in => {:a => true, :b => false}
+    end
+
+    it 'returns hash keys as values' do
+      expect(attr.values).must_equal %w[a b]
+    end
+
+    it 'finds values by hash values' do
+      expect(attr.find_value(true)).must_equal 'a'
+      expect(attr.find_value(false)).must_equal 'b'
+    end
+  end
+end

data/test/base_test.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+describe Enumerize::Base do
+  let(:kklass) do
+    Class.new do
+      extend Enumerize
+    end
+  end
+
+  let(:subklass) do
+    Class.new(kklass)
+  end
+
+  let(:object) { kklass.new }
+
+  it 'returns nil when not set' do
+    kklass.enumerize(:foo, :in => [:a, :b])
+    expect(object.foo).must_be_nil
+  end
+
+  it 'returns value that was set' do
+    kklass.enumerize(:foo, :in => [:a, :b])
+    object.foo = :a
+    expect(object.foo).must_equal 'a'
+  end
+
+  it 'returns translation' do
+    store_translations(:en, :enumerize => {:foo => {:a => 'a text'}}) do
+      kklass.enumerize(:foo, :in => [:a, :b])
+      object.foo = :a
+      expect(object.foo.text).must_equal 'a text'
+      expect(object.foo_text).must_equal 'a text'
+      expect(object.foo_text).must_equal 'a text'
+    end
+  end
+
+  it 'returns nil as translation when value is nil' do
+    store_translations(:en, :enumerize => {:foo => {:a => 'a text'}}) do
+      kklass.enumerize(:foo, :in => [:a, :b])
+      expect(object.foo_text).must_be_nil
+    end
+  end
+
+  it 'scopes translation by i18n key' do
+    def kklass.model_name
+      name = String.new("ExampleClass")
+      def name.i18n_key
+        'example_class'
+      end
+
+      name
+    end
+
+    store_translations(:en, :enumerize => {:example_class => {:foo => {:a => 'a text scoped'}}}) do
+      kklass.enumerize(:foo, :in => [:a, :b])
+      object.foo = :a
+      expect(object.foo.text).must_equal 'a text scoped'
+      expect(object.foo_text).must_equal 'a text scoped'
+    end
+  end
+
+  it 'returns humanized value if there are no translations' do
+    store_translations(:en, :enumerize => {}) do
+      kklass.enumerize(:foo, :in => [:a, :b])
+      object.foo = :a
+      expect(object.foo_text).must_equal 'A'
+    end
+  end
+
+  it 'stores value as string' do
+    kklass.enumerize(:foo, :in => [:a, :b])
+    object.foo = :a
+    expect(object.instance_variable_get(:@foo)).must_be_instance_of String
+  end
+
+  it 'handles default value' do
+    kklass.enumerize(:foo, :in => [:a, :b], :default => :b)
+    expect(object.foo).must_equal 'b'
+  end
+
+  it 'handles default value with lambda' do
+    kklass.enumerize(:foo, :in => [:a, :b], :default => lambda { :b })
+    expect(object.foo).must_equal 'b'
+  end
+
+  it 'injects object instance into lamda default value' do
+    kklass.enumerize(:foo, :in => [:a, :b], :default => lambda { |obj| :b if obj.is_a? kklass })
+    expect(object.foo).must_equal 'b'
+  end
+
+  it 'raises exception on invalid default value' do
+    expect(proc {
+      kklass.enumerize(:foo, :in => [:a, :b], :default => :c)
+    }).must_raise ArgumentError
+  end
+
+  it 'has enumerized attributes' do
+    expect(kklass.enumerized_attributes).must_be_empty
+    kklass.enumerize(:foo, :in => %w[a b])
+    expect(kklass.enumerized_attributes[:foo]).must_be_instance_of Enumerize::Attribute
+  end
+
+  it "doesn't override existing method" do
+    method = kklass.method(:name)
+    kklass.enumerize(:name, :in => %w[a b], :default => 'a')
+    expect(kklass.method(:name)).must_equal method
+  end
+
+  it "inherits enumerized attributes from a parent class" do
+    kklass.enumerize(:foo, :in => %w[a b])
+    expect(subklass.enumerized_attributes[:foo]).must_be_instance_of Enumerize::Attribute
+  end
+
+  it "inherits enumerized attributes from a grandparent class" do
+    kklass.enumerize(:foo, :in => %w[a b])
+    expect(Class.new(subklass).enumerized_attributes[:foo]).must_be_instance_of Enumerize::Attribute
+  end
+
+  it "doesn't add enumerized attributes to parent class" do
+    kklass.enumerize(:foo, :in => %w[a b])
+    subklass.enumerize(:bar, :in => %w[c d])
+
+    expect(kklass.enumerized_attributes[:bar]).must_be_nil
+  end
+
+  it 'adds new parent class attributes to subclass' do
+    subklass = Class.new(kklass)
+    kklass.enumerize :foo, :in => %w[a b]
+    expect(subklass.enumerized_attributes[:foo]).must_be_instance_of Enumerize::Attribute
+  end
+
+  it 'stores nil value' do
+    kklass.enumerize(:foo, :in => [:a, :b])
+    object.foo = nil
+    expect(object.instance_variable_get(:@foo)).must_be_nil
+  end
+
+  it 'casts value to string for validation' do
+    kklass.enumerize(:foo, :in => [:a, :b])
+    object.foo = :c
+    expect(object.read_attribute_for_validation(:foo)).must_equal 'c'
+  end
+
+  it "doesn't cast nil to string for validation" do
+    kklass.enumerize(:foo, :in => [:a, :b])
+    object.foo = nil
+    expect(object.read_attribute_for_validation(:foo)).must_be_nil
+  end
+
+  it 'calls super in the accessor method' do
+    accessors = Module.new do
+      def attributes
+        @attributes ||= {}
+      end
+
+      def foo
+        attributes[:foo]
+      end
+
+      def foo=(v)
+        attributes[:foo] = v
+      end
+    end
+
+    klass = Class.new do
+      include accessors
+      extend Enumerize
+
+      enumerize :foo, :in => %w[test]
+    end
+
+    object = klass.new
+    expect(object.foo).must_be_nil
+    expect(object.attributes).must_equal({})
+
+    object.foo = 'test'
+    expect(object.foo).must_equal 'test'
+    expect(object.attributes).must_equal(:foo => 'test')
+  end
+
+  it 'stores hash values' do
+    kklass.enumerize(:foo, :in => {:a => 1, :b => 2})
+
+    object.foo = :a
+    expect(object.instance_variable_get(:@foo)).must_equal 1
+    expect(object.foo).must_equal 'a'
+
+    object.foo = :b
+    expect(object.instance_variable_get(:@foo)).must_equal 2
+    expect(object.foo).must_equal 'b'
+  end
+
+  it 'returns custom value' do
+    kklass.enumerize(:foo, :in => {:a => 1, :b => 2})
+
+    object.foo = :a
+    expect(object.foo_value).must_equal 1
+
+    object.foo = :b
+    expect(object.foo_value).must_equal 2
+  end
+
+  it 'allows initialize method with arguments' do
+    klass = Class.new do
+      extend Enumerize
+
+      def initialize(argument, key_word_argument: nil); end
+    end
+
+    klass.new('arg1', key_word_argument: 'kwargs1')
+  end
+
+  it 'allows initialize method with arguments for inherited classes' do
+    parent_klass = Class.new do
+      def initialize(argument, key_word_argument: nil); end
+    end
+
+    klass = Class.new(parent_klass) do
+      extend Enumerize
+
+      def initialize(argument, key_word_argument: nil)
+        super
+      end
+    end
+
+    klass.new('arg1', key_word_argument: 'kwargs1')
+  end
+end

data/test/formtastic_test.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+Formtastic::FormBuilder.action_class_finder = Formtastic::ActionClassFinder
+Formtastic::FormBuilder.input_class_finder  = Formtastic::InputClassFinder
+
+class FormtasticSpec < MiniTest::Spec
+  include ViewTestHelper
+  include Formtastic::Helpers::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
+
+    extend Enumerize
+
+    enumerize :sex, :in => [:male, :female]
+
+    def persisted?
+      false
+    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
+
+  before { $VERBOSE = nil }
+  after  { $VERBOSE = true }
+
+  let(:user) { User.new }
+  let(:post) { Post.new }
+
+  it 'renders select with enumerized values' do
+    concat(semantic_form_for(user) do |f|
+      f.input :sex
+    end)
+
+    assert_select 'select option[value=male]'
+    assert_select 'select option[value=female]'
+  end
+
+  it 'renders multiple select with enumerized values' do
+    concat(semantic_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(semantic_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(semantic_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(semantic_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 enumerized values' do
+    concat(semantic_form_for(user) do |f|
+      f.input :sex, :as => :radio
+    end)
+
+    assert_select 'input[type=radio][value=male]'
+    assert_select 'input[type=radio][value=female]'
+  end
+
+  it 'does not affect not enumerized attributes' do
+    concat(semantic_form_for(user) do |f|
+      f.input(:age)
+    end)
+
+    assert_select 'input[type=text]'
+  end
+
+  it 'does not affect not enumerized classes' do
+    concat(semantic_form_for(Thing.new) do |f|
+      f.input(:name)
+    end)
+
+    assert_select 'input[type=text]'
+  end
+
+  it 'renders select with enumerized values for non-ActiveModel object' do
+    concat(semantic_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(semantic_form_for('') do |f|
+      f.input(:name)
+    end)
+
+    assert_select 'input[type=text]'
+  end
+end

data/test/module_attributes_test.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class ModuleAttributesSpec < MiniTest::Spec
+  it 'inherits attribute from the module' do
+    mod = Module.new do
+      extend Enumerize
+      enumerize :sex, :in => %w[male female], :default => 'male'
+    end
+
+    klass = Class.new
+    klass.send :include, mod
+    expect(klass.enumerized_attributes[:sex]).must_be_instance_of Enumerize::Attribute
+    expect(klass.new.sex).must_equal 'male'
+    expect(klass.sex).must_be_instance_of Enumerize::Attribute
+  end
+
+  it 'uses new attributes from the module' do
+    mod = Module.new do
+      extend Enumerize
+    end
+
+    klass = Class.new
+    klass.send :include, mod
+    mod.enumerize :sex, :in => %w[male female], :default => 'male'
+    expect(klass.enumerized_attributes[:sex]).must_be_instance_of Enumerize::Attribute
+    expect(klass.new.sex).must_equal 'male'
+    expect(klass.sex).must_be_instance_of Enumerize::Attribute
+  end
+
+  it 'validates attributes' do
+    mod = Module.new do
+      extend Enumerize
+      enumerize :sex, :in => %w[male female]
+    end
+
+    klass = Class.new do
+      include ActiveModel::Validations
+      include mod
+
+      def self.model_name
+        ActiveModel::Name.new(self, nil, 'name')
+      end
+    end
+
+    object = klass.new
+    object.sex = 'wrong'
+    expect(object).wont_be :valid?
+    expect(object.errors[:sex]).must_include 'is not included in the list'
+  end
+end