id_coder 1.0.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,11 @@
+source "http://rubygems.org"
+
+gem 'modalsupport'
+gem 'modalsettings'
+
+group :development do
+  gem "shoulda", ">= 0"
+  gem "rdoc", "~> 3.12"
+  gem "bundler", "~> 1"
+  gem "jeweler", "~> 1.8.3"
+end

data/Gemfile.lock

@@ -0,0 +1,32 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    git (1.2.5)
+    jeweler (1.8.3)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    json (1.6.6)
+    modalsettings (1.0.0)
+      modalsupport (>= 0.8.1)
+    modalsupport (0.8.3)
+    rake (0.9.2.2)
+    rdoc (3.12)
+      json (~> 1.4)
+    shoulda (3.0.1)
+      shoulda-context (~> 1.0.0)
+      shoulda-matchers (~> 1.0.0)
+    shoulda-context (1.0.0)
+    shoulda-matchers (1.0.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1)
+  jeweler (~> 1.8.3)
+  modalsettings
+  modalsupport
+  rdoc (~> 3.12)
+  shoulda

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Javier Goizueta
+
+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.rdoc

@@ -0,0 +1,44 @@
+= id_coder
+
+Id-codes are relatively short codes to represent externally id internal numbers.
+
+A bijection between ids and codes is used to assure uniqueness of codes and to avoid storing the
+codes in the database (codes and ids are computed on-the-fly from each other).
+
+Codes are user-visible; they're designed to be the user's identification of some element.
+
+Only digits an capital letters are used for the codes, excluding I,O,1,0 to avoid confusion,
+and a check digit can be used to detect most common transcription errors. This makes codes
+viable to be transmitted orally, etc.
+
+The number of digits used is scalable: the minimum number of digits and the increment-size can be
+parameterized to render good-looking codes.
+
+An IdCoder can be defined passing to it three optional parameters that define the lenght of the codes:
+
+  IdCoder[:num_digits=>4, :block_digits=>3, :check_digit=>false]
+
+An additional parameter can be passed to define which characters will be used as digits for the codes
+and its order; this must be a String of IdCoder::RADIX distinct characters:
+
+  IdCoder[:code_digits=>"0123456789ABCDEFGHIJKLMNOPQRSTUV"]
+
+Alternatively, a seed parameter can be passed to generate a randomized string
+
+  IdCoder[:seed=>8734112]
+
+Since this might produce different results in different Ruby versions, the code_digits produced can be accessed
+and kept for portability:
+
+  IdCoder[:seed=>8734112].code_digits # -> "9GTFNJSZA6LQWXV3BEKHYMP75U8R24CD"
+
+Ids (integers) can be coded and decoded into alphanumeric strings like this:
+
+  id_coder = IdCoder[]
+  id_coder.id_to_code(7) # => "JEQJTE3"
+  id_coder.code_to_id("JEQJTE3") # => 7
+
+== Copyright
+
+Copyright (c) 2012 Javier Goizueta. See LICENSE.txt for
+further details.

