inum 3.0.0 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 99359111fe269cc5e91a4b3cfcca01412405ce0e
-  data.tar.gz: d41f12ce30debb7bb1e566bc64658d3ba3c7da73
+  metadata.gz: 7a13fbdf7013fbb32ae52aa22ed0a6190c952ce2
+  data.tar.gz: 8b6d48c73567b96073e0f4b4774ed11ca372a2eb
 SHA512:
-  metadata.gz: afc248454f732406d18b7a38a36a03e1b0106eae10bf9aa81c9727916420b58551aa784a4201516b0baf74cd148c791747f0039884c38a66ae33936dbfe2aac3
-  data.tar.gz: e626427aa8db41a1d7ecca7f95844a5f40aefe5374918195a07d2725701eca0e84ca860388b3e08af4314e1946842c482ad2de6f9ab67bb30dbdf215ed9c1d10
+  metadata.gz: fb3b3e5298b8993ca0b3bff39b7437a44ff82224c749457995e1298360ec37fd164d025162a36e808255d44203ae5f7a6e33f7fb65a288c0a884af4c59edd4e5
+  data.tar.gz: 322444e9be0196b9339b6491d36658005511b2f23fe2e07ccd02570cc06780fbb78bbac3a967e233eb2419abbc0582d0a3259dbff69fa31640f4816939772d20

data/.travis.yml

@@ -5,7 +5,8 @@ before_install:
 rvm:
   - 1.9.3
   - 2.1.0
+  - 2.1.2
 env:
-  - RAILS=3.2.16
-  - RAILS=4.0.2
-  - RAILS=4.1.0.beta1
+  - ACTIVE_RECORD_VERSION=3.2.16
+  - ACTIVE_RECORD_VERSION=4.0.0
+  - ACTIVE_RECORD_VERSION=4.1.4

data/Gemfile

@@ -1,4 +1,8 @@
 source 'https://rubygems.org'
 
+if ENV['ACTIVE_RECORD_VERSION']
+  gem 'activerecord', ENV['ACTIVE_RECORD_VERSION']
+end
+
 # Specify your gem's dependencies in inum.gemspec
 gemspec

data/README.md

@@ -24,97 +24,83 @@ Or install it yourself as:
 For example create enum(inum) of Japanese Anime.
 
 ``` ruby
-class AnimeType < Inum::Base
+class AnimeTypes < Inum::Base
   define :EVANGELION, 0
   define :HARUHI,     1
   define :NYARUKO,    2
 end
 ```
 
-If value(integer) is omitted, value(integer) is auto-incremented.
-
-``` ruby
-define :EVANGELION  # => value will auto-increment.
-```
+If the value(integer) is omitted, It is auto-incremented.(deprecated.)
 
 ### Use Enum(Inum)
 How to use Enum(Inum).
 
 ``` ruby
-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`.)
+p AnimeTypes::EVANGELION.label      # => :EVANGELION
+p AnimeTypes::EVANGELION.to_s       # => "EVANGELION"
+p AnimeTypes::EVANGELION.value      # => 0 (can use to_i.)
+p AnimeTypes::EVANGELION.translate  # => エヴァンゲリオン (I18n.t will be called with `anime_types.evangelion`.)
 
-# parse object to instance of AnimeType.
-# object can use class of Symbol or String or Integer or Self.
-type = AnimeType.parse(0)
-p AnimeType::HARUHI.eql?('HARUHI')   # => true (eql? can compare all parsable object.)
+# Parse object.
+# This method is parsable Symbol and String and Integer and Self.
+p AnimeTypes.parse(1) # => AnimeTypes::HARUHI
 
-p AnimeType::HARUHI + 1   # => NYARUKO
-p AnimeType::NYARUKO - 1  # => HARUHI
+# Compare object.
+p AnimeTypes::HARUHI.eql?('HARUHI')   # => true (This method can compare all parsable object.)
 
 # each method.
-AnimeType::each {|enum| p enum }
-
+AnimeTypes.each {|enum| p enum}
 ```
 
 can use Enumerable and Comparable.
 
 - more detail is [Class::Base](http://rubydoc.info/github/alfa-jpn/inum/Inum/Base)
 
-### if use ActiveRecord, can use bind\_inum
+### If use ActiveRecord, can use bind\_inum
 
 ``` ruby
