inum 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 544234bb17ff082ebab6a647cbd6de98e9537ad1
+  data.tar.gz: 2e9ed5c46161e3fc72d8a5fa137e6f21178a97af
+SHA512:
+  metadata.gz: 33196201c228dbcb269d823423f8cd2c2e55779f615a7d47b2aab6d6d6666b68ce64e366459f02bdabb03978f3f98bf55fd059dca2a4d7dc4eaa82ae2fb40b2b
+  data.tar.gz: ad2bf42518ac9e2c7242bf6f20ceeceb6f9b03f17ec50d265334e089e426cb2dcc25fb65728d375ee71317b23e39c726c52f8af247beeb5a3cee36d2b5c4375c

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+vendor/
+nbproject/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in inum.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Atsushi Nakamura
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,90 @@
+# Inum
+
+Inum(enumerated type of Integer) provide a Java-enum-like Enum.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'inum'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install inum
+
+## Usage
+
+
+### Define Enum(Inum)
+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
+end
+```
+
+### Use Enum(Inum)
+How to use Enum(Inum).
+
+``` ruby
+p AnimeType::EVANGELION       # => EVANGELION
+p AnimeType::EVANGELION.to_i  # => 0
+
+type = AnimeType::Parse(0)    # parse object to instance of AnimeType.
+p type.equal?(AnimeType::EVANGELION) # => true (member of Enum is singleton.)
+
+p AnimeType::HARUHI.eql?('HARUHI')   # => true (eql? can compare all parsable object.)
+
+```
+
+- 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.
+
+``` ruby
+class Anime
+  extend Inum::DefineCheckMethod
+  
+  attr_accessor :type
+
+  define_check_method :type, AnimeType
+end
+
+```
+
+define\_check\_method generates methods for type confirmation. 
+
+``` ruby
+anime = Anime.new
+anime.type = AnimeType::NYARUKO
+
+p anime.evangelion? # => false
+p anime.nyaruko?    # => true
+
+
+# type can use all parsable object.
+anime.type = 1
+p anime.haruhi? # => true
+
+```
+
+
+## API DOCUMENT
+
+- [Documentation for alfa-jpn/Inum(master)](http://rubydoc.info/github/alfa-jpn/inum/frames)
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/inum.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'inum/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "inum"
+  spec.version       = Inum::VERSION
+  spec.authors       = ["alfa-jpn"]
+  spec.email         = ["a.nkmr.ja@gmail.com"]
+  spec.description   = "Inum(enumerated type of Integer) provide a java-Enum-like."
+  spec.summary       = "Inum(enumerated type of Integer) provide a java-Enum-like."
+  spec.homepage      = "https://github.com/alfa-jpn/inum"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "yard"
+end

data/lib/inum.rb

@@ -0,0 +1 @@
+require "inum/version"

data/lib/inum/base.rb

@@ -0,0 +1,132 @@
+module Inum
+  # InumBase class.
+  #
+  # @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
+  #   end
+  class Base
+   
+    attr_accessor :value
+    private_class_method :new
+
+    # initialize Inum::Base with value.
+    # @note Inum::Base can't call new method.
+    #
+    # @param value [Integer] value of Enum.
+    def initialize(value)
+      unless self.class.defined_enums.has_value?(value)
+        raise ArgumentError, "unknown value #{value}!"
+      end
+      @value = value
+    end
+
+    # Compare object.
+    #
+    # @param [Object] parsable object.
+    # @return [Boolean] result.
+    def eql?(object)
+      self.equal?(self.class.parse(object))
+    end
+    
+    # Enum to Integer.
+    # 
+    # @return [Integer] integer value of Enum.
+    def to_i
+      @value
+    end
+
+    # Enum to String.
+    #
+    # @return [String] string value of Enum.
+    def to_s
+      self.class.defined_enums.key(@value).to_s
+    end
+
+    # return array of Enums.
+    #
+    # @return [Array<Array<String, Integer>>] sorted array of Enums.
+    def self.to_a
+      defined_enums.map{|k,v| [k.to_s,v] }.sort{|a,b| a[1] <=> b[1] }
+    end
+    
+    # return hash of Enums.
+    #
+    # @return [Hash] hash of Enums.
+    def self.to_h
+      defined_enums.dup
+    end
+    
+    # Parse Object to Enum.
+    #
+    # @param object [Object] string or symbol or integer or Inum::Base.
+    # @return [Inum::Base] instance of Inum::Base.
+    def self.parse(object)
+      case object
+        when String
+          self.const_get(object)
+        when Symbol
+          parse object.to_s
+        when Integer
+          parse self.defined_enums.key(object).to_s
+        when self
+          object
+        else
+          raise ArgumentError, "#{object} is nani?"
+      end
+    end
+
+    private
+    # Define Enum in called class.
+    #
+    # @param name  [String, Symbol] name of Enum.
+    # @param value [Integer,Fixnum] value of Enum.
+    def self.define_enum(name, value)
+
+      validate_enum_args!(name, value)
+
+      defined_enums[name] = value
+      self.const_set(name, new(value))
+    end
+    
+    # get hash of :DEFINED_ENUMS.
+    def self.defined_enums
+      self.const_get(:DEFINED_ENUMS)
+    end
+
+    # call after inherited.
+    # @note Define hash of :DEFINED_ENUMS in child.
+    def self.inherited(child)
+      child.const_set(:DEFINED_ENUMS, Hash.new)
+    end
+    
+    # Validate enum args, and raise exception.
+    # 
+    # @param name  [Object]  name of Enum.
+    # @param value [Object] value of Enum.
+    def self.validate_enum_args!(name, value)
+      unless name.instance_of?(String) or name.instance_of?(Symbol)
+        raise ArgumentError, "#{name}<#{name.class}> isn't String or Symbol."
+      end
+      
+      unless value.instance_of?(Integer) or value.instance_of?(Fixnum)
+        raise ArgumentError, "#{value}<#{value.class}> isn't Integer or Fixnum."
+      end
+      
+      if name == :DEFINED_ENUMS
+        raise ArgumentError, "#{name} is keyword."
+      end
+
+      if defined_enums.has_key?(name)
+        raise ArgumentError, "name(#{name}!) already exists!!"
+      end
+      
+      if defined_enums.has_value?(value)
+        raise ArgumentError, "value(#{value}!) already exists!!"
+      end
+    end
+  end
+end

data/lib/inum/define_check_method.rb

@@ -0,0 +1,27 @@
+module Inum
+  # DefinedCheckMethod module should be extend.
+  #
+  # @example
+  #   class Fruit
+  #     extend Inum::DefineCheckMethod
+  #     define_check_method :type, FruitType
+  #   
+  #     attr_accessor :type
+  #   end
+  #
+  module DefineCheckMethod
+    # Define compare method in class.
+    #
+    # @param variable_name [String]     name of variable.
+    # @param enum_class    [Inum::Base] class of extended Enum::EnumBase.
+    def define_check_method(variable_name, enum_class)
+      self.class_eval do
+        enum_class::DEFINED_ENUMS.each_key do |enum_name|
+          define_method("#{enum_name.downcase}?") do
+            enum_class::parse(enum_name).eql?(send(variable_name))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/inum/version.rb

@@ -0,0 +1,3 @@
+module Inum
+  VERSION = "1.0.0"
+end

data/spec/inum/base_spec.rb

@@ -0,0 +1,111 @@
+require 'rspec'
+require 'spec_helper'
+
+describe Inum::Base do
+  
+  it 'define_method validate correct' do
+    # correct.
+    expect{
+      Class.new(Inum::Base) { define_enum :REDBULL,  0 } 
+      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
+  
+  context 'define class of extended Inum::Base,' do
+    before(:each) do
+      @enum = Class.new(Inum::Base) do
+        define_enum :REDBULL,  0
+        define_enum :MONSTER,  1
+        define_enum :BURN,     2
+      end
+    end
+
+    it 'can not call new.' do
+      expect{ @enum.new(1) }.to raise_error
+    end
+
+    it 'DEFINED_ENUM is different instance.' do
+      @enum2 = Class.new(Inum::Base) do
+        define_enum :REDBULL,  0
+      end
+      expect( @enum::DEFINED_ENUMS.equal?(@enum2::DEFINED_ENUMS) ).to be_false
+    end
+
+    it 'A enum instance is equal instance.' do
+      expect( @enum::BURN.equal?(@enum::BURN )).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 'to_i return integer.' do
+      expect( @enum::REDBULL.to_i ).to eq(0)
+    end
+
+    it 'to_s return string.' do
+      expect( @enum::MONSTER.to_s ).to eq('MONSTER')
+    end
+    
+    it 'to_a return Array' do
+      expect(@enum::to_a.instance_of?(Array)).to be_true
+      expect(@enum::to_a.length).to eq(3)
+      expect(@enum::to_a[0][0]).to  eq('REDBULL')
+      (0..2).each{|i| expect(@enum::to_a[i][1]).to eq(i) }
+    end
+    
+    it 'to_h return Hash' do
+      expect(@enum::to_h.instance_of?(Hash)).to be_true
+      expect(@enum::to_h.eql?(@enum::DEFINED_ENUMS)).to be_true
+      expect(@enum::to_h.equal?(@enum::DEFINED_ENUMS)).to be_false
+    end
+
+    it 'parse return instance from string.' do
+      expect( @enum::parse('REDBULL') ).to eq( @enum::REDBULL )
+    end
+
+    it 'parse return instance from integer.' do
+      expect( @enum::parse(1) ).to eq( @enum::MONSTER )
+    end
+
+    it 'parse return instance from symbol.' do
+      expect( @enum::parse(:BURN) ).to eq( @enum::BURN )
+    end
+
+    it 'parse return instance from self instance.' do
+      expect( @enum::parse(@enum::REDBULL) ).to eq( @enum::REDBULL )
+    end
+  end
+end

data/spec/inum/define_check_method_spec.rb

@@ -0,0 +1,59 @@
+require 'rspec'
+require 'spec_helper'
+
+describe Inum::DefineCheckMethod do
+
+  context 'create class of called 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
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'inum/base'
+require 'inum/define_check_method'
+
+RSpec.configure do |config|
+  config.mock_framework = :rspec
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: inum
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- alfa-jpn
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-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'
+description: Inum(enumerated type of Integer) provide a java-Enum-like.
+email:
+- a.nkmr.ja@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- inum.gemspec
+- lib/inum.rb
+- lib/inum/base.rb
+- lib/inum/define_check_method.rb
+- lib/inum/version.rb
+- spec/inum/base_spec.rb
+- spec/inum/define_check_method_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/alfa-jpn/inum
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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
+signing_key: 
+specification_version: 4
+summary: Inum(enumerated type of Integer) provide a java-Enum-like.
+test_files:
+- spec/inum/base_spec.rb
+- spec/inum/define_check_method_spec.rb
+- spec/spec_helper.rb
+has_rdoc: