inum 3.0.0 → 4.0.0

data/lib/inum/version.rb

@@ -1,3 +1,3 @@
 module Inum
-  VERSION = "3.0.0"
+  VERSION = "4.0.0"
 end

data/spec/inum/active_record_mixin_spec.rb

@@ -2,7 +2,7 @@ require 'rspec'
 require 'spec_helper'
 
 describe Inum::ActiveRecordMixin do
-  create_temp_table(:tvs){|t| t.integer :anime; t.integer :favorite; t.integer :watching}
+  create_temp_table(:tvs){|t| t.integer :anime}
 
   before :each do
     class Anime < Inum::Base
@@ -12,13 +12,7 @@ describe Inum::ActiveRecordMixin do
       define :KMB,       4
     end
 
-    class TV < ActiveRecord::Base
-      bind_inum :column => :anime, :class => Anime
-
-      bind_inum :column => :favorite, :class => Anime, :prefix => :fav, :allow_nil => true
-
-      bind_inum :column => :watching, :class => Anime, :prefix => nil,  :validation => false
-    end
+    class TV < ActiveRecord::Base; end
   end
 
   after :each do
@@ -28,116 +22,87 @@ describe Inum::ActiveRecordMixin do
     end
   end
 
-  let :tv do
-    TV.create(anime: Anime::NYARUKO)
+  let :bind_class do
+    TV.tap {|klass| klass.instance_eval{ bind_inum :anime, Anime } }
   end
 
-  context 'Comparison methods' do
-    it 'Be defined' do
-      expect(TV.method_defined?(:anime_nyaruko?)).to   be_true
-      expect(TV.method_defined?(:anime_muromisan?)).to be_true
-      expect(TV.method_defined?(:anime_nourin?)).to    be_true
-      expect(TV.method_defined?(:anime_kmb?)).to       be_true
-    end
-
-    it 'Can compare' do
-      expect(tv.anime_nyaruko?).to be_true
-    end
+  let :instance do
+    bind_class.create!(anime: type)
   end
 
-  context 'getter' do
-    it 'Can set enum' do
-      tv.anime = Anime::NOURIN
-      expect(tv.anime_nourin?).to be_true
-    end
-
-    it 'Can set integer' do
-      tv.anime = 1
-      expect(tv.anime_muromisan?).to be_true
-    end
+  let :type do
+    Anime::NYARUKO
+  end
 
-    it 'Can set string' do
-      tv.anime = 'KMB'
-      expect(tv.anime_kmb?).to be_true
+  describe 'Comparison methods' do
+    it 'Will be defined.' do
+      expect(bind_class.method_defined?(:anime_nyaruko?)).to   be_truthy
+      expect(bind_class.method_defined?(:anime_muromisan?)).to be_truthy
+      expect(bind_class.method_defined?(:anime_nourin?)).to    be_truthy
+      expect(bind_class.method_defined?(:anime_kmb?)).to       be_truthy
     end
 
-    it 'Can set symbol' do
-      tv.anime = :KMB
-      expect(tv.anime_kmb?).to be_true
+    it 'Return correct value.' do
+      expect(instance.anime_nyaruko?).to be_truthy
     end
   end
 
-  it 'Prefix is enable, when prefix was set.' do
-      expect(TV.method_defined?(:fav_nyaruko?)).to   be_true
-      expect(TV.method_defined?(:fav_muromisan?)).to be_true
-      expect(TV.method_defined?(:fav_nourin?)).to    be_true
-      expect(TV.method_defined?(:fav_kmb?)).to       be_true
-  end
-
-  it 'Prefix is nothing, when prefix is nil.' do
-      expect(TV.method_defined?(:nyaruko?)).to   be_true
-      expect(TV.method_defined?(:muromisan?)).to be_true
-      expect(TV.method_defined?(:nourin?)).to    be_true
-      expect(TV.method_defined?(:kmb?)).to       be_true
-  end
+  describe '#setter' do
+    subject do
+      expect {
+        instance.anime = target
+      }.to change {
+        instance.send(:read_attribute, :anime)
+      }.from(type.to_i).to(Anime.parse(target).to_i)
+    end
 
-  it 'setter return enum' do
-    expect(tv.anime.instance_of?(Anime)).to be_true
-  end
+    context 'When enum' do
+      let(:target){ Anime::NOURIN }
 
-  context 'update methods can update enum column' do
-    it 'update' do
-      tv.update!(anime: Anime::NOURIN)
-      expect(tv.reload.anime).to eq(Anime::NOURIN)
+      it 'set value.' do
+        subject
+      end
     end
 
-    it 'update_attribute' do
-      tv.update_attribute(:anime, Anime::NOURIN)
-      expect(tv.reload.anime).to eq(Anime::NOURIN)
-    end
-  end
+    context 'When integer' do
+      let(:target){ 1 }
 
-  context 'validation' do
-    let :validators do
-      TV.validators.map{|v| v.attributes[0]}
+      it 'set value.' do
+        subject
+      end
     end
 
-    it 'Enable validator' do
-      expect(validators).to include(:anime)
-      expect(validators).to include(:favorite)
-    end
+    context 'When string' do
+      let(:target){ 'KMB' }
 
-    it 'Disable validator when column has option of validation false.' do
-      expect(validators).not_to include(:watching)
+      it 'set value.' do
+        subject
+      end
     end
 
-    context 'valid' do
-      it 'default is validation passed.' do
-        expect(tv).to be_valid
-      end
+    context 'When string' do
+      let(:target){ :KMB }
 
-      it 'Correct values are validation passed.' do
-        Anime.each do |enum|
-          tv.anime = enum
-          expect(tv).to be_valid
-        end
+      it 'set value.' do
+        subject
       end
+    end
+  end
 
-      it 'Incorrect values are validation failed.' do
-        [-1000, 9999, 'Nothing!!', :Nothing].each do |value|
-          tv.anime = value
-          expect(tv).not_to be_valid
-        end
-      end
+  describe '#getter' do
+    it 'Return enum' do
+      expect(instance.anime.instance_of?(Anime)).to be_truthy
+    end
+  end
 
-      it 'Can not set nil' do
-        tv.anime = nil
-        expect(tv).not_to be_valid
-      end
+  context 'When with prefix option' do
+    let :bind_class do
+      TV.tap {|klass| klass.instance_eval{ bind_inum :anime, Anime, prefix: 'prefix' } }
+    end
 
-      it 'Can set nil when column has option of allow_nil true.' do
-        tv.favorite = nil
-        expect(tv).to be_valid
+    describe 'Comparison methods' do
+      it 'Will be defined with prefix.' do
+        expect(bind_class.method_defined?(:prefix_nyaruko?)).to   be_truthy
       end
     end
   end

data/spec/inum/base_spec.rb

@@ -2,214 +2,317 @@ require 'rspec'
 require 'spec_helper'
 
 describe Inum::Base do
-
-  context 'When define enum,' do
-    it 'Correct definition be validation passed.' do
-      expect{
-        Class.new(Inum::Base) { define :REDBULL,  0 }
+  describe '.define' do
+    context 'When define a correct enum' do
+      subject do
         Class.new(Inum::Base) {
-          define :REDBULL, 0
-          define :MONSTER, 1
+          define :RED_BULL, 0
+          define :MONSTER,  1
+          define :MONSTER2, 2
         }
-      }.not_to raise_error
-    end
-
-    it 'Incorrect definition be validation failed.' do
-      # wrong name.
-      expect{
-        Class.new(Inum::Base) { define 1111, 0 }
-      }.to raise_error
+      end
 
-      # wrong value.
-      expect{
-        Class.new(Inum::Base) { define :REDBULL, :no_int }
-      }.to raise_error
+      it 'pass validation.' do
+        expect { subject }.not_to raise_error
+      end
+    end
 
-      # dup name.
-      expect{
+    context 'When define a omit a value enum' do
+      subject do
         Class.new(Inum::Base) {
-          define :REDBULL, 0
-          define :REDBULL, 1
+          define :RED_BULL
+          define :MONSTER
+          define :MONSTER2
         }
-      }.to raise_error
+      end
 