-class Anime < ActiveRecord::Base
-  bind_inum :column => :type, :class => AnimeType
+class Favorite < ActiveRecord::Base
+  bind_inum :anime, AnimeTypes
 end
-
-# if set prefix.
-class Anime < ActiveRecord::Base
-  bind_inum :column => :type, :class => AnimeType, :prefix => nil # remove prefix, when prefix is nil.
-end
-
 ```
 
-bind\_enum generates useful methods and validation.
+bind\_enum wrap accessor of column.
 
 ``` ruby
-anime = Anime.new(type: AnimeType::NYARUKO)
-p anime.type.t # => '這いよれ！ニャル子さん' t is aliased translate.
+fav = Favorite.new(anime: AnimeTypes::NYARUKO)
 
-p anime.type_evangelion? # => false
-p anime.type_nyaruko?    # => true
+# #getter will return instance of AnimeTypes.
+p fav.anime.t # => '這いよれ！ニャル子さん' t is aliased translate.
 
-
-# type can use all parsable object.
+# #setter can set parsable object.
 anime.type = 1
-p anime.type_haruhi? # => true
+anime.type = 'NYARUKO'
 
+# check methods.
+p fav.anime_evangelion? # => false
 ```
 
 ### Localize(i18n)
-to_t methods localize enum by i18n.
-default i18n key is inum.{name_space}.{class_name}.{enum_member_label}.
+translate methods localize enum by i18n.
+default i18n key is `#{name_space}.#{class_name}.#{label}`.
+
+``` yaml
+ja:
+  anime_types:
+    evangelion: 'エヴァンゲリオン'
+    haruhi:     'ハルヒ'
+    nyaruko:    '這いよれ！ニャル子さん'
+```
+
 If change default, Override i18n_key class method.
 
 ``` ruby
-# default i18n_key.
 def self.i18n_key(label)
-  Inum::Utils::underscore("inum::#{self.name}::#{label}")
+  "hogehoge.#{label}"
 end
 ```
 
-example
-
-``` yaml
-ja:
-  inum:
-    anime_type:
-      evangelion: 'エヴァンゲリオン'
-      haruhi:     'ハルヒ'
-      nyaruko:    '這いよれ！ニャル子さん'
-```
-
 ## API DOCUMENT
 
 - [Documentation for alfa-jpn/Inum(master)](http://rubydoc.info/github/alfa-jpn/inum/frames)

data/inum.gemspec

@@ -18,12 +18,15 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.required_ruby_version = ">= 1.9.3"
+
+  spec.add_development_dependency "bundler", "~> 1.5"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rspec", ">= 3.0.0"
   spec.add_development_dependency "yard"
   spec.add_development_dependency "activerecord"
   spec.add_development_dependency "sqlite3"
 
-  spec.add_dependency "i18n", "~> 0.6.5"
+  spec.add_dependency "i18n"
+  spec.add_dependency "activesupport"
 end

data/lib/inum.rb

@@ -5,6 +5,8 @@ require 'inum/base'
 require 'inum/active_record_mixin.rb'
 
 module Inum
+  class NotDefined < StandardError; end
+
   if Object.const_defined?(:ActiveRecord)
     ActiveRecord::Base.send :extend, Inum::ActiveRecordMixin
   end

data/lib/inum/active_record_mixin.rb

@@ -9,44 +9,32 @@ module Inum
   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]}_"
+    # @param column     [Symbol]      Binding column name.
+    # @param enum_class [Inum::Base]  Binding Enum.
+    # @param options    [Hash]        option
+    # @option options [Symbol]    :prefix     Prefix. (default: column)
+    def bind_inum(column, enum_class, options = {})
+      options = { prefix: column }.merge(options)
+      options[:prefix] = options[:prefix] ? "#{options[:prefix]}_" : ''
 
       self.class_eval do
-        if opts[:validation]
-          validates opts[:column], {
-            allow_nil: opts[:allow_nil],
-            inclusion: {in: opts[:class].to_a},
-          }
+        define_method(column) do
+          enum_class.parse(read_attribute(column))
         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)
