irxrb 0.0.7

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YzZlYTIzZjhjNmRhYTIwZGJmZDM0N2I4YzU0N2Y2YmVkOTY5OGU5Mw==
+  data.tar.gz: !binary |-
+    MzJlOWIzNTRmY2E0M2E2MzJiZjVjOWZiODI3M2JkNGY1ZWNhMmRhOA==
+SHA512:
+  metadata.gz: !binary |-
+    OTNkMWZjYWQ2MTcwYTZlNDI2ZTlmZWQzMjZhNWU1N2E5NjI5MWU0YTkzNWY4
+    OTU5MmZkMTdiYTAyZmRiNzQwOTA5YjY5ZmJkM2E3MjNjNGM2OGNhODkzNmRj
+    ZjYzOTY4MGE3ZGFmZWZiNDllZjI2N2RmYTU4Njk3NDUwMzJlYTI=
+  data.tar.gz: !binary |-
+    NjQzZWQ1YTM1M2ZkYTdkNTkxMmFlYWVjOTM3MzIyMjJiMjM3MTAzYmI5NjY4
+    YmJhODNjNjI0MmYxZjY3M2MwMWQ2YTY1Njk5YWRjMWMyZGI4NGZjMmJkMGM0
+    YjFmZjJiMjQ3YjY1NDMyMTk0Nzk3Zjk5OGU1NTk0MWMyYTQxYzc=

