inum 2.1.2 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c5055c9ab3014b32c6e8aec6eaaa6bfdc7b78ba3
-  data.tar.gz: 7fed7e2c4a17826aa469410d02e38fad5b39b616
+  metadata.gz: 99359111fe269cc5e91a4b3cfcca01412405ce0e
+  data.tar.gz: d41f12ce30debb7bb1e566bc64658d3ba3c7da73
 SHA512:
-  metadata.gz: e08410058e6c7aff4ffd11ced7dca2d3132f7e7e77885cc9301cc1d673b9674e441970d2471881ac3958b6c22fd1833c3632834e0febbd81aeb1560f111bcd8a
-  data.tar.gz: 0de1515b63dd86c93099f37f29b51d77f8cfb7d066d27d17e80c16395ab4dd2b0dccf286801b626b35bf0865863e9ba31946c5ccaac8a3d44c9834a201454cbb
+  metadata.gz: afc248454f732406d18b7a38a36a03e1b0106eae10bf9aa81c9727916420b58551aa784a4201516b0baf74cd148c791747f0039884c38a66ae33936dbfe2aac3
+  data.tar.gz: e626427aa8db41a1d7ecca7f95844a5f40aefe5374918195a07d2725701eca0e84ca860388b3e08af4314e1946842c482ad2de6f9ab67bb30dbdf215ed9c1d10

data/.gitignore

@@ -16,4 +16,7 @@ test/tmp
 test/version_tmp
 tmp
 vendor/
-nbproject/
+
+# IDE Projects files.
+nbproject/
+.project

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+script: bundle exec rspec
+before_install:
+  - gem install bundler
+rvm:
+  - 1.9.3
+  - 2.1.0
+env:
+  - RAILS=3.2.16
+  - RAILS=4.0.2
+  - RAILS=4.1.0.beta1

data/README.md

@@ -25,37 +25,35 @@ For example create enum(inum) of Japanese Anime.
 
 ``` ruby
 class AnimeType < Inum::Base
-  define_enum :EVANGELION, 0
-  define_enum :HARUHI,     1
-  define_enum :NYARUKO,    2
+  define :EVANGELION, 0
+  define :HARUHI,     1
+  define :NYARUKO,    2
 end
 ```
 
 If value(integer) is omitted, value(integer) is auto-incremented.
 
 ``` ruby
-define_enum :EVANGELION  # => value will auto-increment.
+define :EVANGELION  # => value will auto-increment.
 ```
 
 ### Use Enum(Inum)
 How to use Enum(Inum).
 
 ``` ruby
-p AnimeType::EVANGELION            # => EVANGELION
-p AnimeType::EVANGELION.to_i       # => 0
+p AnimeType::EVANGELION.label      # => :EVANGELION (if use to_s, return "EVANGELION")
+p AnimeType::EVANGELION.value      # => 0 (can use to_i.)
 p AnimeType::EVANGELION.translate  # => エヴァンゲリオン (i18n find `inum.anime_type.evangelion`.)
 
 # parse object to instance of AnimeType.
 # object can use class of Symbol or String or Integer or Self.
-type = AnimeType::parse(0)
-p type.equal?(AnimeType::EVANGELION) # => true (member of Enum is singleton.)
-
+type = AnimeType.parse(0)
 p AnimeType::HARUHI.eql?('HARUHI')   # => true (eql? can compare all parsable object.)
 
 p AnimeType::HARUHI + 1   # => NYARUKO
 p AnimeType::NYARUKO - 1  # => HARUHI
 
-# can use each method.
+# each method.
 AnimeType::each {|enum| p enum }
 
 ```