+        define_method("#{column}=") do |value|
+          enum_class.parse(value).tap do |enum|
+            if enum
+              write_attribute(column, enum.to_i)
+            else
+              write_attribute(column, nil)
+            end
           end
         end
 
-        opts[:class].each do |enum|
-          define_method("#{opts[:prefix]}#{enum.underscore}?") do
-            enum.eql?(send(opts[:column]))
+        enum_class.each do |enum|
+          define_method("#{options[:prefix]}#{enum.to_s.underscore}?") do
+            enum.eql?(read_attribute(column))
           end
         end
       end

data/lib/inum/base.rb

@@ -1,6 +1,6 @@
 module Inum
+  require 'active_support/inflector'
   require 'i18n'
-  require 'inum/utils'
 
   # InumBase class.
   #
@@ -21,10 +21,10 @@ module Inum
     # @param label [Symbol]  label of Enum.
     # @param value [Integer] value of Enum.
     def initialize(label, value)
-      @label = label
-      @value = value
-
-      @underscore_label = Inum::Utils::underscore(label)
+      @label        = label
+      @label_string = label.to_s
+      @value        = value
+      @i18n_key     = ActiveSupport::Inflector.underscore("#{self.class.name}::#{label}").gsub('/', '.')
     end
 
     # Compare object.
@@ -32,11 +32,10 @@ module Inum
     # @param object [Object] parsable object.
     # @return [Integer] same normal <=>.
     def <=> (object)
-      other = self.class.parse(object)
-      if other.nil?
-        nil
-      else
+      if other = self.class.parse(object)
         @value <=> other.to_i
+      else
+        nil
       end
     end
 
@@ -75,7 +74,7 @@ module Inum
     #
     # @return [String] Label(String).
     def to_s
-      @label.to_s
+      @label_string
     end
 
     # Translate Enum to localized string.(use i18n)
@@ -83,17 +82,10 @@ module Inum
     #
     # @return [String] localized string of Enum.
     def translate
-      I18n.t(self.class.i18n_key(@label))
+      I18n.t(@i18n_key)
     end
     alias_method :t, :translate
 
-    # Enum label to underscore string.
-    #
-    # @return [String] under_score string value(label) of Enum.
-    def underscore
-      @underscore_label
-    end
-
     # Value of Enum.
     #
     # @return [Integer] Value of Enum.
@@ -102,152 +94,128 @@ module Inum
     end
     alias_method :to_i, :value
 
+    # Get collection.
+    # @note Type of usable with a Rails form helper.
+    # @exapmle
+    #  f.select :name, Enum.collection
+    #  f.select :name, Enum.collection(except:[:HOGE])      # Except Enum::HOGE
+    #  f.select :name, Enum.collection(only:[:HOGE, :FUGA]) # Only Enum::HOGE and Enum::FUGA
+    #
+    # @param option [Hash] Options.
+    # @option option [Array<Symbol>] except Except enum.
+    # @option option [Array<Symbol>] only   Limit enum.
+    # @return [Array<Array>] collection.
+    def self.collection(option)
+      map { |e|
+        next if option[:except] and option[:except].include?(e.label)
+        next if option[:only]   and !option[:only].include?(e.label)
+        [e.translate, e.value]
+      }.compact
+    end
+
     # Execute the yield(block) with each member of enum.
     #
     # @param &block [proc{|enum| .. }] execute the block.
     def self.each(&block)
-      enums.each(&block)
+      @enums.each(&block)
     end
 
     # get all labels of Enum.
     #
     # @return [Array<Symbol>] all labels of Enum.
     def self.labels
-      enum_format.keys
+      @enums.map(&:label)
     end
 
     # get Enum length.
     #
     # @return [Integer] count of Enums.
     def self.length
-      enum_format.length
+      @enums.length
     end
 
-    # return array of Enums.
+    # Parse object to Enum.
     #