-      # dup value.
-      expect{
-        Class.new(Inum::Base) {
-          define :REDBULL, 0
-          define :MONSTER, 0
-        }
-      }.to raise_error
+      it 'pass validation.' do
+        expect { subject }.not_to raise_error
+      end
+
+      it 'auto incremented value.' do
+        expect(subject::RED_BULL.to_i).to eq(0)
+        expect(subject::MONSTER.to_i).to  eq(1)
+        expect(subject::MONSTER2.to_i).to eq(2)
+      end
     end
 
-    it 'Autoincrement value when without default value.' do
-      enum = Class.new(Inum::Base) do
-        define :REDBULL
-        define :MONSTER
-        define :BURN
+    context 'When define a enum having wrong label' do
+      subject do
+        Class.new(Inum::Base) {
+          define :red_bull, 0
+        }
       end
 
-      expect(enum::REDBULL.value).to eq(0)
-      expect(enum::MONSTER.value).to eq(1)
-      expect(enum::BURN.value).to    eq(2)
+      it 'fail validation.' do
+        expect { subject }.to raise_error
+      end
     end
 
-    it 'Instances of enum are different each definition.' do
-      first  = Class.new(Inum::Base){ define :REDBULL }
-      second = Class.new(Inum::Base){ define :MONSTER }
-
-      first_enum_format  = first.instance_variable_get(:@enum_format)
-      second_enum_format = second.instance_variable_get(:@enum_format)
+    context 'When define a enum having duplicate label' do
+      subject do
+        Class.new(Inum::Base) {
+          define :RED_BULL, 0
+          define :RED_BULL, 1
+        }
+      end
 
-      first_enums  = first.instance_variable_get(:@enums)
-      second_enums = second.instance_variable_get(:@enums)
+      it 'fail validation.' do
+        expect { subject }.to raise_error
+      end
+    end
 
-      expect(first_enum_format.eql?(second_enum_format)).to  be_false
-      expect(first_enum_format.equal?(second_enum_format)).to be_false
+    context 'When define a enum having duplicate value' do
+      subject do
+        Class.new(Inum::Base) {
+          define :RED_BULL, 0
+          define :MONSTER,  0
+        }
+      end
 
-      expect(first_enums.eql?(second_enums)).to  be_false
-      expect(first_enums.equal?(second_enums)).to be_false
+      it 'fail validation.' do
+        expect { subject }.to raise_error
+      end
     end
   end
 
-
-  describe 'Defined Inum::Base' do
-    before :each do
+  describe 'Defined enum class' do
+    before :all do
       class Anime < Inum::Base
         define :NYARUKO,   0
         define :MUROMISAN, 1
         define :NOURIN,    2
-        define :KMB,       4
+        define :KMB,       3
       end
     end
 
-    after :each do
+    after :all do
       Object.class_eval{ remove_const :Anime }
     end
 
-    it 'Can not create instance.(Singleton)' do
-      expect{ Anime.new(:NICONICO, 2525) }.to raise_error
-    end
-
-    it 'The instance of enum is equal.' do
-      expect(Anime::NYARUKO.equal?(Anime.parse!('NYARUKO'))).to be_true
-    end
+    describe '#<=>' do
+      context 'self == other' do
+        it 'Return 0.' do
+          expect(Anime::MUROMISAN <=> 1).to eq(0)
+        end
+      end
 
-    it '<=> method return a correct value.' do
-      expect((Anime::MUROMISAN <=> 0)  > 0 ).to be_true
-      expect((Anime::MUROMISAN <=> 1) == 0 ).to be_true
-      expect((Anime::MUROMISAN <=> 2)  < 0 ).to be_true
+      context 'self < other' do
+        it 'Return a negative values.' do
+          expect(Anime::MUROMISAN <=> 2).to be < 0
+        end
+      end
 
-      expect(Anime::NYARUKO <=> 'Value can not compare.').to be_nil
+      context 'self > other' do
+        it 'Return a positive values.' do
+          expect(Anime::MUROMISAN <=> 0).to be > 0
+        end
+      end
     end
 
-    it '+ method return a correct Inum.' do
-      expect(Anime::NYARUKO + 1).to eq(Anime::MUROMISAN)
+    describe '#+' do
+      it 'Returning value is correct.' do
+        expect(Anime::NYARUKO + 1).to eq(Anime::MUROMISAN)
+      end
     end
 