@@ -64,33 +62,33 @@ can use Enumerable and Comparable.
 
 - more detail is [Class::Base](http://rubydoc.info/github/alfa-jpn/inum/Inum/Base)
 
-### Use define\_check\_method
-define\_check\_method can extend your class.
+### if use ActiveRecord, can use bind\_inum
 
 ``` ruby
-class Anime
-  extend Inum::DefineCheckMethod
-  
-  attr_accessor :type
+class Anime < ActiveRecord::Base
+  bind_inum :column => :type, :class => AnimeType
+end
 
-  define_check_method :type, AnimeType
+# if set prefix.
+class Anime < ActiveRecord::Base
+  bind_inum :column => :type, :class => AnimeType, :prefix => nil # remove prefix, when prefix is nil.
 end
 
 ```
 
-define\_check\_method generates methods for type confirmation. 
+bind\_enum generates useful methods and validation.
 
 ``` ruby
-anime = Anime.new
-anime.type = AnimeType::NYARUKO
+anime = Anime.new(type: AnimeType::NYARUKO)
+p anime.type.t # => '這いよれ！ニャル子さん' t is aliased translate.
 
-p anime.evangelion? # => false
-p anime.nyaruko?    # => true
+p anime.type_evangelion? # => false
+p anime.type_nyaruko?    # => true
 
 
 # type can use all parsable object.
 anime.type = 1
-p anime.haruhi? # => true
+p anime.type_haruhi? # => true
 
 ```
 

data/inum.gemspec

@@ -22,6 +22,8 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
   spec.add_development_dependency "yard"
+  spec.add_development_dependency "activerecord"
+  spec.add_development_dependency "sqlite3"
 
   spec.add_dependency "i18n", "~> 0.6.5"
 end

data/lib/inum.rb

@@ -1,3 +1,11 @@
-require "inum/version"
-require "inum/base"
-require "inum/define_check_method"
+require 'i18n'
+
+require 'inum/version'
+require 'inum/base'
+require 'inum/active_record_mixin.rb'
+
+module Inum
+  if Object.const_defined?(:ActiveRecord)
+    ActiveRecord::Base.send :extend, Inum::ActiveRecordMixin
+  end
+end

data/lib/inum/active_record_mixin.rb

@@ -0,0 +1,55 @@
+module Inum
+  # Mixin module to ActiveRecord.
+  #
+  # @example
+  #   class Fruit < ActiveRecord::Base
+  #     bind_enum :type, FruitType
+  #   end
+  #
+  module ActiveRecordMixin
+    # Define compare method in class.
+    #
+    # @param options [Hash] option
+    # @option options [Symbol]    :column     Binding column.          (require)
+    # @option options [Inum:Base] :class      Binding enum.            (require)
+    # @option options [Symbol]    :prefix     Prefix.                  (default: "{option[:column]}_")
+    # @option options [Bool]      :validation Enable validation        (default: true)
+    # @option options [Bool]      :allow_nil  Allow nil when validate. (default: false)
+    def bind_inum(options)
+      opts = {
+        allow_nil:  false,
+        prefix:     options[:column],
+        validation: true,
+      }.merge(options)
+      opts[:prefix] = (opts[:prefix].nil?)? '' : "#{opts[:prefix]}_"
+
+      self.class_eval do
+        if opts[:validation]
+          validates opts[:column], {
+            allow_nil: opts[:allow_nil],
+            inclusion: {in: opts[:class].to_a},
+          }
+        end
+
+        define_method("#{opts[:column]}") do
+          opts[:class].parse(read_attribute(opts[:column]))
+        end
+
+        define_method("#{opts[:column]}=") do |value|
+          enum  = opts[:class].parse(value)
+          if enum
+            write_attribute(opts[:column], enum.to_i)
+          else
+            write_attribute(opts[:column], nil)
+          end
+        end
+
+        opts[:class].each do |enum|
+          define_method("#{opts[:prefix]}#{enum.underscore}?") do
+            enum.eql?(send(opts[:column]))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/inum/base.rb

@@ -7,16 +7,14 @@ module Inum
   # @abstract Inum class should be a inheritance of Inum::Base.
   # @example
   #   class FruitType < Inum::Base
-  #     define_enum :APPLE,  0
-  #     define_enum :BANANA, 1
-  #     define_enum :ORANGE, 2
+  #     define :APPLE,  0
+  #     define :BANANA, 1
+  #     define :ORANGE, 2
   #   end
   class Base
     extend Enumerable
     include Comparable
 
-    private_class_method :new
-
     # initialize Inum::Base with value.
     # @note The instance of Enum Member is singleton.
     #
@@ -66,16 +64,16 @@ module Inum
       self.equal?(self.class.parse(object))
     end
 
-    # Enum to Integer.
+    # Label of Enum.
     #
-    # @return [Integer] integer value of Enum.
-    def to_i
-      @value
+    # @return [Symbol] Label of Enum.
+    def label
+      @label
     end
 
     # Enum to String.
     #
-    # @return [String] string value(label) of Enum.
+    # @return [String] Label(String).
     def to_s
       @label.to_s
     end
@@ -87,7 +85,7 @@ module Inum
     def translate
       I18n.t(self.class.i18n_key(@label))
     end
-    alias_method :to_t, :translate
+    alias_method :t, :translate
 
     # Enum label to underscore string.
     #
@@ -95,41 +93,48 @@ module Inum
     def underscore
       @underscore_label
     end
-    alias_method :to_u, :underscore
+
+    # Value of Enum.
+    #
+    # @return [Integer] Value of Enum.
+    def value
+      @value
+    end
+    alias_method :to_i, :value
 
     # Execute the yield(block) with each member of enum.
     #
-    # @yield [enum] instance of enum.
-    def self.each
-      defined_enums.each_key {|key| yield parse(key.to_s)}
+    # @param &block [proc{|enum| .. }] execute the block.
+    def self.each(&block)
+      enums.each(&block)
     end
 
     # get all labels of Enum.
     #
     # @return [Array<Symbol>] all labels of Enum.
     def self.labels
-      defined_enums.keys
+      enum_format.keys
     end
 
     # get Enum length.
     #
     # @return [Integer] count of Enums.
     def self.length
-      defined_enums.length
+      enum_format.length
     end
 
     # return array of Enums.
     #
-    # @return [Array<Array<Symbol, Integer>>] sorted array of Enums.
+    # @return [Array<Inum>] sorted array of Enums.
     def self.to_a
-      defined_enums.flatten(0).sort{|a,b| a[1] <=> b[1] }
+      enums.dup
     end
 
     # return hash of Enums.
     #
     # @return [Hash<Symbol, Integer>] hash of Enums.
     def self.to_h
-      defined_enums.dup
+      enum_format.dup
     end
 
     # Parse Object to Enum.(unsafe:An exception may occur.)
@@ -143,7 +148,7 @@ module Inum
         when Symbol
           parse object.to_s
         when Integer
-          parse self.defined_enums.key(object).to_s
+          parse self.enum_format.key(object).to_s
         when self
           object
         else
@@ -175,28 +180,39 @@ module Inum
     #
     # @return [Array<Integer>] all values of Enum.
     def self.values
-      defined_enums.values
+      enum_format.values
     end
 
-    private
+
     # Define Enum in called class.
     #
     # @param label [Symbol]  label of Enum.
     # @param value [Integer] value of Enum.(default:autoincrement for 0.)
-    def self.define_enum(label, value = defined_enums.size)
+    def self.define(label, value = enum_format.size)
       value = value.to_i
-
       validate_enum_args!(label, value)
 
-      defined_enums[label] = value
-      self.const_set(label, new(label, value))
+      enum = new(label, value)
+      enum_format[label] = value
+
+      enums.push(enum)
+      self.const_set(label, enum)
     end
 
-    # get hash of @defined_enums.
+    # get hash of @enum_format.
+    # @private
     #
-    # @return [Hash] hash of defined enums.
-    def self.defined_enums
-      @defined_enums
+    # @return [Hash] format(hash) of enum.
+    def self.enum_format
+      @enum_format
+    end
+
+    # get array of @enums.
+    # @private
+    #
+    # @return [Array] array of defined enums.
+    def self.enums
+      @enums
     end
 
     # get key for I18n.t method.
@@ -210,9 +226,11 @@ module Inum
     end
 
     # call after inherited.
-    # @note Define hash of :DEFINED_ENUMS in child.
+    #
+    # @note Define hash of :enum_format in child.
     def self.inherited(child)
-      child.instance_variable_set(:@defined_enums, Hash.new)
+      child.instance_variable_set(:@enum_format, Hash.new)
+      child.instance_variable_set(:@enums, Array.new)
     end
 
     # Validate enum args, and raise exception.
@@ -224,13 +242,15 @@ module Inum
         raise ArgumentError, "The label(#{label}!) isn't instance of Symbol."
       end
 
-      if defined_enums.has_key?(label)
+      if labels.include?(label)
         raise ArgumentError, "The label(#{label}!) already exists!!"
       end
 
-      if defined_enums.has_value?(value)
+      if values.include?(value)
         raise ArgumentError, "The value(#{value}!) already exists!!"
       end
     end
+
+    private_class_method :new, :define, :validate_enum_args!
   end
 end

data/lib/inum/version.rb

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

data/spec/inum/active_record_mixin_spec.rb

@@ -0,0 +1,144 @@
+require 'rspec'
+require 'spec_helper'
+
+describe Inum::ActiveRecordMixin do
+  create_temp_table(:tvs){|t| t.integer :anime; t.integer :favorite; t.integer :watching}
+
+  before :each do
+    class Anime < Inum::Base
+      define :NYARUKO,   0
+      define :MUROMISAN, 1
+      define :NOURIN,    2
+      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
+  end
+
+  after :each do
+    Object.class_eval do
+      remove_const :TV
+      remove_const :Anime
+    end
+  end
+
+  let :tv do
+    TV.create(anime: Anime::NYARUKO)
+  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
+  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
+
+    it 'Can set string' do
+      tv.anime = 'KMB'
+      expect(tv.anime_kmb?).to be_true
+    end
+
+    it 'Can set symbol' do
+      tv.anime = :KMB
+      expect(tv.anime_kmb?).to be_true
+    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
+
+  it 'setter return enum' do
+    expect(tv.anime.instance_of?(Anime)).to be_true
+  end
+
+  context 'update methods can update enum column' do
+    it 'update' do
+      tv.update!(anime: Anime::NOURIN)
+      expect(tv.reload.anime).to eq(Anime::NOURIN)
+    end
+
+    it 'update_attribute' do
+      tv.update_attribute(:anime, Anime::NOURIN)
+      expect(tv.reload.anime).to eq(Anime::NOURIN)
+    end
+  end
+
+  context 'validation' do
+    let :validators do
+      TV.validators.map{|v| v.attributes[0]}
+    end
+
+    it 'Enable validator' do
+      expect(validators).to include(:anime)
+      expect(validators).to include(:favorite)
+    end
+
+    it 'Disable validator when column has option of validation false.' do
+      expect(validators).not_to include(:watching)
+    end
+
+    context 'valid' do
+      it 'default is validation passed.' do
+        expect(tv).to be_valid
+      end
+
+      it 'Correct values are validation passed.' do
+        Anime.each do |enum|
+          tv.anime = enum
+          expect(tv).to be_valid
+        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
+
+      it 'Can not set nil' do
+        tv.anime = nil
+        expect(tv).not_to be_valid
+      end
+
+      it 'Can set nil when column has option of allow_nil true.' do
+        tv.favorite = nil
+        expect(tv).to be_valid
+      end
+    end
+  end
+end

data/spec/inum/base_spec.rb

@@ -3,204 +3,213 @@ require 'spec_helper'
 
 describe Inum::Base do
 
-  it 'define_enum validate correct' do
-    # correct.
-    expect{
-      Class.new(Inum::Base) { define_enum :REDBULL,  0 }
-      Class.new(Inum::Base) { define_enum :REDBULL,  0.to_i }
-      Class.new(Inum::Base) {
-        define_enum :REDBULL, 0
-        define_enum :MONSTER, 1
-      }
-    }.not_to raise_error
-
-    # wrong name.
-    expect{
-      Class.new(Inum::Base) { define_enum 1111, 0 }
-    }.to raise_error
-
-    # wrong value.
-    expect{
-      Class.new(Inum::Base) { define_enum :REDBULL, :no_int }
-    }.to raise_error
-
-    # dup name.
-    expect{
-      Class.new(Inum::Base) {
-        define_enum :REDBULL, 0
-        define_enum :REDBULL, 1
-      }
-    }.to raise_error
-
-    # dup value.
-    expect{
-      Class.new(Inum::Base) {
-        define_enum :REDBULL,  0
-        define_enum :REDBULL2, 0
-      }
-    }.to raise_error
-  end
-
-  it 'define_enum called without value, value is autoincrement.' do
-    enum = Class.new(Inum::Base) do
-      define_enum :REDBULL
-      define_enum :MONSTER
-      define_enum :BURN
+  context 'When define enum,' do
+    it 'Correct definition be validation passed.' do
+      expect{
+        Class.new(Inum::Base) { define :REDBULL,  0 }
+        Class.new(Inum::Base) {
+          define :REDBULL, 0
+          define :MONSTER, 1
+        }
+      }.not_to raise_error
     end
 
-    expect(enum::REDBULL.to_i).to eq(0)
-    expect(enum::MONSTER.to_i).to eq(1)
-    expect(enum::BURN.to_i).to    eq(2)
-  end
+    it 'Incorrect definition be validation failed.' do
+      # wrong name.
+      expect{
+        Class.new(Inum::Base) { define 1111, 0 }
+      }.to raise_error
+
+      # wrong value.
+      expect{
+        Class.new(Inum::Base) { define :REDBULL, :no_int }
+      }.to raise_error
+
+      # dup name.
+      expect{
+        Class.new(Inum::Base) {
+          define :REDBULL, 0
+          define :REDBULL, 1
+        }
+      }.to raise_error
 
-  context 'define class of extended Inum::Base,' do
-    before(:each) do
-      I18n.stub(:t).and_return('Good drink!')
-      @enum = Class.new(Inum::Base) do
-        define_enum :REDBULL,  0
-        define_enum :MONSTER,  1
-        define_enum :BURN,     2
+      # dup value.
+      expect{
+        Class.new(Inum::Base) {
+          define :REDBULL, 0
+          define :MONSTER, 0
+        }
+      }.to raise_error
+    end
+
+    it 'Autoincrement value when without default value.' do
+      enum = Class.new(Inum::Base) do
+        define :REDBULL
+        define :MONSTER
+        define :BURN
       end
-    end
 
-    it 'can not call new.' do
-      expect{ @enum.new(1) }.to raise_error
+      expect(enum::REDBULL.value).to eq(0)
+      expect(enum::MONSTER.value).to eq(1)
+      expect(enum::BURN.value).to    eq(2)
     end
 
-    it 'DEFINED_ENUM is different instance.' do
-      @enum2 = Class.new(Inum::Base) do
-        define_enum :REDBULL,  0
-      end
+    it 'Instances of enum are different each definition.' do
+      first  = Class.new(Inum::Base){ define :REDBULL }
+      second = Class.new(Inum::Base){ define :MONSTER }
 
-      defined_enum_inst  = @enum.instance_variable_get(:@defined_enums)
-      defined_enum_inst2 = @enum2.instance_variable_get(:@defined_enums)
+      first_enum_format  = first.instance_variable_get(:@enum_format)
+      second_enum_format = second.instance_variable_get(:@enum_format)
 
-      expect( defined_enum_inst.eql?(defined_enum_inst2) ).to be_false
-      expect( defined_enum_inst.equal?(defined_enum_inst2) ).to be_false
-    end
+      first_enums  = first.instance_variable_get(:@enums)
+      second_enums = second.instance_variable_get(:@enums)
+
+      expect(first_enum_format.eql?(second_enum_format)).to  be_false
+      expect(first_enum_format.equal?(second_enum_format)).to be_false
 
-    it 'A enum instance is equal instance.' do
-      expect( @enum::BURN.equal?(@enum::BURN )).to be_true
+      expect(first_enums.eql?(second_enums)).to  be_false
+      expect(first_enums.equal?(second_enums)).to be_false
     end
+  end
 
-    it '<=> return a correct value.' do
-      expect( (@enum::REDBULL <=> 1)  < 0 ).to be_true
-      expect( (@enum::REDBULL <=> 0) == 0 ).to be_true
-      expect( (@enum::MONSTER <=> 0)  > 0 ).to be_true
 
-      expect( @enum::MONSTER <=> 'a' ).to be_nil
+  describe 'Defined Inum::Base' do
+    before :each do
+      class Anime < Inum::Base
+        define :NYARUKO,   0
+        define :MUROMISAN, 1
+        define :NOURIN,    2
+        define :KMB,       4
+      end
     end
 
-    it '+ return a correct Inum.' do
-      expect(@enum::REDBULL + 1).to eq(@enum::MONSTER)
-      expect(@enum::REDBULL + @enum::MONSTER).to eq(@enum::MONSTER)
+    after :each do
+      Object.class_eval{ remove_const :Anime }
     end
 
-    it '- return a correct Inum.' do
-      expect(@enum::BURN - 1).to eq(@enum::MONSTER)
-      expect(@enum::BURN - @enum::MONSTER).to eq(@enum::MONSTER)
+    it 'Can not create instance.(Singleton)' do
+      expect{ Anime.new(:NICONICO, 2525) }.to raise_error
     end
 
-    it 'Comparable module enable.' do
-      expect(@enum::REDBULL.between?(0,1)).to be_true
+    it 'The instance of enum is equal.' do
+      expect(Anime::NYARUKO.equal?(Anime.parse!('NYARUKO'))).to be_true
     end
 
-    it 'eql? return a correct result.' do
-      expect( @enum::REDBULL.eql?(0) ).to be_true
-      expect( @enum::REDBULL.eql?(1) ).to be_false
-    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
 
-    it 'to_i return integer.' do
-      expect( @enum::REDBULL.to_i ).to eq(0)
+      expect(Anime::NYARUKO <=> 'Value can not compare.').to be_nil
     end
 
-    it 'to_s return string.' do
-      expect( @enum::MONSTER.to_s ).to eq('MONSTER')
+    it '+ method return a correct Inum.' do
+      expect(Anime::NYARUKO + 1).to eq(Anime::MUROMISAN)
     end
 
-    it 'translate and to_t return localized string.' do
-      expect( @enum::REDBULL.translate ).to eq('Good drink!')
-      expect( @enum::REDBULL.to_t ).to eq('Good drink!')
+    it '- method return a correct Inum.' do
+      expect(Anime::NOURIN - 1).to eq(Anime::MUROMISAN)
     end
 
-    it 'underscore and to_u return underscore string.' do
-      expect( @enum::REDBULL.underscore ).to eq('redbull')
-      expect( @enum::REDBULL.to_u ).to eq('redbull')
+    it 'Comparable module enable.' do
+      expect(Anime::MUROMISAN.between?(0,2)).to be_true
     end
 
-    it 'each can execute block with enum' do
+    it 'each method can execute block with enum' do
       count = 0
       expect{
-        @enum::each do |enum|
-          expect(enum.instance_of?(@enum)).to be_true
+        Anime.each do |enum|
+          expect(enum.instance_of?(Anime)).to be_true
           count += 1
         end
-      }.to change{count}.by(3)
+      }.to change{count}.by(Anime.length)
     end
 
     it 'Enumerable module enable.' do
