base_convert 0.0.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dbccf02603e1f029d1acfa79abfff94b93f315c6
-  data.tar.gz: 44227572331e4c2203d3012f32377ea4bde2e573
+  metadata.gz: e38bf64a72b3127b158c244a87a65176db358c21
+  data.tar.gz: 1dc82bdddee617c3fe44e2c125a33b15641a346f
 SHA512:
-  metadata.gz: 07e12a56d9fd457e70417ab65124d4b9fba0c45ecd922ec6ebdf8ec3856da9d10be56f69d11cf364dd3e9aeb4a57d150824cda3d5383df874115af2d4400b4ac
-  data.tar.gz: 89dd3ea459891e0bc478b1f808e680e1b6d761c4b4bfd4e7e7e0e6440f889139de4383e503510fd23ba817eee6bbe7cf42abddf753cf270278773a099fc4fad8
+  metadata.gz: 44c73f5bb7180fbecaaba4cc1936a339019ddbc367a76a30e815cbee9a0ce13d1235e2b86d5bca6e65fc3b3f3c1a1fba7a21e4dcad5eceb806a2b4e14e705e15
+  data.tar.gz: 11c95ca5dd520a33e7c61da20c29c42e8adcb80da99030efcdfeb8d16cc7b63fa972dff21510a1105dbf4eafc911dfcfaf42eaf33569b88f4445c62caf9c2595

data/History.txt

@@ -0,0 +1,3 @@
+0.0.0 September 24, 2011 (5.5 KB) yanked
+0.0.1 September 24, 2011 (5.5 KB) yanked
+0.0.2 February 12, 2014 (6.5 KB)

data/README.rdoc