-    # @return [Array<Inum>] sorted array of Enums.
-    def self.to_a
-      enums.dup
-    end
-
-    # return hash of Enums.
-    #
-    # @return [Hash<Symbol, Integer>] hash of Enums.
-    def self.to_h
-      enum_format.dup
+    # @param object [Object] string or symbol or integer or Inum::Base.
+    # @return [Inum::Base, Nil] enum or nil.
+    def self.parse(object)
+      case object
+      when String
+        upcase = object.upcase
+        find {|e| e.to_s == upcase}
+      when Symbol
+        upcase = object.upcase
+        find {|e| e.label == upcase}
+      when Integer
+        find {|e| e.value == object}
+      when self
+        object
+      else
+        nil
+      end
     end
 
-    # Parse Object to Enum.(unsafe:An exception may occur.)
+    # Parse object to Enum.
+    # @raise [Inum::NotDefined] raise if not found.
     #
     # @param object [Object] string or symbol or integer or Inum::Base.
-    # @return [Inum::Base] instance of Inum::Base. or raise Exception.
+    # @return [Inum::Base] enum.
     def self.parse!(object)
-      case object
-        when String
-          self.const_get(object)
-        when Symbol
-          parse object.to_s
-        when Integer
-          parse self.enum_format.key(object).to_s
-        when self
-          object
-        else
-          raise ArgumentError, "#{object} is nani?"
-      end
+      parse(object) || raise(Inum::NotDefined)
     end
 
-    # Parse Object to Enum.
+    # return array of Enums.
     #
-    # @param object [Object] string or symbol or integer or Inum::Base.
-    # @return [Inum::Base] instance of Inum::Base. or nil.
-    def self.parse(object)
-      case object
-        when String
-          return nil unless labels.include?(object.to_sym)
-        when Symbol
-          return nil unless labels.include?(object)
-        when Integer
-          return nil unless values.include?(object)
-        when self
-          # do nothing.
-        else
-          return nil
-      end
-      parse!(object)
+    # @return [Array<Inum>] sorted array of Enums.
+    def self.to_a
+      @enums.dup
     end
 
     # get all values of Enum.
     #
     # @return [Array<Integer>] all values of Enum.
     def self.values
-      enum_format.values
+      @enums.map(&:value)
     end
 
-
-    # Define Enum in called class.
+    # Define Enum.
     #
     # @param label [Symbol]  label of Enum.
     # @param value [Integer] value of Enum.(default:autoincrement for 0.)
-    def self.define(label, value = enum_format.size)
-      value = value.to_i
+    def self.define(label, value = @enums.size)
       validate_enum_args!(label, value)
 
-      enum = new(label, value)
-      enum_format[label] = value
-
-      enums.push(enum)
-      self.const_set(label, enum)
-    end
-
-    # get hash of @enum_format.
-    # @private
-    #
-    # @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.
-    # @note default: Namespace.Classname.Label(label of enum member.)
-    #
-    # @param label [Symbol] label of enum member.
-    # @return [String] key for I18n.t method.
-    # @abstract If change key from the default.
-    def self.i18n_key(label)
-      Inum::Utils::underscore("inum::#{self.name}::#{label}")
+      new(label, value).tap do |enum|
+        const_set(label, enum)
+        @enums.push(enum)
+      end
     end
 
-    # call after inherited.
-    #
-    # @note Define hash of :enum_format in child.
+    # Initialize inherited class.
     def self.inherited(child)
-      child.instance_variable_set(:@enum_format, Hash.new)
       child.instance_variable_set(:@enums, Array.new)
     end
 
-    # Validate enum args, and raise exception.
+    # Validate enum args.
+    # @raise [ArgumentError] If argument is wrong.
     #
     # @param label [Object]  label of Enum.
     # @param value [Integer] value of Enum.
     def self.validate_enum_args!(label, value)
       unless label.instance_of?(Symbol)
-        raise ArgumentError, "The label(#{label}!) isn't instance of Symbol."
+        raise ArgumentError, "#{label} isn't instance of Symbol."
+      end
+
+      if labels =~ /[^A-Z\d_]/
+        raise ArgumentError, "#{label} is wrong constant name. Label allow uppercase and digits and underscore."
       end
 
       if labels.include?(label)
-        raise ArgumentError, "The label(#{label}!) already exists!!"
+        raise ArgumentError, "#{label} already exists label."
       end
 
       if values.include?(value)
-        raise ArgumentError, "The value(#{value}!) already exists!!"
+        raise ArgumentError, "#{value} already exists value."
       end
     end