-      expect(@enum::count).to eq(3)
-      expect(@enum::include?(@enum::REDBULL)).to be_true
+      expect(Anime.count).to eq(Anime.length)
+      expect(Anime.include?(Anime::NOURIN)).to be_true
+    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
     end
 
-    it 'labels return Array<Symbol>.' do
-      expect(@enum::labels.length).to eq(3)
-      expect(@enum::labels.instance_of?(Array)).to     be_true
-      expect(@enum::labels[0].instance_of?(Symbol)).to be_true
+    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
     end
 
     it 'length return count of enum.' do
-      expect(@enum::length).to eq(3)
+      expect(Anime.length).to eq(4)
     end
 
-    it 'to_a return Array<Array<Symbol,Integer>>.' do
-      expect(@enum::to_a.length).to eq(3)
-      expect(@enum::to_a.instance_of?(Array)).to        be_true
-      expect(@enum::to_a[0].instance_of?(Array)).to     be_true
-      expect(@enum::to_a[0][0].instance_of?(Symbol)).to be_true
-      expect(@enum::to_a[0][1].integer?).to             be_true
+    context 'Parse method' do
+      it 'Parsable string.' do
+        expect(Anime.parse('NOURIN')).to eq(Anime::NOURIN)
+      end
 
-      expect(@enum::to_a[0][0]).to eq(:REDBULL)
-      (0..2).each{|i| expect(@enum::to_a[i][1]).to eq(i) }
-    end
+      it 'Parsable integer.' do
+        expect(Anime.parse(1)).to eq(Anime::MUROMISAN)
+      end
 