data/Rakefile

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "id_coder"
+  gem.homepage = "http://github.com/jgoizueta/id_coder"
+  gem.license = "MIT"
+  gem.summary = %Q{Alphanumeric code generator}
+  gem.description = %Q{Generates relatively short codes to represent id numbers externally}
+  gem.email = "jgoizueta@gmail.com"
+  gem.authors = ["Javier Goizueta"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "id_coder #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/lib/id_coder.rb

@@ -0,0 +1,203 @@
+require 'rubygems'
+require 'modalsupport'
+require 'modalsettings'
+
+# Id-codes are relatively short codes to represent externally id internal numbers.
+#
+# A bijection between ids and codes is used to assure uniqueness of codes and to avoid storing the
+# codes in the database (codes and ids are computed on-the-fly from each other).
+#
+# Codes are user-visible; they're designed to be the user's identification of some element.
+#
+# Only digits an capital letters are used for the codes, excluding I,O,1,0 to avoid confusion,
+# and a check digit can be used to detect most common transcription errors. This makes codes
+# viable to be transmitted orally, etc.
+#
+# The number of digits used is scalable: the minimum number of digits and the increment-size can be
+# parameterized to render good-looking codes.
+#
+# An IdCoder can be defined passing to it three optional parameters that define the lenght of the codes:
+#   IdCoder[:num_digits=>4, :block_digits=>3, :check_digit=>false]
+# An additional parameter can be passed to define which characters will be used as digits for the codes
+# and its order; this must be a String of IdCoder::RADIX distinct characters:
+#   IdCoder[:code_digits=>"0123456789ABCDEFGHIJKLMNOPQRSTUV"]
+# Alternatively, a seed parameter can be passed to generate a randomized string
+#   IdCoder[:seed=>8734112]
+# Since this might produce different results in different Ruby versions, the code_digits produced can be accessed
+# and kept for portability:
+#   IdCoder[:seed=>8734112].code_digits # -> "9GTFNJSZA6LQWXV3BEKHYMP75U8R24CD"
+#
+class IdCoder
+
+  # Internal parameters
+  RADIX = 32
+  DIGITS = "0123456789abcdefghijklmnopqrstuv"      # RADIX-digits used by Integer#to_s(RADIX), String#to_i(RADIX)
+  CODE_DIGITS = "BAFTQ4EJCNVYZKDPG37H5S8WML692RXU" # RADIX-digits used for the codes (permutation of 2-9,A-Z except I,O)
+
+  class InvalidCode < RuntimeError; end
+  class InvalidNumber < RuntimeError; end
+  class InvalidCodeDigits < RuntimeError; end
+
+  def initialize(config={})
+    config = Settings[config]
+    if config.code_digits
+      @code_digits = config.code_digits
+      raise InvalidCodeDigits, "Invalid digits" if @code_digits.bytes.to_a.uniq.size!=RADIX
+    else
+      @code_digits = CODE_DIGITS
+      if config.seed
+        srand config.seed
+        @code_digits = @code_digits.bytes.to_a.shuffle.map(&:chr)*""
+      end
+    end
+    @num_digits = (config.num_digits || 6).to_i
+    @block_digits = (config.block_digits || 2).to_i
+    @check_digit = config.check_digit
+    @check_digit = true if @check_digit.nil?
+  end
+
+  include ModalSupport::BracketConstructor
+
+  include
+
+  # configurable parameters
+
+  # Minumum number of digits used; limits the number of valid ids before scaling up to RADIX**num_digits
+  def num_digits
+    @num_digits
+  end
+
+  # Use a check digit?: this increases the length of codes in one
+  def check_digit?
+    @check_digit
+  end
+
+  # Number of digits for incremental scaling-up blocks
+  def block_digits
+    @block_digits
+  end
+
+  # Properties of the codes
+
+  # mininum code_length
+  def code_length
+    num_digits + (check_digit? ? 1 : 0)
+  end
+
+  # Number of valid codes before scaling-up
+  def num_valid_codes
+    RADIX**num_digits
+  end
+
+  def num_digits_for(id)
+    if id<num_valid_codes
+      num_digits
+    else
+      # ((Math.log(id)/Math.log(RADIX)-code_length)/block_digits).ceil*block_digits + num_digits
+      nd = num_digits
+      loop do
+        nd += block_digits
+        nvc = RADIX**nd
+        break if id<nvc
+      end
+      # check = ((Math.log(id)/Math.log(RADIX)-code_length)/block_digits).ceil*block_digits + num_digits
+      # raise "nd=#{nd}; [#{check}] id=#{id}" unless nd==check
+      nd
+    end
+  end
+
+  def code_length_for(id)
+    num_digits_for(id) + (check_digit? ? 1 : 0)
+  end
+
+  def code_digits
+    @code_digits
+  end
+
+  def parameters
+    { :num_digits=>@num_digits, :block_digits=>@block_digits, :check_digit=>@check_digit, :code_digits=>@code_digits }
+  end
+
+  def inspect
+    "IdCoder[#{parameters.inspect.unwrap('[]')}]"
+  end
+
+  # Code generatioon
+
+  # Direct encoding: generate an Id-Code from an integer id.
+  def id_to_code(id)
+    raise InvalidNumber, "Numbers to be coded must be passed as integers" unless id.kind_of?(Integer)
+    raise InvalidNumber, "Negative numbers cannot be encoded: #{id}" if id<0
+    nd = num_digits_for(id)
+    v = id.to_s(RADIX)
+    v = "0"*(nd-v.size) + v
+    i = 0
+    code = ""
+    mask = 0
+    v.reverse.each_byte do |b|
+      d = DIGITS.index(b.chr)
+      code << @code_digits[mask = ((d+i)%RADIX ^ mask),1]
+      i += 1
+    end
+    code << check_digit(code) if check_digit?
+    code
+  end
+
+  # Inverse encoding: compute the integer id for a Id-Code
+  def code_to_id(code)
+    raise InvalidCode, "Codes must be strings" unless code.kind_of?(String)
+    code = code.strip.upcase # tolerate case differences & surrounding whitespace
+    raise InvalidCode, "Invalid code: #{code}" unless code =~ /\A[#{@code_digits}]+\Z/
+    # raise InvalidCode, "Invalid code length: #{code.size} for #{code} (must be #{code_length})" unless code.size==code_length
+    if check_digit?
+      cd = code[-1,1]
+      code = code[0...-1]
+      raise InvalidCode, "Invalid code: #{code+cd}" if cd!=check_digit(code)
+    end
+    nd = code.size
+    sx = nd-num_digits
+    raise InvalidCode, "Invalid code length: #{code.size} for #{code}" unless sx>=0 && (sx%block_digits)==0
+    i = 0
+    v = ""
+    mask = 0
+    code.each_byte do |b|
+      next_mask = @code_digits.index(b.chr)
+      d  = ((next_mask ^ mask)-i)%RADIX
+      mask = next_mask
+      d = DIGITS[d,1]
+      v = d + v
+      i += 1
+    end
+    v.to_i(RADIX)
+  end
+
+  # Check code: returns true (valid) or false (invalid)
+  def valid_code?(code)
+    is_valid = true
+    begin
+      code_to_id(code)
+    rescue InvalidCode
+      is_valid = false
+    end
+    is_valid
+  end
+
+  private
+
+  # Check digits are computed using the Luhn Mod N Algorithm:
+  # http://en.wikipedia.org/wiki/Luhn_mod_N_algorithm
+  def check_digit(code)
+    factor = 2
+    sum = 0
+    code.each_byte do |b|
+      addend = factor * @code_digits.index(b.chr)
+      factor = (factor==2) ? 1 : 2
+      addend = (addend / RADIX) + (addend % RADIX)
+      sum += addend
+    end
+    remainder = sum % RADIX
+    @code_digits[(RADIX - remainder) % RADIX, 1]
+  end
+
+
+end

data/test/helper.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'id_coder'
+
+class Test::Unit::TestCase
+end

data/test/test_id_coder.rb

@@ -0,0 +1,152 @@
+require 'helper'
+
+class TestIdCoder < Test::Unit::TestCase
+
+  def setup
+    @id_coder = IdCoder[
+      :num_digits => 6,
+      :block_digits => 2,
+      :check_digit => true
+    ]
+  end
+
+  def test_bijectivity
+    # sanity check
+    assert@id_coder.check_digit?
+    assert_equal 6,@id_coder.num_digits
+    assert_equal 2,@id_coder.block_digits
+    assert_equal 7,@id_coder.code_length
+    assert_equal 32, IdCoder::RADIX
+    assert_equal 32**6,@id_coder.num_valid_codes
+
+    # Test numbers within the basic range (num_digits)
+    test_numbers = (0..100).to_a + (99999900..100000020).to_a + [232211,9898774,1002,343332,1023,1024,1025]
+    test_numbers.each do |number|
+      code =@id_coder.id_to_code(number)
+      assert_equal 7, code.size # test also code length here
+      assert_equal number,@id_coder.code_to_id(code),"#{number} is converted to a code and back"
+    end
+
+    # Test larger numbers
+    test_numbers = (1_999_999_990..2_000_000_010).to_a + (1_999_999_999_990..2_000_000_000_010).to_a
+    test_numbers.each do |number|
+      code =@id_coder.id_to_code(number)
+      assert code.size > 7
+      assert(
+        (code.size-(@id_coder.check_digit? ? 1 : 0)-@id_coder.num_digits)%@id_coder.block_digits == 0
+      )
+      assert_equal number,@id_coder.code_to_id(code),"#{number} is converted to a code and back"
+    end
+
+  end
+
+  def test_invalid_numbers
+    # sanity check
+    assert@id_coder.check_digit?
+    assert_equal 6,@id_coder.num_digits
+    assert_equal 2,@id_coder.block_digits
+    assert_equal 7,@id_coder.code_length
+    assert_equal 32, IdCoder::RADIX
+    assert_equal 32**6,@id_coder.num_valid_codes
+    # => ~1000000000 codes
+
+    assert_raise(IdCoder::InvalidNumber){@id_coder.id_to_code("1") }
+    assert_raise(IdCoder::InvalidNumber){@id_coder.id_to_code(-1) }
+    assert_nothing_raised(IdCoder::InvalidNumber){@id_coder.id_to_code(2000000000) }
+    assert_nothing_raised(IdCoder::InvalidNumber){@id_coder.id_to_code(0) }
+    assert_nothing_raised(IdCoder::InvalidNumber){@id_coder.id_to_code(1) }
+    assert_nothing_raised(IdCoder::InvalidNumber){@id_coder.id_to_code(100) }
+    assert_nothing_raised(IdCoder::InvalidNumber){@id_coder.id_to_code(1000000000) }
+    assert_nothing_raised(IdCoder::InvalidNumber){@id_coder.id_to_code(2000000000) }
+    assert_nothing_raised(IdCoder::InvalidNumber){@id_coder.id_to_code(100000000000000000000) }
+  end
+
+  def test_invalid_codes
+    @id_coder = IdCoder[:num_digits=>4, :block_digits=>3, :check_digit=>false]
+    # sanity check
+    assert !@id_coder.check_digit?
+    assert_equal 4,@id_coder.num_digits
+    assert_equal 3,@id_coder.block_digits
+    assert_equal 4,@id_coder.code_length
+    assert_equal 32, IdCoder::RADIX
+    assert_equal 32**4,@id_coder.num_valid_codes
+
+    assert_raise(IdCoder::InvalidCode){@id_coder.code_to_id(1023) }
+    assert_raise(IdCoder::InvalidCode){@id_coder.code_to_id(234) }
+    assert_raise(IdCoder::InvalidCode){@id_coder.code_to_id(2345) }
+    assert_nothing_raised(IdCoder::InvalidCode){@id_coder.code_to_id('2345') }
+    assert_raise(IdCoder::InvalidCode){@id_coder.code_to_id('345') }
+    assert_raise(IdCoder::InvalidCode){@id_coder.code_to_id('34567') }
+    assert_raise(IdCoder::InvalidCode){@id_coder.code_to_id('3415') }
+    assert_raise(IdCoder::InvalidCode){@id_coder.code_to_id('34I5') }
+    assert_raise(IdCoder::InvalidCode){@id_coder.code_to_id('2A04') }
+    assert_raise(IdCoder::InvalidCode){@id_coder.code_to_id('2AO4') }
+    assert_raise(IdCoder::InvalidCode){@id_coder.code_to_id('2A-3') }
+    assert_raise(IdCoder::InvalidCode){@id_coder.code_to_id('2A 3') }
+    assert_raise(IdCoder::InvalidCode){@id_coder.code_to_id('2A)3') }
+    assert_raise(IdCoder::InvalidCode){@id_coder.code_to_id('345678') }
+    assert_nothing_raised(IdCoder::InvalidCode){@id_coder.code_to_id('3456789') }
+    assert_raise(IdCoder::InvalidCode){@id_coder.code_to_id('3456789A') }
+    assert_raise(IdCoder::InvalidCode){@id_coder.code_to_id('3456789AB') }
+    assert_nothing_raised(IdCoder::InvalidCode){@id_coder.code_to_id('3456789ABC') }
+    assert_raise(IdCoder::InvalidCode){@id_coder.code_to_id('3456789ABCD') }
+    assert_nothing_raised(IdCoder::InvalidCode){@id_coder.code_to_id('2A45') }
+    assert_nothing_raised(IdCoder::InvalidCode){@id_coder.code_to_id(' 2A43  ') }
+    assert_nothing_raised(IdCoder::InvalidCode){@id_coder.code_to_id('2a43') }
+  end
+
+  def test_check_digits
+    # sanity check
+    assert@id_coder.check_digit?
+    assert_equal 6,@id_coder.num_digits
+    assert_equal 2,@id_coder.block_digits
+    assert_equal 7,@id_coder.code_length
+    assert_equal 32, IdCoder::RADIX
+    assert_equal 32**6,@id_coder.num_valid_codes
+
+    assert_raise(IdCoder::InvalidCode){@id_coder.code_to_id(1023) }
+    assert_raise(IdCoder::InvalidCode){@id_coder.code_to_id(234) }
+    assert_raise(IdCoder::InvalidCode){@id_coder.code_to_id(2345938) }
+    assert_raise(IdCoder::InvalidCode){@id_coder.code_to_id('2345938') }
+    assert_raise(IdCoder::InvalidCode){@id_coder.code_to_id('345432') }
+    assert_raise(IdCoder::InvalidCode){@id_coder.code_to_id('3454321') }
+    valid_code =@id_coder.id_to_code(234331)
+    assert_equal 7, valid_code.size
+    digits = %w{2 3 4 5 6 7 8 9 A B C D E F G H J K L M N P Q R S T U V W X Y Z}
+    assert_raise(IdCoder::InvalidCode){@id_coder.code_to_id(valid_code[0...-1])}
+    # Check that changing the check digit makes the code invalid
+    digits.each do |digit|
+      next if digit == valid_code[-1,1]
+      assert_raise(IdCoder::InvalidCode){@id_coder.code_to_id(valid_code[0...-1]+digit)}
+    end
+    # Check that any single-digit change makes the code invalid
+    (0..5).each do |i|
+      digits.each do |digit|
+        next if digit == valid_code[i,1]
+        invalid_code = valid_code[0,i] + digit + valid_code[i+1..-1]
+        assert_raise(IdCoder::InvalidCode){@id_coder.code_to_id(invalid_code)}
+      end
+    end
+    # Check that adjacent digit swapping makes the code invalid
+    # (there are some exceptions though, see http://en.wikipedia.org/wiki/Luhn_mod_N_algorithm)
+    # TODO: sistematic check avoiding exceptions
+    invalid_code = valid_code[0,2] + valid_code[3,1] + valid_code[2,1] + valid_code[4..-1]
+    assert_raise(IdCoder::InvalidCode){@id_coder.code_to_id(invalid_code)}
+  end
+
+  def test_internal_sanity
+    # Check the coded digits used: must be exactly IdCoder::RADIX unique uppercase characters
+    chars = []
+    IdCoder::CODE_DIGITS.each_byte{|b| chars << b.chr}
+    assert_equal IdCoder::RADIX, chars.uniq.size
+    assert_equal IdCoder::CODE_DIGITS.upcase, IdCoder::CODE_DIGITS
+
+    # Check the internally-used radix-32 digits to be consistent with Integer#to_s
+    assert_equal IdCoder::RADIX, IdCoder::DIGITS.size
+    (0...IdCoder::RADIX).each do |i|
+      assert_equal i.to_s(IdCoder::RADIX), IdCoder::DIGITS[i,1]
+    end
+  end
+
+
+end

metadata

@@ -0,0 +1,156 @@
+--- !ruby/object:Gem::Specification
+name: id_coder
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Javier Goizueta
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: modalsupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: modalsettings
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.3
+description: Generates relatively short codes to represent id numbers externally
+email: jgoizueta@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- .document
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/id_coder.rb
+- test/helper.rb
+- test/test_id_coder.rb
+homepage: http://github.com/jgoizueta/id_coder
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1112580131298559240
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.21
+signing_key: 
+specification_version: 3
+summary: Alphanumeric code generator
+test_files: []