-    it '- method return a correct Inum.' do
-      expect(Anime::NOURIN - 1).to eq(Anime::MUROMISAN)
+    describe '#-' do
+      it 'Returning value is correct.' do
+        expect(Anime::MUROMISAN - 1).to eq(Anime::NYARUKO)
+      end
     end
 
-    it 'Comparable module enable.' do
-      expect(Anime::MUROMISAN.between?(0,2)).to be_true
-    end
+    describe '#eql?' do
+      context 'When compare same enum' do
+        it 'Return truthy value.' do
+          expect(Anime::KMB.eql?(Anime::KMB)).to be_truthy
+        end
+      end
 
-    it 'each method can execute block with enum' do
-      count = 0
-      expect{
-        Anime.each do |enum|
-          expect(enum.instance_of?(Anime)).to be_true
-          count += 1
+      context 'When compare other enum' do
+        it 'Return falsey value.' do
+          expect(Anime::KMB.eql?(Anime::NYARUKO)).to be_falsey
         end
-      }.to change{count}.by(Anime.length)
+      end
     end
 
-    it 'Enumerable module enable.' do
-      expect(Anime.count).to eq(Anime.length)
-      expect(Anime.include?(Anime::NOURIN)).to be_true
+    describe '#t' do
+      subject do
+        expect(I18n).to receive(:t).with('animes.kmb') { 'ok' }
+        expect(Anime::KMB.t).to eq('ok')
+      end
     end
 
-    it 'eql? method return a correct result.' do
-      expect(Anime::KMB.eql?(0) ).to be_false
-      expect(Anime::KMB.eql?(4) ).to be_true
+    describe '#to_i' do
+      it 'Return integer.' do
+        expect(Anime::KMB.to_i).to eq(3)
+      end
     end
 
-    it 'labels method return Array<Symbol>.' do
-      expect(Anime.labels.length).to eq(Anime.length)
-      expect(Anime.labels.instance_of?(Array)).to     be_true
-      expect(Anime.labels[0].instance_of?(Symbol)).to be_true
+    describe '#to_s ' do
+      it 'Return string.' do
+        expect(Anime::NOURIN.to_s).to eq('NOURIN')
+      end
     end
 
-    it 'length return count of enum.' do
-      expect(Anime.length).to eq(4)
+    describe '#translate' do
+      subject do
+        expect(I18n).to receive(:t).with('animes.kmb') { 'ok' }
+        expect(Anime::KMB.translate).to eq('ok')
+      end
     end
 
-    context 'Parse method' do
-      it 'Parsable string.' do
-        expect(Anime.parse('NOURIN')).to eq(Anime::NOURIN)
+    describe '#value' do
+      it 'Return integer.' do
+        expect(Anime::KMB.value).to eq(3)
       end
+    end
 
-      it 'Parsable integer.' do
-        expect(Anime.parse(1)).to eq(Anime::MUROMISAN)
+    describe '.collection' do
+      subject do
+        allow(I18n).to receive(:t) { 't' }
+        Anime.collection(option)
       end
 
-      it 'Parsable symbol.' do
-        expect(Anime.parse(:KMB)).to eq(Anime::KMB)
+      let(:option) { Hash.new }
+
+      it 'Return all item array.' do
+        expect(subject).to match_array([
+          ['t', 0],
+          ['t', 1],
+          ['t', 2],
+          ['t', 3],
+        ])
       end
 
-      it 'Parsable self instance.' do
-        expect(Anime.parse(Anime::NYARUKO)).to eq(Anime::NYARUKO)
+      context 'When with only option' do
+        let(:option) { {only: [:KMB]} }
+
+        it 'Return only selected item array.' do
+          expect(subject).to match_array([['t', 3]])
+        end
       end
 
-      it 'return nil for a unknown value.' do
-        expect(Anime.parse('Nothing') ).to eq(nil)
+      context 'When with except option' do
+        let(:option) { {except: [:KMB]} }
+
+        it 'Return only except item array.' do
+          expect(subject).to match_array([
+            ['t', 0],
+            ['t', 1],
+            ['t', 2],
+          ])
+        end
       end
+    end
 