-    it 'to_h return Hash' do
-      defined_enum_inst  = @enum.instance_variable_get(:@defined_enums)
+      it 'Parsable symbol.' do
+        expect(Anime.parse(:KMB)).to eq(Anime::KMB)
+      end
+
+      it 'Parsable self instance.' do
+        expect(Anime.parse(Anime::NYARUKO)).to eq(Anime::NYARUKO)
+      end
 
-      expect(@enum::to_h.instance_of?(Hash)).to be_true
+      it 'return nil for a unknown value.' do
+        expect(Anime.parse('Nothing') ).to eq(nil)
+      end
 
-      expect(@enum::to_h.eql?(defined_enum_inst)).to be_true
-      expect(@enum::to_h.equal?(defined_enum_inst)).to be_false
+      it 'parse! method raise exception for a unknown value.' do
+        expect{Anime.parse!('Nothing') }.to raise_error(NameError)
+      end
     end
 
-    it 'parse return instance from string.' do
-      expect( @enum::parse('REDBULL') ).to eq( @enum::REDBULL )
+    it 'to_a method return Array<Enum>.' do
+      enums = Anime.instance_variable_get(:@enums)
+
+      expect(Anime.to_a.eql?(enums)).to   be_true
+      expect(Anime.to_a.equal?(enums)).to be_false
     end
 