data/.gitignore

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

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 1.9.2
+  - jruby-19mode
+  - rbx-19mode
+

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in irxrb.gemspec
+gemspec
+
+group :test do
+  gem 'rake'
+  gem 'rspec'
+  gem 'simplecov', require: false
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 OTA Daichi
+
+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,32 @@
+
+[![Build Status](https://secure.travis-ci.org/irxground/irxrb.png?branch=master)](http://travis-ci.org/irxground/irxrb)
+
+# Irxrb
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'irxrb'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install irxrb
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,9 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec)
+
+  task :default => :spec
+rescue LoadError
+end

data/irxrb.gemspec

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/irxrb/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["irxground"]
+  gem.email         = ["irxnjhtchlnrw@gmail.com"]
+  gem.description   = %q{Ruby extension}
+  gem.summary       = %q{Ruby extension}
+  gem.homepage      = "https://github.com/irxground/irxrb"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "irxrb"
+  gem.require_paths = ["lib"]
+  gem.version       = Irxrb::VERSION
+end

data/irxrb.sublime-project

@@ -0,0 +1,8 @@
+{
+	"folders":
+	[
+		{
+			"path": "."
+		}
+	]
+}

data/lib/irxrb/core_ext/generic_type.rb

@@ -0,0 +1,5 @@
+require 'irxrb/generic_type'
+
+class Module
+  include Irxrb::GenericType
+end

data/lib/irxrb/core_ext/hash_to_obj.rb

@@ -0,0 +1,5 @@
+class Hash
+  def to_obj
+    Irxrb::HashObject.new(self)
+  end
+end

data/lib/irxrb/core_ext/match_data_to_hash.rb

@@ -0,0 +1,5 @@
+class MatchData
+  def to_hash
+    names.each_with_object({}){|name, hash| hash[name] = self[name] }
+  end
+end

data/lib/irxrb/core_ext/maybe.rb

@@ -0,0 +1,13 @@
+def Maybe(obj)
+  Irxrb::Maybe[obj]
+end
+class Object
+  def maybe(&block)
+    self.instance_eval(&block)
+  end
+end
+class NilClass
+  def maybe(&block)
+  end
+end
+

data/lib/irxrb/core_ext/range_to_regex.rb

@@ -0,0 +1,7 @@
+require 'irxrb/range_to_regex'
+
+class Range
+  def to_regex
+    Irxrb::RangeToRegex.invoke(self)
+  end
+end

data/lib/irxrb/core_ext/to_proc.rb

@@ -0,0 +1,5 @@
+class Object
+  def to_proc
+    method(:===).to_proc
+  end
+end

data/lib/irxrb/generic_type.rb

@@ -0,0 +1,25 @@
+module Irxrb
+  module GenericType
+    def type_parameter(*params)
+      m = self
+      define_singleton_method :[] do |*types|
+        raise ArgumentError if params.size != types.size
+        @_specific_type ||= {}
+        @_specific_type[types] ||=
+          begin
+            k = (m.is_a? Class) ?
+              Class.new(m) :
+              Module.new.tap{ |x| x.instance_eval { include m } }
+            params.zip(types).each do |param_name, type|
+              k.const_set param_name, type
+              k.instance_eval do
+                define_method(param_name){ type }
+              end
+            end
+            k
+          end
+      end
+    end
+  end
+end
+

data/lib/irxrb/hash_object.rb

@@ -0,0 +1,21 @@
+module Irxrb
+  class HashObject
+    def initialize(hash)
+      raise ArgumentError, 'argument should be Hash' unless Hash === hash
+      @hash = hash
+    end
+
+    def method_missing(action, *args)
+      if @hash.has_key? action
+        self.class.class_eval do
+          define_method(action) do
+            @hash[action]
+          end
+        end
+        return __send__ action
+      end
+      super
+    end
+  end
+end
+

data/lib/irxrb/lazy_attribute.rb

@@ -0,0 +1,27 @@
+module Irxrb
+  module LazyAttribute
+    def lazy(name, &block)
+      method_name = "__#{name}_lazy"
+      self.class_eval <<-"END"
+        def #{name}=(value)
+          @#{name} = value
+        end
+
+        def #{name}
+          @#{name} ||= #{method_name}
+        end
+
+        def #{name}?
+          @#{name} != nil
+        end
+
+        def #{name}!
+          @#{name} = #{method_name}
+        end
+      END
+      self.instance_eval do
+        define_method method_name, block
+      end
+    end
+  end
+end

data/lib/irxrb/maybe.rb

@@ -0,0 +1,52 @@
+
+module Irxrb
+  class Maybe
+    class << self
+      def [](value)
+        value != nil ? Just.new(value) : Nothing.instance
+      end
+    end
+
+    class Nothing < Maybe
+      @@instance = new
+
+      def initialize
+        raise "#{self.class} can't be instantize."
+      end
+
+      def self.instance
+        @@instance
+      end
+
+      def !@
+        nil
+      end
+
+      def method_missing(name, *arg)
+        self
+      end
+    end
+
+    class Just < Maybe
+      def initialize(value)
+        raise 'argument should not be nil' if value == nil
+        @value = value
+      end
+
+      def !@
+        @value
+      end
+
+      def method_missing(name, *arg)
+        ret =
+          block_given? ?
+            @value.__send__(name, *arg){|*a| yield *a } :
+            @value.__send__(name, *arg)
+        return Nothing.instance if ret == nil
+        return self             if ret == @value
+        return Just.new(ret)
+      end
+    end
+  end
+end
+

data/lib/irxrb/range_to_regex.rb

@@ -0,0 +1,68 @@
+module Irxrb::RangeToRegex
+
+  module_function
+
+  def invoke(range)
+    max = range.max + 1
+    min = range.min
+    pivot = pivot(min, max)
+
+    ret = []
+
+    base = pivot
+    split_by_unit(max - pivot).each do |unit, diff|
+      ret << make_regex(base, unit, diff)
+      base += unit * diff
+    end
+
+    base = pivot
+    split_by_unit(pivot - min).each do |unit, diff|
+      ret.unshift make_regex(base, unit, -diff)
+      base -= unit * diff
+    end
+
+    /#{ret.join('|')}/
+  end
+
+  def unit_of(num)
+    unit = 1
+    loop do
+      return unit if num < unit * 10
+      unit *= 10
+    end
+  end
+
+  def split_by_unit(num)
+    ret = []
+    unit = 1
+    while num > 0
+      n = num % 10
+      ret.unshift [unit, n] if n != 0
+      unit *= 10
+      num /= 10
+    end
+    return ret
+  end
+
+  def pivot(min, max)
+    unit = unit_of(max)
+    pivot = max / unit * unit
+    while unit > 1 && (min / pivot) == 1
+      unit /= 10
+      pivot = max / unit * unit
+    end
+    return pivot
+  end
+
+  def make_regex(base, unit, diff)
+    if diff < 0
+      return make_regex(base + unit * diff, unit, -diff)
+    end
+    prefix = base / (unit * 10)
+    prefix_str = prefix == 0 ? '' : prefix.to_s
+    current = base / unit % 10
+    current_str = diff == 1 ? current.to_s : "[#{current}-#{current + diff - 1}]"
+    suffix_str = "[0-9]" * Math.log(unit, 10).round
+    return prefix_str + current_str + suffix_str
+  end
+end

data/lib/irxrb/version.rb

@@ -0,0 +1,3 @@
+module Irxrb
+  VERSION = "0.0.7"
+end

data/lib/irxrb.rb

@@ -0,0 +1,9 @@
+require 'irxrb/version'
+
+module Irxrb
+  autoload :HashObject,    'irxrb/hash_object'
+  autoload :Maybe,         'irxrb/maybe'
+  autoload :LazyAttribute, 'irxrb/lazy_attribute'
+  autoload :RangeToRegex,  'irxrb/range_to_regex'
+  autoload :GenericType,   'irxrb/generic_type'
+end

data/spec/core_ext/hash_to_obj_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+require 'irxrb/core_ext/hash_to_obj'
+
+describe Hash, '#to_obj' do
+  subject { Hash[a: 1] }
+  specify { subject.should respond_to(:to_obj) }
+  specify { subject.to_obj.should be_an_instance_of(Irxrb::HashObject) }
+end

data/spec/core_ext/match_data_to_hash_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+require 'irxrb/core_ext/match_data_to_hash'
+
+describe MatchData, '#to_hash' do
+  subject do
+    /(?<a>\d+)-(?<b>\d+)-(?<c>\d+)/ =~ '12-34-56'
+    $~.to_hash
+  end
+
+  it { should be_an_instance_of(Hash) }
+  it { should == { 'a' => '12', 'b' => '34', 'c' => '56' } }
+end

data/spec/core_ext/maybe_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+require 'irxrb/core_ext/maybe'
+
+describe '#maybe' do
+  it 'should raise error without block' do
+    expect{ Object.new.maybe }.to raise_error
+  end
+
+  specify { expect([1,2,3].maybe{ self.map{|x| x * x } }).to eq([1,4,9]) }
+  specify { expect(    nil.maybe{ self.map{|x| x * x } }).to eq(nil    ) }
+  specify { expect(     10.maybe{ self * self          }).to eq(100    ) }
+end
+
+describe '#Maybe' do
+  specify { Maybe(100).should be_an_instance_of(Irxrb::Maybe::Just)    }
+  specify { Maybe(nil).should be_an_instance_of(Irxrb::Maybe::Nothing) }
+end

data/spec/core_ext/range_to_regex_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+require 'irxrb/core_ext/range_to_regex'
+
+describe Range do
+  subject { (10...100) }
+  specify { subject.to_regex.should be_an_instance_of(Regexp) }
+end

data/spec/core_ext/to_proc_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+require 'irxrb/core_ext/to_proc'
+
+describe '#to_proc' do
+  describe Object do
+    it 'should behave as ==' do
+      obj1 = Object.new
+      obj2 = Object.new
+      p = obj1.to_proc
+
+      p[obj1].should     be_true
+      p[obj2].should_not be_true
+    end
+  end
+
+  describe Regexp do
+    it 'should behave as matcher' do
+      p = /o/.to_proc
+
+      p['foo'].should     be_true
+      p['bar'].should_not be_true
+    end
+  end
+
+  describe Class do
+    it 'should behave as is_a?' do
+      is_str = String.to_proc
+
+      is_str['foo'].should     be_true
+      is_str[12345].should_not be_true
+    end
+  end
+
+  describe Proc do
+    it 'should not cause infinit loop' do
+      is_odd = proc{|num| num % 2 != 0 }
+
+      is_odd[1].should     be_true
+      is_odd[2].should_not be_true
+
+      case 1
+      when is_odd
+        value = :odd
+      else
+        value = :even
+      end
+      value.should == :odd
+
+      case 2
+      when is_odd
+        value = :odd
+      else
+        value = :even
+      end
+      value.should == :even
+    end
+  end
+
+  describe '&proc' do
+    specify { [1,2,3].map(&2).should == [false, true, false] }
+    specify { %w(foo bar baz).select(&/a/).should == %w(bar baz) }
+  end
+end
+

data/spec/generic_type_spec.rb

@@ -0,0 +1,46 @@
+require_relative 'spec_helper'
+require 'irxrb/core_ext/generic_type'
+
+describe Irxrb::GenericType do
+  context 'generic class' do
+    class Factory
+      type_parameter :T
+
+      def create
+        self.T.new
+      end
+    end
+
+    describe 'class' do
+      specify { Factory[String]::T.should == String }
+    end
+
+    describe 'instance' do
+      subject { Factory[String].new }
+      it { should be_an_instance_of(Factory[String]) }
+      it { should be_kind_of(Factory) }
+      it { should_not be_an_instance_of(Factory[Object]) }
+
+      specify { subject.T == String }
+      specify { subject.create.should == "" }
+    end
+  end
+
+  context 'generic module' do
+    module Map
+      type_parameter :Key, :Value
+    end
+
+    class ConcreteMap
+      include Map[Integer, String]
+    end
+
+    subject { ConcreteMap }
+    specify { subject::Key.should   == Integer }
+    specify { subject::Value.should == String  }
+    specify { subject.new.should be_kind_of(Map) }
+    specify { subject.new.should be_kind_of(Map[Integer, String]) }
+    specify { subject.new.should_not be_kind_of(Map[String, String]) }
+  end
+end
+

data/spec/hash_object_spec.rb

@@ -0,0 +1,24 @@
+require_relative 'spec_helper'
+
+describe Irxrb::HashObject do
+  describe 'constructor' do
+    it 'should raise error' do
+      expect {
+        Irxrb::HashObject.new("str")
+      }.to raise_error(ArgumentError)
+    end
+
+    it 'should create instance' do
+      expect {
+        Irxrb::HashObject.new(foo: bar)
+      }.not_to raise_error(ArgumentError)
+    end
+  end
+
+  describe 'method' do
+    subject { Irxrb::HashObject.new(foo: 1) }
+    specify { expect( subject.foo ).to eq(1) }
+    specify { expect{ subject.bar }.to raise_error(NoMethodError) }
+  end
+end
+

data/spec/lazy_attribute_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Irxrb::LazyAttribute do
+  subject { TestObj.new }
+
+  its(:counter) { should == 0 }
+  its(:value?)  { should == false }
+
+  describe 'after get attribute' do
+    before { subject.value.should == 'value1' }
+    its(:counter) { should == 1 }
+    its(:value?)  { should == true }
+    its(:value)   { should == 'value1' }
+
+    describe 'redo lazy' do
+      before { subject.value!.should == 'value2' }
+      its(:counter) { should == 2 }
+      its(:value?)  { should == true }
+      its(:value)   { should == 'value2' }
+    end
+  end
+
+  describe 'redo lazy' do
+    before { subject.value!.should == 'value1' }
+    its(:counter) { should == 1 }
+    its(:value?)  { should == true }
+    its(:value)   { should == 'value1' }
+  end
+
+  class TestObj
+    extend Irxrb::LazyAttribute
+
+    attr_reader :counter
+    def initialize
+      @counter = 0
+    end
+
+    lazy :value do
+      @counter += 1
+      "value#@counter"
+    end
+
+  end
+end

data/spec/maybe_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe Irxrb::Maybe do
+  describe '.[]' do
+    specify { expect { Irxrb::Maybe[] }.to raise_error }
+    specify { Irxrb::Maybe[nil  ].should be_kind_of(Irxrb::Maybe) }
+    specify { Irxrb::Maybe[false].should be_kind_of(Irxrb::Maybe) }
+
+    specify { Irxrb::Maybe[nil  ].should be_an_instance_of(Irxrb::Maybe::Nothing) }
+    specify { Irxrb::Maybe[false].should be_an_instance_of(Irxrb::Maybe::Just) }
+    specify { Irxrb::Maybe[true ].should be_an_instance_of(Irxrb::Maybe::Just) }
+    specify { Irxrb::Maybe[1    ].should be_an_instance_of(Irxrb::Maybe::Just) }
+    specify { Irxrb::Maybe["str"].should be_an_instance_of(Irxrb::Maybe::Just) }
+    specify { Irxrb::Maybe[:sym ].should be_an_instance_of(Irxrb::Maybe::Just) }
+    specify { Irxrb::Maybe[Class].should be_an_instance_of(Irxrb::Maybe::Just) }
+  end
+
+  describe '#!' do
+    specify {                   expect(!maybe(nil  )).to eq(nil  ) }
+    specify {                   expect(!maybe(1    )).to eq(1    ) }
+    specify {                   expect(!maybe("str")).to eq("str") }
+    specify { obj = Object.new; expect(!maybe(obj  )).to eq(obj  ) }
+  end
+
+  describe 'method call' do
+    describe Irxrb::Maybe::Nothing do
+      describe 'always return Nothing' do
+        subject { Irxrb::Maybe[nil] }
+        specify { expect(!subject           ).to eq(nil) }
+        specify { expect(!subject.foo       ).to eq(nil) }
+        specify { expect(!subject.foo.bar   ).to eq(nil) }
+        specify { expect(!subject.foo(1)    ).to eq(nil) }
+        specify { expect(!subject.foo{|x| x}).to eq(nil) }
+      end
+    end
+
+    describe Irxrb::Maybe::Just do
+      before do
+        @mock = Object.new
+        @mock.stub(ret_nil: nil)
+        @mock.stub(ret_self: @mock)
+      end
+
+      specify { expect(!maybe(@mock).ret_self).to             eq(@mock)   }
+      specify { expect(!maybe(@mock).ret_nil ).to             eq(nil)     }
+      specify { expect(!maybe(@mock).ret_self.ret_self).to    eq(@mock)   }
+      specify { expect(!maybe(@mock).ret_self.ret_nil ).to    eq(nil)     }
+      specify { expect(!maybe(@mock).ret_nil .ret_self).to    eq(nil)     }
+      specify { expect(!maybe(@mock).ret_nil .ret_nil ).to    eq(nil)     }
+      specify { expect(!maybe([1,2,3]).map{|x| x*x }).to      eq([1,4,9]) }
+      specify { expect(!maybe([1,2,3]).inject{|a,x| a+x }).to eq(6)       }
+      specify { expect(!maybe(a: 1)[:a]).to                   eq(1)       }
+      specify { expect(!maybe(a: 1)[:b][:c]).to               eq(nil)     }
+    end
+  end
+
+  describe '.new' do
+    specify { expect{ Irxrb::Maybe::Just.new(nil) }.to raise_error }
+    specify { expect{ Irxrb::Maybe::Nothing.new   }.to raise_error }
+  end
+
+  def maybe(value)
+    Irxrb::Maybe[value]
+  end
+end
+

data/spec/range_to_regex_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe Irxrb::RangeToRegex do
+  include Irxrb::RangeToRegex
+
+  describe '#invoke' do
+    specify { invoke(1..  9).should == /[1-9]/ }
+    specify { invoke(1... 9).should == /[1-8]/ }
+    specify { invoke(1.. 10).should == /[1-9]|10/ }
+    specify { invoke(1.. 11).should == /[1-9]|1[0-1]/ }
+    specify { invoke(1.. 99).should == /[1-9]|[1-9][0-9]/ }
+    specify { invoke(1..100).should == /[1-9]|[1-9][0-9]|100/ }
+    specify { invoke(1..101).should == /[1-9]|[1-9][0-9]|10[0-1]/ }
+    specify { invoke(1..110).should == /[1-9]|[1-9][0-9]|10[0-9]|110/ }
+    specify { invoke(1..111).should == /[1-9]|[1-9][0-9]|10[0-9]|11[0-1]/ }
+
+    specify { invoke(59.. 79).should == /59|[6-7][0-9]/ }
+    specify { invoke(60.. 79).should == /[6-7][0-9]/ }
+    specify { invoke(61.. 79).should == /6[1-9]|7[0-9]/ }
+    specify { invoke(59.. 80).should == /59|[6-7][0-9]|80/ }
+    specify { invoke(60.. 80).should == /[6-7][0-9]|80/ }
+    specify { invoke(61.. 80).should == /6[1-9]|7[0-9]|80/ }
+    specify { invoke(59.. 81).should == /59|[6-7][0-9]|8[0-1]/ }
+    specify { invoke(60.. 81).should == /[6-7][0-9]|8[0-1]/ }
+    specify { invoke(61.. 81).should == /6[1-9]|7[0-9]|8[0-1]/ }
+
+    specify { invoke(10..100).should == /[1-9][0-9]|100/ }
+    specify do
+      actual = invoke(987..654321)
+      expect = [
+        '98[7-9]|99[0-9]',
+        '[1-9][0-9][0-9][0-9]',
+        '[1-9][0-9][0-9][0-9][0-9]',
+        '[1-5][0-9][0-9][0-9][0-9][0-9]',
+        '6[0-4][0-9][0-9][0-9][0-9]',
+        '65[0-3][0-9][0-9][0-9]',
+        '654[0-2][0-9][0-9]',
+        '6543[0-1][0-9]',
+        '65432[0-1]'].join('|')
+      actual.should == /#{expect}/
+    end
+  end
+
+  describe '#unit_of' do
+    specify { unit_of(  8).should ==   1 }
+    specify { unit_of( 10).should ==  10 }
+    specify { unit_of( 99).should ==  10 }
+    specify { unit_of(100).should == 100 }
+  end
+
+  describe '#split_by_unit' do
+    specify { split_by_unit(1905).should == [[1000, 1], [100, 9], [1, 5]] }
+  end
+
+  describe '#pivot' do
+    specify { pivot(100, 200).should == 200 }
+    specify { pivot(199, 200).should == 200 }
+    specify { pivot( 99, 200).should == 200 }
+    specify { pivot(100, 299).should == 200 }
+    specify { pivot(100, 201).should == 200 }
+
+    specify { pivot(1860, 1970).should == 1900 }
+    specify { pivot(1960, 1970).should == 1970 }
+    specify { pivot(1986, 1987).should == 1987 }
+
+    specify { pivot(9876, 9876).should == 9876 }
+  end
+
+  describe '#make_regex' do
+    specify { make_regex(100, 10, 2).should == '1[0-1][0-9]' }
+    specify { make_regex(130, 10, 3).should == '1[3-5][0-9]' }
+    specify { make_regex(100, 10, 1).should == '10[0-9]' }
+    specify { make_regex(130, 10, 1).should == '13[0-9]' }
+
+    specify { make_regex(  10,   10, 3).should == '[1-3][0-9]' }
+    specify { make_regex( 100,  100, 3).should == '[1-3][0-9][0-9]' }
+    specify { make_regex(1000, 1000, 3).should == '[1-3][0-9][0-9][0-9]' }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'rubygems'
+require 'simplecov'
+SimpleCov.start do
+  add_filter '/spec'
+end
+require 'irxrb'

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: irxrb
+version: !ruby/object:Gem::Version
+  version: 0.0.7
+platform: ruby
+authors:
+- irxground
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-17 00:00:00.000000000 Z
+dependencies: []
+description: Ruby extension
+email:
+- irxnjhtchlnrw@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- irxrb.gemspec
+- irxrb.sublime-project
+- lib/irxrb.rb
+- lib/irxrb/core_ext/generic_type.rb
+- lib/irxrb/core_ext/hash_to_obj.rb
+- lib/irxrb/core_ext/match_data_to_hash.rb
+- lib/irxrb/core_ext/maybe.rb
+- lib/irxrb/core_ext/range_to_regex.rb
+- lib/irxrb/core_ext/to_proc.rb
+- lib/irxrb/generic_type.rb
+- lib/irxrb/hash_object.rb
+- lib/irxrb/lazy_attribute.rb
+- lib/irxrb/maybe.rb
+- lib/irxrb/range_to_regex.rb
+- lib/irxrb/validation_struct.rb
+- lib/irxrb/version.rb
+- spec/core_ext/hash_to_obj_spec.rb
+- spec/core_ext/match_data_to_hash_spec.rb
+- spec/core_ext/maybe_spec.rb
+- spec/core_ext/range_to_regex_spec.rb
+- spec/core_ext/to_proc_spec.rb
+- spec/generic_type_spec.rb
+- spec/hash_object_spec.rb
+- spec/lazy_attribute_spec.rb
+- spec/maybe_spec.rb
+- spec/range_to_regex_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/irxground/irxrb
+licenses: []
+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.1.9
+signing_key: 
+specification_version: 4
+summary: Ruby extension
+test_files:
+- spec/core_ext/hash_to_obj_spec.rb
+- spec/core_ext/match_data_to_hash_spec.rb
+- spec/core_ext/maybe_spec.rb
+- spec/core_ext/range_to_regex_spec.rb
+- spec/core_ext/to_proc_spec.rb
+- spec/generic_type_spec.rb
+- spec/hash_object_spec.rb
+- spec/lazy_attribute_spec.rb
+- spec/maybe_spec.rb
+- spec/range_to_regex_spec.rb
+- spec/spec_helper.rb