@@ -0,0 +1,133 @@
+= base_convert
+
+github :: https://www.github.com/carlosjhr64/base_convert
+rubygems :: https://rubygems.org/gems/base_convert
+
+== DESCRIPTION:
+
+base_convert - Number base conversion.
+
+Converts positive integers to different bases:
+Binary, octal, hexadecimal, decimal, or any arbitrary base.
+"Out of the box" handling of up to base 91.
+Allows for arbitrary choice of alphabet(digits).
+
+See also Non-decimal_radices/Convert[http://rosettacode.org/wiki/Non-decimal_radices/Convert].
+
+== SYNOPSIS:
+
+    require 'base_convert'
+    include BASE_CONVERT
+    h2o = BaseConvert.new(16, 8)
+    o2h = BaseConvert.new(8, 16)
+    puts h2o.convert('FFFF') #=> "177777"
+    puts o2h.convert('177777') #=> "FFFF"
+
+== BUT WAIT, THERE'S MORE:
+
+Using `irb` to demonstrate the features.
+The components are scoped under `BASE_CONVERT`:
+
+    # irb
+    # Welcome to IRB...
+    require 'base_convert' #=> true
+    include BASE_CONVERT #=> Object
+
+`base_convert` provides three ways to convert a string representation of a number.
+The first is functional.  One can extend(import) the functions that do the conversions.
+The conversion functions are `to_integer` and `to_base`.
+For example, the octal number "7777":
+
+    extend FUNCTIONS #=> main
+    digits = ['0','1','2','3','4','5','6','7']
+    base = digits.length #=> 8
+    to_integer('7777', base, digits) #=> 4095
+    to_base(4095, base, digits) #=> "7777"
+
+You can work with arbitrary digits:
+
+    digits = [')','!','@','#','$','%','^','&']
+    base = digits.length #=> 8
+    to_integer('&&&&', base, digits) #=> 4095
+    to_base(4095, base, digits) #=> "&&&&"
+
+For convenience, `base_convert` provides two sets of digits.
+`WORD` are the ASCII word characters except underscore[_].
+`QGRAPH` are the ASCII graph characters except quotes['"].
+
+    CONFIG::WORD #=> ["0","1",... "A","B",... "a","b",... "y","z"]
+    CONFIG::QGRAPH #=> ["!", "#",... "0","1",... "A","B",... "a","b",...  "}", "~"]
+    to_base(4095, 8, CONFIG::WORD) #=> "7777"
+    to_base(4095, 8, CONFIG::QGRAPH) #=> "****"
+
+The second way to convert is via a conversion object of `BASE_CONVERT::BaseConvert`.
+For example, to convert from hexadecimal to octal, and back:
+
+    h2o = BaseConvert.new(16, 8)
+    o2h = BaseConvert.new(8, 16)
+    h2o.convert('FFFF') #=> "177777"
+    o2h.convert('177777') #=> "FFFF"
+
+You can access the conversion alphabets via
+the accessors BaseConvert#from_digits and BaseConvert#to_digits.
+By default, WORD is used for bases upto 62.
+For bigger bases upto 91, QGRAPH is used.
+You can have bigger bases, but
+you will need to come up with a bigger alphabet, perhaps
+by adding greek letters.
+Note that when there's no ambiguity while using WORD,
+BaseConvert will upcase the string.
+
+    h2o.convert('FFFF') #=> "177777"
+    h2o.convert('ffff') #=> "177777"
+
+BaseConvert also make avalable the  intermediary methods that works with integers,
+BaseConvert#base2integer and BaseConvert#integer2Base:
+
+    h2o.base2integer('FFFF') #=> 65535
+    h2o.integer2base(65535) #=> "177777"
+
+The above replaces #base2dec and #dec2base which are now aliases and are deprecated.
+The third way to convert is via the subclass of String, `BASE_CONVERT::Number`:
+
+    hexadecimal = Number.new('FFFF', 16, CONFIG::WORD) #=> "FFFF"
+    # WORD is the default alphabet
+    hexadecimal = Number.new('FFFF', 16) #=> "FFFF"
+    hexadecimal.to_integer #=> 65535
+    # Base 10 the default
+    decimal = Number.new('65535') # "65535"
+    decimal.to_integer #=> 65535
+    decimal.to_base(16) #=> "FFFF"
+    decimal.to_base(8) #=> "177777"
+    # You can also specify the digits to use
+    digits = [')','!','@','#','$','%','^','&']
+    decimal.to_base(8, digits) #=> "!&&&&&"
+
+== INSTALL:
+
+  $ sudo gem install base_convert
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2014 CarlosJHR64
+
+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/TODO.txt

@@ -0,0 +1,3 @@
+== File List
+
+

data/base_convert.gemspec

@@ -0,0 +1,55 @@
+Gem::Specification.new do |s|
+
+  s.name     = 'base_convert'
+  s.version  = '1.0.0'
+
+  s.homepage = 'https://github.com/carlosjhr64/base_convert'
+
+  s.author   = 'CarlosJHR64'
+  s.email    = 'carlosjhr64@gmail.com'
+
+  s.date     = '2014-02-13'
+  s.licenses = ['MIT']
+
+  s.description = <<DESCRIPTION
+base_convert - Number base conversion.
+
+Converts positive integers to different bases:
+Binary, octal, hexadecimal, decimal, or any arbitrary base.
+"Out of the box" handling of up to base 91.
+Allows for arbitrary choice of alphabet(digits).
+DESCRIPTION
+
+  s.summary = <<SUMMARY
+base_convert - Number base conversion.
+SUMMARY
+
+  s.extra_rdoc_files = ['README.rdoc']
+  s.rdoc_options     = ["--main", "README.rdoc"]
+
+  s.require_paths = ["lib"]
+  s.files = %w(
+History.txt
+README.rdoc
+TODO.txt
+base_convert.gemspec
+lib/base_convert.rb
+lib/base_convert/base_convert.rb
+lib/base_convert/config.rb
+lib/base_convert/functions.rb
+lib/base_convert/helpers.rb
+lib/base_convert/number.rb
+lib/base_convert/version.rb
+test/test_base_convert.rb
+test/test_functions.rb
+test/test_helpers.rb
+test/test_number.rb
+test/test_original.rb
+test/test_original2.rb
+test/test_trivial.rb
+  )
+
+  s.add_development_dependency 'test-unit', '~> 2.5', '>= 2.5.5'
+  s.requirements << 'ruby: ruby 2.1.0p0 (2013-12-25 revision 44422) [x86_64-linux]'
+
+end

data/lib/base_convert.rb

@@ -1,58 +1,7 @@
-# http://rosettacode.org/wiki/Non-decimal_radices/Convert#Ruby
-class BaseConvert
-  DIGITS = 0.upto(255).map{|i| i.chr}.select{|c| c=~/\w/ && c=~/[^_]/} # 0..9 a..z A..Z
-  QGRAPH = 0.upto(255).map{|i| i.chr}.select{|c| c=~/[[:graph:]]/ && c=~/[^`'"]/}
-
-  BASE = {
-	:word		=> DIGITS.length,
-	:qgraph		=> QGRAPH.length,
-	:hexadecimal	=> 16,
-	:hex		=> 16,
-	:decimal	=> 10,
-	:dec		=> 10,
-	:octal		=> 8,
-	:oct		=> 8,
-	:binary		=> 2,
-  }
-
-  attr_accessor :from_digits, :to_digits
-  def initialize(basefrom,baseto=nil)
-    baseto = basefrom if baseto.nil?
-    @basefrom		= BASE[basefrom]	|| basefrom
-    @baseto		= BASE[baseto]		|| baseto
-    dl = DIGITS.length
-    @from_digits	= ((basefrom == :qgraph) || (@basefrom > dl))? QGRAPH : DIGITS
-    @to_digits		= ((baseto   == :qgraph) || (@baseto > dl))? QGRAPH : DIGITS
-  end
-
-  def convert(str)
-    if str.class == String
-      dec = base2dec(str)
-      return (@baseto == @basefrom)? dec : dec2base(dec)
-    end
-    dec2base(str)
-  end
- 
-  def base2dec(str)
-    str = str.upcase if @basefrom < 37
-    raise ArgumentError, "base is invalid" unless @basefrom.between?(2, @from_digits.length)
-    res = 0
-    str.to_s.each_char do |c|
-      idx = @from_digits[0,@basefrom].find_index(c)
-      idx.nil? and raise ArgumentError, "invalid base-#{@basefrom} digit: #{c}"
-      res = res * @basefrom + idx
-    end
-    res
-  end
- 
-  def dec2base(n)
-    return @to_digits.first if n == 0
-    raise ArgumentError, "base is invalid" unless @baseto.between?(2, @to_digits.length)
-    res = []
-    while n > 0
-      n, r = n.divmod(@baseto)
-      res.unshift(@to_digits[r])
-    end
-    res.join("") 
-  end
-end
+require 'base_convert/version'
+require 'base_convert/config'
+require 'base_convert/functions'
+require 'base_convert/helpers'
+require 'base_convert/number'
+require 'base_convert/base_convert'
+#`ruby`

data/lib/base_convert/base_convert.rb

@@ -0,0 +1,35 @@
+module BASE_CONVERT
+class BaseConvert
+  include CONFIG
+  extend FUNCTIONS
+  extend HELPERS
+
+  attr_accessor :from_digits, :to_digits
+  def initialize(basefrom, baseto=basefrom)
+    @basefrom    = BaseConvert.base(basefrom)
+    @baseto      = BaseConvert.base(baseto)
+    @from_digits = BaseConvert.digits(basefrom)
+    @to_digits   = BaseConvert.digits(baseto)
+
+    BaseConvert.validate(@baseto, @to_digits)
+    BaseConvert.validate(@basefrom, @from_digits)
+  end
+ 
+  def base2integer(string)
+    string = string.upcase if BaseConvert.upcase?(@basefrom, @from_digits) # covenience
+    BaseConvert.validate_string(string, @basefrom, @from_digits)
+    BaseConvert.to_integer(string, @basefrom, @from_digits)
+  end
+  alias base2dec base2integer 
+ 
+  def integer2base(integer)
+    BaseConvert.to_base(integer, @baseto, @to_digits)
+  end
+  alias dec2base integer2base
+
+  def convert(string)
+    integer2base base2integer string.to_s
+  end
+
+end
+end

data/lib/base_convert/config.rb

@@ -0,0 +1,27 @@
+module BASE_CONVERT
+module CONFIG
+
+  QGRAPH = 0.upto(255).map{|i| i.chr}.select{|c| c=~/[[:graph:]]/ && c=~/[^`'"]/}
+
+  WORD   = 0.upto(255).map{|i| i.chr}.select{|c| c=~/\w/ && c=~/[^_]/} # 0..9 a..z A..Z
+  INDEXa = WORD.find_index('a')
+
+  BASE = {
+    :word        => WORD.length,
+    :qgraph      => QGRAPH.length,
+    :hexadecimal => 16,
+    :hex         => 16,
+    :decimal     => 10,
+    :dec         => 10,
+    :octal       => 8,
+    :oct         => 8,
+    :binary      => 2,
+  }
+
+  DIGITS = {
+    :word   => WORD,
+    :qgraph => QGRAPH,
+  }
+
+end
+end

data/lib/base_convert/functions.rb

@@ -0,0 +1,25 @@
+# http://rosettacode.org/wiki/Non-decimal_radices/Convert#Ruby
+module BASE_CONVERT
+module FUNCTIONS
+
+  def to_integer(string, base, digits)
+    integer = 0
+    string.each_char do |c|
+      index = digits.find_index(c)
+      integer = integer * base + index
+    end
+    integer
+  end
+
+  def to_base(integer, base, digits)
+    return digits.first if integer == 0
+    string = ''
+    while integer > 0
+      integer, index = integer.divmod(base)
+      string = string.insert(0, digits[index])
+    end
+    string
+  end
+
+end
+end

data/lib/base_convert/helpers.rb

@@ -0,0 +1,37 @@
+# http://rosettacode.org/wiki/Non-decimal_radices/Convert#Ruby
+module BASE_CONVERT
+module HELPERS
+  include CONFIG
+
+  def upcase?(base, digits)
+    base <= INDEXa and digits.equal?(WORD)
+  end
+
+  def validate(base, digits)
+    raise 'base is not an integer' unless base.kind_of?(Integer)
+    raise 'digits not an Array'    unless digits.kind_of?(Array)
+    raise 'base not between 2 and digits.length' unless base.between?(2, digits.length)
+  end
+
+  def validate_string(string, base, digits)
+    string.chars.uniq.each do |c|
+      raise 'String has invalid character' unless (i=digits.find_index(c)) and (i<base)
+    end
+  end
+
+  def digits(base)
+    if base.class == Symbol
+      if digits = DIGITS[base]
+        return digits
+      end
+      base = BASE[base]
+    end
+    (base > WORD.length)? QGRAPH : WORD
+  end
+
+  def base(base)
+    (base.class == Symbol)? BASE[base]: base
+  end
+
+end
+end

data/lib/base_convert/number.rb

@@ -0,0 +1,31 @@
+module BASE_CONVERT
+class Number < String
+  include CONFIG
+  extend FUNCTIONS
+  extend HELPERS
+
+  def initialize(counter, base=10, digits=Number.digits(base), validate=true)
+    super(counter.to_s)
+    @base   = Number.base(base)
+    @digits = digits
+    if validate
+      self.upcase! if Number.upcase?(@base, @digits)
+      Number.validate(@base, @digits)
+      Number.validate_string(self, @base, @digits)
+    end
+  end
+
+  def to_integer
+    Number.to_integer(self, @base, @digits)
+  end
+
+  def to_base(base, digits=Number.digits(base), validate=true)
+    base   = Number.base(base)
+    Number.validate(base, digits) if validate
+    integer = self.to_integer
+    string = Number.to_base(integer, base, digits)
+    Number.new(string, base, digits, false) # no need to validate
+  end
+
+end
+end

data/lib/base_convert/version.rb

@@ -0,0 +1,3 @@
+module BASE_CONVERT
+  VERSION = '1.0.0'
+end

data/test/test_base_convert.rb

@@ -0,0 +1,56 @@
+require 'test/unit'
+require 'base_convert'
+
+class TestBaseConvert < Test::Unit::TestCase
+  include BASE_CONVERT
+  include CONFIG
+
+  def test_001_new
+    wl = WORD.length
+
+    base = BaseConvert.new(10, 16)
+    assert base.from_digits.equal?(WORD)
+    assert base.to_digits.equal?(WORD)
+
+    base = BaseConvert.new(70, 8)
+    assert base.from_digits.equal?(QGRAPH)
+    assert base.to_digits.equal?(WORD)
+
+    base = BaseConvert.new(wl, 90)
+    assert base.from_digits.equal?(WORD)
+    assert base.to_digits.equal?(QGRAPH)
+
+    base = BaseConvert.new(wl+1, wl+2)
+    assert base.from_digits.equal?(QGRAPH)
+    assert base.to_digits.equal?(QGRAPH)
+
+    base = BaseConvert.new(:word, :qgraph)
+    assert base.from_digits.equal?(WORD)
+    assert base.to_digits.equal?(QGRAPH)
+
+    base = BaseConvert.new(:qgraph, :word)
+    assert base.from_digits.equal?(QGRAPH)
+    assert base.to_digits.equal?(WORD)
+
+    a = base.base2integer('z')
+    assert_equal(Fixnum, a.class)
+    assert_equal(86, a)
+
+    a = base.integer2base(16)
+    assert_equal(String, a.class)
+    assert_equal('G', a)
+
+    a = base.convert('z')
+    assert_equal(String, a.class)
+    base = BaseConvert.new(:word, :qgraph)
+    a = base.convert(a)
+    assert_equal('z', a)
+
+    base = BaseConvert.new(:hex, :oct)
+    assert_equal('7777', base.convert('FFF'))
+    assert_equal('7777', base.convert('fff')) # Tests the upcase convenience
+
+    base = BaseConvert.new(:oct, :hex)
+    assert_equal('FFF', base.convert('7777'))
+  end
+end

data/test/test_functions.rb

@@ -0,0 +1,34 @@
+require 'test/unit'
+require 'base_convert/config'
+require 'base_convert/functions'
+
+class TestFunctions < Test::Unit::TestCase
+  include BASE_CONVERT
+  include CONFIG
+  extend  FUNCTIONS
+
+  HEX  = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f']
+
+  def test_001_to_integer
+    a = TestFunctions.to_integer('0', 16, HEX)
+    assert_equal(0, a)
+    a = TestFunctions.to_integer('a', 16, HEX)
+    assert_equal(10, a)
+    a = TestFunctions.to_integer('f', 16, HEX)
+    assert_equal(15, a)
+    a = TestFunctions.to_integer('abcdef', 16, HEX)
+    assert_equal(11259375, a)
+  end
+
+  def test_002_to_base
+    a = TestFunctions.to_base(0, 16, WORD)
+    assert_equal('0', a)
+    a = TestFunctions.to_base(10, 16, WORD)
+    assert_equal('A', a)
+    a = TestFunctions.to_base(15, 16, WORD)
+    assert_equal('F', a)
+    a = TestFunctions.to_base(11259375, 16, WORD)
+    assert_equal('ABCDEF', a)
+  end
+
+end

data/test/test_helpers.rb

@@ -0,0 +1,99 @@
+require 'test/unit'
+require 'base_convert/config'
+require 'base_convert/helpers'
+
+class TestHelpers < Test::Unit::TestCase
+  include BASE_CONVERT
+  include CONFIG
+  extend  HELPERS
+
+  HEX  = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f']
+
+  def test_003_upcase
+    assert(TestHelpers.upcase?(36, WORD))
+    refute(TestHelpers.upcase?(36, HEX))
+    refute(TestHelpers.upcase?(37, WORD))
+  end
+
+  def test_004_validate
+    assert_raises(RuntimeError){ TestHelpers.validate(5.0, WORD) }
+    assert_nothing_raised(Exception){ TestHelpers.validate(5, WORD) }
+
+    assert_raises(RuntimeError){ TestHelpers.validate(5, '0123456789abdef') }
+    assert_nothing_raised(Exception){ TestHelpers.validate(5, ['0', '1', '2', '3', '4']) }
+
+    assert_raises(RuntimeError){ TestHelpers.validate(5, ['0', '1', '2', '3']) }
+    assert_nothing_raised(Exception){ TestHelpers.validate(5, ['0', '1', '2', '3', '4', '5', '6']) }
+
+    assert_raises(RuntimeError){ TestHelpers.validate(1, ['0', '1']) }
+    assert_nothing_raised(Exception){ TestHelpers.validate(2, ['0', '1']) }
+  end
+
+  def test_005_validate_string
+    assert_raises(RuntimeError){ TestHelpers.validate_string('xyz', 3, ['a','b','c']) }
+    assert_nothing_raised(Exception){ TestHelpers.validate_string('xyz', 3, ['x','y','z']) }
+    assert_nothing_raised(Exception){ TestHelpers.validate_string('xyz', 3, ['x','y','z','a','b','c']) }
+    assert_raises(RuntimeError){ TestHelpers.validate_string('abc', 3, ['x','y','z','a','b','c']) }
+    assert_nothing_raised(Exception){ TestHelpers.validate_string('abc', 6, ['x','y','z','a','b','c']) }
+  end
+
+  def test_006_digits
+    wl = WORD.length
+
+    a = TestHelpers.digits(wl)
+    assert(a.equal?(WORD))
+
+    a = TestHelpers.digits(wl+1)
+    assert(a.equal?(QGRAPH))
+
+    a = TestHelpers.digits(:word)
+    assert(a.equal?(WORD))
+
+    a = TestHelpers.digits(:qgraph)
+    assert(a.equal?(QGRAPH))
+
+    a = TestHelpers.digits(:hex)
+    assert(a.equal?(WORD))
+
+    DIGITS[:my_digits] = ['X','Y','Z']
+    a = TestHelpers.digits(:my_digits)
+    assert(a.equal?(DIGITS[:my_digits]))
+
+    BASE[:my_base] = wl
+    a = TestHelpers.digits(:my_base)
+    assert(a.equal?(WORD))
+
+    BASE[:my_base] = wl+1
+    a = TestHelpers.digits(:my_base)
+    assert(a.equal?(QGRAPH))
+  end
+
+  def test_007_base
+    wl = WORD.length
+    ql = QGRAPH.length
+
+    a = TestHelpers.base(:word)
+    assert_equal(wl, a)
+
+    a = TestHelpers.base(:qgraph)
+    assert_equal(ql, a)
+
+    a = TestHelpers.base(:hex)
+    assert_equal(16, a)
+    a = TestHelpers.base(:hexadecimal)
+    assert_equal(16, a)
+
+    a = TestHelpers.base(:decimal)
+    assert_equal(10, a)
+    a = TestHelpers.base(:dec)
+    assert_equal(10, a)
+
+    a = TestHelpers.base(:octal)
+    assert_equal(8, a)
+    a = TestHelpers.base(:oct)
+    assert_equal(8, a)
+
+    a = TestHelpers.base(:binary)
+    assert_equal(2, a)
+  end
+end

data/test/test_number.rb

@@ -0,0 +1,21 @@
+require 'test/unit'
+require 'base_convert'
+
+class TestNumber < Test::Unit::TestCase
+  include BASE_CONVERT
+  include CONFIG
+
+  def test_001_new
+    a = Number.new(100)
+    assert_equal '100', a
+    a = Number.new('100')
+    assert_equal '100', a
+    assert_equal 100, a.to_integer
+
+    assert_raises(RuntimeError){ Number.new('FFF') }
+    a = Number.new('FFF', 16)
+    assert_equal 'FFF', a
+    assert_equal '7777', a.to_base(8)
+    assert_equal 'FFF', a.to_base(8).to_base(16)
+  end
+end

data/test/test_original.rb

@@ -0,0 +1,47 @@
+require 'test/unit'
+require 'base_convert'
+require 'digest'
+
+class TestOriginal < Test::Unit::TestCase
+  include BASE_CONVERT
+
+  def test_001_to_s_n
+    # test against number.to_s(n)
+    2.upto(36) do |n|
+      # Converts to base n.
+      base = BaseConvert.new(n)
+      100.times do
+        number = rand(10000)
+        string = number.to_s(n)
+        # BaseConvert uses caps
+        assert_equal(string.upcase, base.integer2base(number))
+        # and it will automatically upcase
+        assert_equal(number, base.base2integer(string))
+      end
+    end
+  end
+
+  def test_002_hello_world
+    hexdigest = Digest::SHA256.hexdigest('Hello World!') # and verified below
+    assert_equal '7f83b1657ff1fc53b92dc18148a1d65dfc2d4b1fa3d677284addd200126d9069', hexdigest
+
+    word = BaseConvert.new(:hex, :word).convert(hexdigest)
+    assert_equal 'UEjKBW7lvEq1KjyCxAYQRJqmvffQEbwLNvzs8Ggdy4P', word
+
+    assert_equal hexdigest.upcase, BaseConvert.new(:word, :hex).convert(word)
+
+    qstring = '$<c6PCX_mugC58xfO5JOp+V4|<jHekI^_WE$?d?9'
+    assert_equal qstring, BaseConvert.new(:hex, :qgraph).convert(hexdigest)
+    assert_equal hexdigest.upcase, BaseConvert.new(:qgraph, :hex).convert(qstring)
+  end
+
+  def test_003_hundred_million
+    assert_equal '6laZE', BaseConvert.new(10, 62).convert( 100_000_000 )
+    assert_equal ')8]3H', BaseConvert.new(63).integer2base( 100_000_000 )
+
+    base = BaseConvert.new(62)
+    base.to_digits = BaseConvert::QGRAPH
+    assert_equal ')RGF1', base.integer2base( 100_000_000 )
+  end
+
+end

data/test/test_original2.rb

@@ -0,0 +1,66 @@
+require 'test/unit'
+require 'base_convert'
+require 'digest'
+
+# Using my original tests on BASE_CONVERT::Number
+class TestOriginal2 < Test::Unit::TestCase
+  include BASE_CONVERT
+
+  def test_001_to_s_n
+    # test against number.to_s(base)
+    2.upto(36) do |base|
+      100.times do
+        decimal  = rand(10000)
+
+        decimal0 = decimal.to_s
+        decimal1 = Number.new(decimal)
+        assert_equal(decimal0, decimal1)
+
+        base0 = decimal.to_s(base)
+        base1 = decimal1.to_base(base)
+
+        # BaseConvert uses caps
+        assert_equal(base0.upcase, base1)
+        assert_equal(decimal1, base1.to_base(10))
+        # and it will automatically upcase
+        assert_equal(decimal1, Number.new(base0, base).to_base(10))
+      end
+    end
+  end
+
+  def test_002_hello_world
+    hexdigest = Number.new(Digest::SHA256.hexdigest('Hello World!'), :hex)
+    # and verified below (BaseConvert uses uppecase for hexadeximals.
+    assert_equal '7f83b1657ff1fc53b92dc18148a1d65dfc2d4b1fa3d677284addd200126d9069'.upcase, hexdigest
+
+    #word = BaseConvert.new(:hex, :word).convert(hexdigest)
+    word = hexdigest.to_base(:word)
+    assert_equal 'UEjKBW7lvEq1KjyCxAYQRJqmvffQEbwLNvzs8Ggdy4P', word
+
+    #assert_equal hexdigest.upcase, BaseConvert.new(:word, :hex).convert(word)
+    assert_equal hexdigest, word.to_base(:hex)
+
+    qstring = Number.new('$<c6PCX_mugC58xfO5JOp+V4|<jHekI^_WE$?d?9', :qgraph)
+    # and verified below
+    assert_equal '$<c6PCX_mugC58xfO5JOp+V4|<jHekI^_WE$?d?9', qstring
+    #assert_equal qstring, BaseConvert.new(:hex, :qgraph).convert(hexdigest)
+    assert_equal qstring, hexdigest.to_base(:qgraph)
+
+    assert_equal hexdigest, qstring.to_base(:hex)
+  end
+
+  def test_003_hundred_million
+    hudred_million = Number.new(100_000_000)
+    assert_equal '100000000', hudred_million
+    #assert_equal '6laZE', BaseConvert.new(10, 62).convert( 100_000_000 )
+    assert_equal '6laZE', hudred_million.to_base(62)
+    #assert_equal ')8]3H', BaseConvert.new(63).integer2base( 100_000_000 )
+    assert_equal ')8]3H', hudred_million.to_base(63)
+
+    #base = BaseConvert.new(62)
+    #base.to_digits = BaseConvert::QGRAPH
+    #assert_equal ')RGF1', base.integer2base( 100_000_000 )
+    assert_equal ')RGF1', hudred_million.to_base(62, BaseConvert::QGRAPH)
+  end
+
+end

data/test/test_trivial.rb

@@ -0,0 +1,48 @@
+require 'test/unit'
+require 'base_convert'
+
+class TestTrivial < Test::Unit::TestCase
+
+  def test_001_version
+    assert_not_nil BASE_CONVERT::VERSION=~/^\d+\.\d+\.\d+$/
+  end
+
+  def test_002_qgraph
+    a = BASE_CONVERT::CONFIG::QGRAPH
+    assert_equal(91, a.length)
+    refute(a.include?('"'))
+    refute(a.include?("'"))
+    assert_equal('!', a.first)
+  end
+
+  def test_003_word
+    a = BASE_CONVERT::CONFIG::WORD
+    assert_equal(62, a.length)
+    refute(a.include?('_'))
+    assert_equal('0', a.first)
+    assert_equal(36, BASE_CONVERT::CONFIG::INDEXa)
+    assert_equal('a', a[36])
+  end
+
+  def test_004_base
+    a = BASE_CONVERT::CONFIG::BASE
+    assert_equal(Hash, a.class)
+    assert_equal(62, a[:word])
+    assert_equal(91, a[:qgraph])
+    assert_equal(16, a[:hex])
+    assert_equal(16, a[:hexadecimal])
+    assert_equal(10, a[:decimal])
+    assert_equal(10, a[:dec])
+    assert_equal(8,  a[:octal])
+    assert_equal(8,  a[:oct])
+    assert_equal(2,  a[:binary])
+  end
+
+  def test_005_digits
+    a = BASE_CONVERT::CONFIG::DIGITS
+    assert_equal(Hash, a.class)
+    assert(a[:word].equal?(BASE_CONVERT::CONFIG::WORD))
+    assert(a[:qgraph].equal?(BASE_CONVERT::CONFIG::QGRAPH))
+  end
+
+end

metadata

@@ -1,29 +1,74 @@
 --- !ruby/object:Gem::Specification
 name: base_convert
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 1.0.0
 platform: ruby
 authors:
-- carlosjhr64@gmail.com
+- CarlosJHR64
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-12 00:00:00.000000000 Z
-dependencies: []
-description: Got the code originally from http://rosettacode.org/wiki/Non-decimal_radices/Convert#Ruby
-  which I then converted to a class.
+date: 2014-02-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.5.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.5.5
+description: |
+  base_convert - Number base conversion.
+
+  Converts positive integers to different bases:
+  Binary, octal, hexadecimal, decimal, or any arbitrary base.
+  "Out of the box" handling of up to base 91.
+  Allows for arbitrary choice of alphabet(digits).
 email: carlosjhr64@gmail.com
 executables: []
 extensions: []
-extra_rdoc_files: []
+extra_rdoc_files:
+- README.rdoc
 files:
-- "./README.txt"
-- "./lib/base_convert.rb"
+- History.txt
+- README.rdoc
+- TODO.txt
+- base_convert.gemspec
+- lib/base_convert.rb
+- lib/base_convert/base_convert.rb
+- lib/base_convert/config.rb
+- lib/base_convert/functions.rb
+- lib/base_convert/helpers.rb
+- lib/base_convert/number.rb
+- lib/base_convert/version.rb
+- test/test_base_convert.rb
+- test/test_functions.rb
+- test/test_helpers.rb
+- test/test_number.rb
+- test/test_original.rb
+- test/test_original2.rb
+- test/test_trivial.rb
 homepage: https://github.com/carlosjhr64/base_convert
-licenses: []
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
-rdoc_options: []
+rdoc_options:
+- "--main"
+- README.rdoc
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
@@ -36,10 +81,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-requirements: []
+requirements:
+- 'ruby: ruby 2.1.0p0 (2013-12-25 revision 44422) [x86_64-linux]'
 rubyforge_project: 
 rubygems_version: 2.2.0
 signing_key: 
 specification_version: 4
-summary: BaseConvert
+summary: base_convert - Number base conversion.
 test_files: []

data/README.txt

@@ -1,84 +0,0 @@
-# BaseConvert
-# DESCRIPTION:
-# Got the code originally from
-#	http://rosettacode.org/wiki/Non-decimal_radices/Convert#Ruby
-# which I then converted to a class.
-# SINOPSIS:
-
-def ok(a,b)
-  raise "bad! /#{a}/ == /#{b}/" unless a == b
-end
-
-# ruby -I ./lib README.txt
-if RUBY_VERSION =~ /^1.9.2/ then
-  require 'base_convert'
-
-  # Verify it works up to base 36 with number.to_s(n)
-  2.upto(36) do |n|
-    base = BaseConvert.new(n)
-    100.times do
-      number = rand(10000)
-      string = number.to_s(n)
-      ok( base.convert(string), number  )
-      ok( base.convert(number), string.upcase  ) # BaseConvert uses caps
-    end
-  end
-
-  # BaseConvert is case insensitive up to base 36, but
-  # returns string values with capital leters.  
-  # At base 37 and up, it's case sensitive with lower case letter being of higher order.
-  # It primary use is to reduce digest strings.
-  # For example:
-  require 'digest'
-  # This hexadecimal:
-  ok(	"7f83b1657ff1fc53b92dc18148a1d65dfc2d4b1fa3d677284addd200126d9069",
-	hexdigest = Digest::SHA256.hexdigest('Hello World!') )
-  # Translatates to this word(\w except '_') string
-  ok(	string = 'UEjKBW7lvEq1KjyCxAYQRJqmvffQEbwLNvzs8Ggdy4P',
-	BaseConvert.new(:hexadecimal,:word).convert(hexdigest) )
-  # and we can covert it back:
-  ok(	BaseConvert.new(:word,:hexadecimal).convert(string),
-	hexdigest.upcase )
-  # Again, note the BaseConvert returns the hexdigest string capitalized.
-  #There is also a quotable string([[:graph:]] except [`'"]):
-  ok(	qstring = '$<c6PCX_mugC58xfO5JOp+V4|<jHekI^_WE$?d?9',
-	BaseConvert.new(:hexadecimal,:qgraph).convert(hexdigest))
-  # And you can convert it back
-  ok(	BaseConvert.new(:qgraph,:hexadecimal).convert(qstring),
-	hexdigest.upcase)
-  # Note the length
-  ok(	64, hexdigest.length)
-  ok(	43, string.length)
-  ok(	40, qstring.length)
-
-  # BaseConvert has the following primary form:
-  #	# converting from basefrom to baseto
-  #	base = BaseConvert.new( basefrom, baseto )
-  #	# covert basefrom_string in basefrom to baseto_string in baseto
-  #	baseto_string = base.convert( basefrom_string )
-  #	# convert basefrom_string to it's decimal number representation
-  #	decimal_number = base.base2dec( basefrom_string )
-  #	# convert a decimal_number to it's baseto string representation
-  #	baseto_string = base.dec2base( decimal_number )
-  # BaseConvert has the following heuristic forms:
-  #	# converting to and from _base_
-  #	base = BaseConvert.new( _base_ )
-  #	base_string = base.convert( decimal_number )
-  #	decimal_number = base.convert( base_string )
-  # BaseConvert has the following mneumonic keys that can be use for base:
-  #	:binary	=> 2
-  #	:oct,:octal => 8,
-  #	:dec,:decimal => 10,
-  #	:hex,:hexadecimal => 16
-  # BaseConvert's base can go up to 62 with :word(\w except '_') and 91 with :qgraph([:graph] except [`'"].
-  # By default, :word is used...
-  ok(	'6laZE', BaseConvert.new(62).convert( 100_000_000 ))
-  # ...until a transition to :qgraph is required.
-  ok(	')8]3H', BaseConvert.new(63).convert( 100_000_000 ))
-  # But you can specify the digit dictionary. At this point you've read and know the code...
-  base = BaseConvert.new(62)
-  base.to_digits = BaseConvert::QGRAPH
-  ok(	')RGF1', base.convert( 100_000_000 ))
-end
-# The End.
-# <i>carlosjhr64</i>@<i>gmail<i/>.<i>com</i>