-    it 'parse return instance from integer.' do
-      expect( @enum::parse(1) ).to eq( @enum::MONSTER )
+    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
     end
 
-    it 'parse return instance from symbol.' do
-      expect( @enum::parse(:BURN) ).to eq( @enum::BURN )
+    it 'to_i and value methods return integer.' do
+      expect(Anime::KMB.to_i).to  eq(4)
+      expect(Anime::KMB.value).to eq(4)
     end
 
-    it 'parse return instance from self instance.' do
-      expect( @enum::parse(@enum::REDBULL) ).to eq( @enum::REDBULL )
+    it 'to_s method return string.' do
+      expect(Anime::NOURIN.to_s ).to eq('NOURIN')
     end
 
-    it 'parse return nil from a unknown value.' do
-      expect( @enum::parse('hoge') ).to eq( nil )
+    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-')
+
+      expect(Anime::NOURIN.t).to      eq('NO-RIN!')
+      expect(Anime::KMB.translate).to eq('KIRUMI-BEIBE-')
     end
 
-    it 'parse! raise exception from a unknown value.' do
-      expect{ @enum::parse!('hoge') }.to raise_error( NameError )
+    it 'underscore method return underscore string.' do
+      expect(Anime::NYARUKO.underscore).to eq('nyaruko')
     end
 
-    it 'values return Array<Integer>.' do
-      expect(@enum::values.length).to eq(3)
-      expect(@enum::values.instance_of?(Array)).to be_true
-      expect(@enum::values[0].integer?).to         be_true
+    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
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,9 +1,29 @@
 require 'rubygems'
 require 'bundler/setup'
+require 'active_record'
 require 'inum'
-require 'inum/utils'
-require 'i18n'
 
 RSpec.configure do |config|
   config.mock_framework = :rspec
+  config.before(:all) {
+    Dir.mkdir('tmp') unless Dir.exists?('tmp')
+    ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => 'tmp/rspec.sqlite')
+    I18n.enforce_available_locales = false
+  }
+end
+
+def create_temp_table(name, &block)
+  raise 'No Block given!' unless block_given?
+
+  before :all do
+    migration = ActiveRecord::Migration.new
+    migration.verbose = false
+    migration.create_table name, &block
+  end
+
+  after :all do
+    migration = ActiveRecord::Migration.new
+    migration.verbose = false
+    migration.drop_table name
+  end
 end

metadata

@@ -1,83 +1,111 @@
 --- !ruby/object:Gem::Specification
 name: inum
 version: !ruby/object:Gem::Version
-  version: 2.1.2
+  version: 3.0.0
 platform: ruby
 authors:
 - alfa-jpn
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-12 00:00:00.000000000 Z
+date: 2014-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: i18n
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.6.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.6.5
 description: Inum(enumerated type of Integer) provide a java-Enum-like.