-      it 'parse! method raise exception for a unknown value.' do
-        expect{Anime.parse!('Nothing') }.to raise_error(NameError)
+    describe '.new' do
+      it 'Can not create a instance of enum.' do
+        expect{ Anime.new(:NICONICO, 2525) }.to raise_error
       end
     end
 
-    it 'to_a method return Array<Enum>.' do
-      enums = Anime.instance_variable_get(:@enums)
+    describe '.each' do
+      it 'Execute block with a right order.' do
+        count  = 0
+        orders = [Anime::NYARUKO, Anime::MUROMISAN, Anime::NOURIN, Anime::KMB]
 
-      expect(Anime.to_a.eql?(enums)).to   be_true
-      expect(Anime.to_a.equal?(enums)).to be_false
+        Anime.each do |enum|
+          expect(enum).to eq(orders[count])
+          count += 1
+        end
+      end
     end
 
-    it 'to_h method return Hash' do
-      enum_format = Anime.instance_variable_get(:@enum_format)
-
-      expect(Anime.to_h.eql?(enum_format)).to   be_true
-      expect(Anime.to_h.equal?(enum_format)).to be_false
+    describe '.labels' do
+      it 'Return array of label.' do
+        expect(Anime.labels).to match_array([:NYARUKO, :MUROMISAN, :NOURIN, :KMB])
+      end
     end
 
-    it 'to_i and value methods return integer.' do
-      expect(Anime::KMB.to_i).to  eq(4)
-      expect(Anime::KMB.value).to eq(4)
+    describe '.length' do
+      it 'Return correct count of enum.' do
+        expect(Anime.length).to eq(4)
+      end
     end
 
-    it 'to_s method return string.' do
-      expect(Anime::NOURIN.to_s ).to eq('NOURIN')
+    describe '.parse' do
+      subject do
+        expect(Anime.parse(source)).to eq(destination)
+      end
+
+      let(:destination) { Anime::KMB }
+
+      context 'source is string' do
+        let(:source) { 'KMB' }
+        it 'success.' do
+          subject
+        end
+      end
+
+      context 'source is symbol' do
+        let(:source) { :kmb }
+        it 'success.' do
+          subject
+        end
+      end
+
+      context 'source is integer' do
+        let(:source) { 3 }
+        it 'success.' do
+          subject
+        end
+      end
+
+      context 'source is enum' do
+        let(:source) { Anime::KMB }
+        it 'success.' do
+          subject
+        end
+      end
+
+      context 'source is incorrect' do
+        let(:source) { '' }
+        let(:destination) { nil }
+        it 'return nil.' do
+          subject
+        end
+      end
     end
 
-    it 'translate and t methods return localized string.' do
-      I18n.should_receive(:t).with('inum.anime.nourin').and_return('NO-RIN!')
-      I18n.should_receive(:t).with('inum.anime.kmb').and_return('KIRUMI-BEIBE-')
+    describe '.parse!' do
+      subject do
+        expect(Anime).to receive(:parse).with(:hoge) { returning_value }
+        expect(Anime.parse!(:hoge)).to eq(returning_value)
+      end
+
+      context '#parse return enum' do
+        let(:returning_value) { Anime::KMB }
+
+        it 'success.' do
+          subject
+        end
+      end
 
-      expect(Anime::NOURIN.t).to      eq('NO-RIN!')
-      expect(Anime::KMB.translate).to eq('KIRUMI-BEIBE-')
+      context '#parse return nil' do
+        let(:returning_value) { nil }
+
+        it 'raise error.' do
+          expect{subject}.to raise_error
+        end
+      end
     end
 
-    it 'underscore method return underscore string.' do
-      expect(Anime::NYARUKO.underscore).to eq('nyaruko')
+    describe '.to_a' do
+      it 'Return array of enum.' do
+        expect(Anime.to_a).to match_array([Anime::NYARUKO, Anime::MUROMISAN, Anime::NOURIN, Anime::KMB])
+      end
     end
 
-    it 'values method return Array<integer>.' do
-      expect(Anime.values.length).to eq(Anime.length)
-      expect(Anime.values.instance_of?(Array)).to be_true
-      expect(Anime.values[0].integer?).to         be_true
+    describe '.values' do
+      it 'Return array of value.' do
+        expect(Anime.values).to match_array([0, 1, 2, 3])
+      end
     end
   end
 end