@@ -87,19 +115,20 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - inum.gemspec
 - lib/inum.rb
+- lib/inum/active_record_mixin.rb
 - lib/inum/base.rb
-- lib/inum/define_check_method.rb
 - lib/inum/utils.rb
 - lib/inum/version.rb
+- spec/inum/active_record_mixin_spec.rb
 - spec/inum/base_spec.rb
-- spec/inum/define_check_method_spec.rb
 - spec/inum/utils_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/alfa-jpn/inum
@@ -112,23 +141,23 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.2.0
 signing_key: 
 specification_version: 4
 summary: Inum(enumerated type of Integer) provide a java-Enum-like.
 test_files:
+- spec/inum/active_record_mixin_spec.rb
 - spec/inum/base_spec.rb
-- spec/inum/define_check_method_spec.rb
 - spec/inum/utils_spec.rb
 - spec/spec_helper.rb
 has_rdoc: 

data/lib/inum/define_check_method.rb

@@ -1,33 +0,0 @@
-module Inum
-  # DefinedCheckMethod module should be extend.
-  #
-  # @example
-  #   class Fruit
-  #     extend Inum::DefineCheckMethod
-  #     define_check_method :type, FruitType
-  #
-  #     attr_accessor :type
-  #   end
-  #
-  module DefineCheckMethod
-    require 'inum/utils'
-
-    # Define compare method in class.
-    #
-    # @param variable_name [String]     name of variable.
-    # @param enum_class    [Inum::Base] class of extended Enum::EnumBase.
-    # @param prefix        [String]     prefix of define method.
-    def define_check_method(variable_name, enum_class, prefix = nil)
-      prefix = (prefix.nil?)? '' : "#{prefix}_"
-
-      self.class_eval do
-        enum_class::each do |enum|
-          define_method("#{prefix}#{enum.to_u}?") do
-            enum.eql?(send(variable_name))
-          end
-        end
-      end
-    end
-
-  end
-end

data/spec/inum/define_check_method_spec.rb

@@ -1,82 +0,0 @@
-require 'rspec'
-require 'spec_helper'
-
-describe Inum::DefineCheckMethod do
-
-  context 'create class after call define_check_method' do
-    before(:each) do
-      enum = @enum = Class.new(Inum::Base) do
-        define_enum :REDBULL,  0
-        define_enum :MONSTER,  1
-        define_enum :BURN,     2
-      end
-
-      @mixin = Class.new do
-        attr_accessor :drink
-
-        extend Inum::DefineCheckMethod
-        self.define_check_method(:drink, enum)
-      end
-    end
-
-    it 'defined comparison method.' do
-      expect(@mixin.method_defined?(:redbull?)).to be_true
-      expect(@mixin.method_defined?(:monster?)).to be_true
-      expect(@mixin.method_defined?(:burn?)).to    be_true
-    end
-
-    context 'create instance the class,' do
-      before(:each) do
-        @inst = @mixin.new
-      end
-
-      it 'can compare integer.' do
-        @inst.drink = 0
-        expect(@inst.redbull?).to be_true
-        expect(@inst.monster?).to be_false
-      end
-
-      it 'can compare string.' do
-        @inst.drink = 'REDBULL'
-        expect(@inst.redbull?).to be_true
-        expect(@inst.monster?).to be_false
-      end
-
-      it 'can compare symbol.' do
-        @inst.drink = :REDBULL
-        expect(@inst.redbull?).to be_true
-        expect(@inst.monster?).to be_false
-      end
-
-      it 'can compare self instance.' do
-        @inst.drink = @enum::REDBULL
-        expect(@inst.redbull?).to be_true
-        expect(@inst.monster?).to be_false
-      end
-
-    end
-  end
-
-  context 'create class after call define_check_method with prefix.' do
-    before(:each) do
-      enum = @enum = Class.new(Inum::Base) do
-        define_enum :REDBULL,  0
-        define_enum :MONSTER,  1
-        define_enum :BURN,     2
-      end
-
-      @mixin = Class.new do
-        attr_accessor :drink
-
-        extend Inum::DefineCheckMethod
-        self.define_check_method(:drink, enum, 'drink_type')
-      end
-    end
-
-    it 'defined comparison method.' do
-      expect(@mixin.method_defined?(:drink_type_redbull?)).to be_true
-      expect(@mixin.method_defined?(:drink_type_monster?)).to be_true
-      expect(@mixin.method_defined?(:drink_type_burn?)).to    be_true
-    end
-  end
-end