base32-alphabets 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 172119bb357b29e94a3d86c76da19e2351f38339
-  data.tar.gz: 68d93fd3b370c85e7a81255f4824310693039ff9
+  metadata.gz: 94a33c87036d36e7280aae81da210d4155b20b54
+  data.tar.gz: 6b1c22db5cb74881d9948cc23269c67678f9946b
 SHA512:
-  metadata.gz: 06504a90143c2c945641fa15aaea86f547efc7d8fe5d6db677963132d4e890b6b8377c7dd91fc3b4f66583593a3fabe38295d95c423085b215cc9861c9201c3a
-  data.tar.gz: 106070cdcbb6a18f038059d6a2838ac00f29ebf4ef8e7a96ff577e66cd883fb4a4ce11260b5001c50e1b6ecd717e0f6837db428e3c9e7a3747f17ecdb733c2e7
+  metadata.gz: 0c98cf85b86052006d7928c5c271f03d30a24e55f90eabd73302d712536088ad39101e6b4b9352ac09be447ee1bebdae91d520b8237b727c4799a1d5507eb16f
+  data.tar.gz: 697155fa0c6bf2c12b04021959e224970f12200ef3baaa545d199126ff028e536a7a0c9b2e771532ec328ffbb92fd317ef8c3c6ec86bc30830096e3f484a7f87

data/Manifest.txt

@@ -1,4 +1,4 @@
-HISTORY.md
+CHANGELOG.md
 LICENSE.md
 Manifest.txt
 README.md
@@ -11,5 +11,7 @@ lib/base32-alphabets/electrologica.rb
 lib/base32-alphabets/kai.rb
 lib/base32-alphabets/version.rb
 test/helper.rb
-test/test_base32.rb
 test/test_base32_crockford.rb
+test/test_base32_electrologica.rb
+test/test_base32_kai.rb
+test/test_bytes.rb

data/README.md

@@ -66,6 +66,8 @@ pp str == str2
 # => true
 pp Kai.fmt( str2 )
 # => "aaaa 7885 22f2 agff 1661 7755 e979 2441 6667 7664 a9aa cfff"
+pp Kai.fmt( hex )   # all-in-one "shortcut" for Kai.fmt( Kai.encode( hex ))
+# => "aaaa 7885 22f2 agff 1661 7755 e979 2441 6667 7664 a9aa cfff"
 
 hex2 = Kai.decode( str2 )   ## text to (binary) number
 pp hex
@@ -74,6 +76,11 @@ pp hex2
 # => 512955438081049600613224346938352058409509756310147795204209859701881294
 pp hex == hex2
 # => true
+
+pp = Kai.bytes( hex )
+# => [9,9,9,9,6,7,7,4,1,1,14,1,9,15,14,14,0,5,5,0,6,6,4,4,13,8,6,8,1,3,3,0,5,5,5,6,6,5,5,3,9,8,9,9,11,14,14,14]
+pp = Kai.bytes( str )  # or from a kai string (auto-decodes to hex first)
+# => [9,9,9,9,6,7,7,4,1,1,14,1,9,15,14,14,0,5,5,0,6,6,4,4,13,8,6,8,1,3,3,0,5,5,5,6,6,5,5,3,9,8,9,9,11,14,14,14]
 ```
 
 or
@@ -87,8 +94,14 @@ pp str
 # => "aaaa788522f2agff16617755e979244166677664a9aacfff"
 pp Base32.fmt( str )
 # => "aaaa 7885 22f2 agff 1661 7755 e979 2441 6667 7664 a9aa cfff"
+pp Base32.fmt( hex )  # all-in-one "shortcut" for Base32.fmt( Base32.encode( hex ))
+# => "aaaa 7885 22f2 agff 1661 7755 e979 2441 6667 7664 a9aa cfff"
 pp = Base32.decode( str )   ## text to (binary) number
 # => 512955438081049600613224346938352058409509756310147795204209859701881294
+pp = Base32.bytes( hex )
+# => [9,9,9,9,6,7,7,4,1,1,14,1,9,15,14,14,0,5,5,0,6,6,4,4,13,8,6,8,1,3,3,0,5,5,5,6,6,5,5,3,9,8,9,9,11,14,14,14]
+pp = Base32.bytes( str )  # or from a kai string (auto-decodes to hex first)
+# => [9,9,9,9,6,7,7,4,1,1,14,1,9,15,14,14,0,5,5,0,6,6,4,4,13,8,6,8,1,3,3,0,5,5,5,6,6,5,5,3,9,8,9,9,11,14,14,14]
 ```
 
 

data/Rakefile

@@ -15,7 +15,7 @@ Hoe.spec 'base32-alphabets' do
 
   # switch extension to .markdown for gihub formatting
   self.readme_file  = 'README.md'
-  self.history_file = 'HISTORY.md'
+  self.history_file = 'CHANGELOG.md'
 
   self.extra_deps = [
   ]

data/lib/base32-alphabets.rb

@@ -22,8 +22,20 @@ Crockford     = Base32::Crockford
 Electrologica = Base32::Electrologica
 
 
-def encode32( num ) Base32.encode( num ); end
-def decode32( num ) Base32.decode( str ); end
+def encode32( num_or_bytes )
+  Base32.encode( num_or_bytes )
+end
+
+def decode32( str )
+  Base32.decode( str )
+end
+
+
+## -- add bytes32 - why? why not?
+##
+## def bytes32( num_or_str )
+##  Base32.bytes( num_or_str )
+## end
 
 
 

data/lib/base32-alphabets/base.rb

@@ -7,57 +7,100 @@
 module Base32
 class Base
 
-  # Converts a base10 integer to a base32 string.
-  def self.encode( num, klass: )
-    buf = String.new
-    while num >= BASE
-      ## puts "num=#{num}"
-      mod = num % BASE
-      ## puts "  mod=#{mod} == #{klass::ALPHABET[mod]}"
-      buf = klass::ALPHABET[mod] + buf
-      ## puts "buf=#{buf}"
-      num = (num - mod)/BASE
+  def self.bytes( num_or_str )
+    if num_or_str.is_a? String
+      str = num_or_str
+      num = decode( str )
+    else  # assume number
+      num = num_or_str
     end
-    klass::ALPHABET[num] + buf
+    Base32._bytes( num )
   end
 
-
-
-  # Converts a base32 string to a base10 integer.
-  def self.decode( str, klass: )
-    ## note: allow spaces or dashes (-); remove them all first
-    str = str.tr( ' -', '' )
-
-    num = 0
-    str.reverse.each_char.with_index do |char,index|
-      code = klass::NUMBER[char]
-      raise ArgumentError, "Value passed not a valid base32 string - >#{char}< not found in alphabet"  if code.nil?
-      num += code * (BASE**(index))
+  # Converts a base10 integer to a base32 string.
+  def self.encode( num_or_bytes )
+    if num_or_bytes.is_a? Array
+      bytes = num_or_bytes
+    else
+      num = num_or_bytes
+      bytes = Base32._bytes( num )
     end
-    num
+    _encode( bytes )
   end
 
+  def self._encode( bytes )
+    bytes.reduce( String.new ) do |buf, byte|
+      buf << alphabet[byte]
+      buf
+    end
+  end
 
+  def self.fmt( str_or_num_or_bytes, group: 4, sep: ' ' )
+    if str_or_num_or_bytes.is_a? String
+      str = str_or_num_or_bytes
+    else  ## assume number
+      ## str_or_num_or_bytes.is_a?(Integer) ||
+      ## str_or_num_or_bytes.is_a?(Bignum) ||
+      ## str_or_num_or_bytes.is_a?(Fixnum)
+      num_or_bytes = str_or_num_or_bytes
+      str = encode( num_or_bytes )   ## auto-encode (shortcut)
+    end
+    _fmt( str, group: group, sep: sep )
+  end
 
-
-  def self.fmt( str )
-    ## note: allow spaces or dashes (-); remove them all first
-    str = str.tr( ' -', '' )
+  def self._fmt( str, group: 4, sep: ' ' )
+    str = _clean( str )
 
     ## format in groups of four (4) separated by space
     ##  e.g.  ccac7787fa7fafaa16467755f9ee444467667366cccceede
     ##     :  ccac 7787 fa7f afaa 1646 7755 f9ee 4444 6766 7366 cccc eede
-    str.reverse.gsub( /(.{4})/, '\1 ').reverse.strip
+    str.reverse.gsub( /(.{#{group}})/, "\\1#{sep}" ).reverse.sub( /^#{sep}/, '' )
   end
 
 
+  # Converts a base32 string to a base10 integer.
+  def self.decode( str_or_bytes )
+    if str_or_bytes.is_a? Array
+      bytes = str_or_bytes
+    else  ## assume string
+      str   = str_or_bytes
+      bytes = _decode( str )
+    end
+    Base32._pack( bytes )
+  end
+
+
+  def self._decode( str )
+    str = _clean( str )
+    str.each_char.reduce([]) do |bytes,char|
+      byte = number[char]
+      raise ArgumentError, "Value passed not a valid base32 string - >#{char}< not found in alphabet"  if byte.nil?
+      bytes << byte
+      bytes
+    end
+  end
+
+  def self._clean( str )
+    ## note: remove space ( ), dash (-), slash (/) for now as "allowed / supported" separators
+    str.tr( ' -/', '' )
+  end
+
+
+
+  ########################
+  ## (private) helpers
+  def self._build_binary
+    ## e.g. '00000', '00001', '00010', '00011', etc.
+    number.each.reduce({}) do |h, (char,index)|
+      h[char]        = '%05b' % index
+      h
+    end
+  end
 
-########################
-## (private) helpers
-  def self.build_binary( alphabet )
-    alphabet.each_with_index.reduce({}) do |h, (char,index)|
-      # puts "#{char} => #{index} #{'%05b' % index}"
-      h[char] = '%05b' % index
+  def self._build_code
+    ## e.g. '00', '01', '02', '03', '04', etc.
+    number.each.reduce({}) do |h, (char,index)|
+      h[char]        = '%02d' % index
       h
     end
   end

data/lib/base32-alphabets/base32.rb

@@ -49,13 +49,54 @@ module Base32   ## Base32  (2^5 - 5-bits)
 
 
 
-  def self.encode( num, klass: configuration.format ) klass.encode( num ); end
-  def self.decode( str, klass: configuration.format ) klass.decode( str ); end
-  def self.fmt( str, klass: configuration.format ) klass.fmt( str );    end
+  def self.encode( num_or_bytes, klass: configuration.format )
+    klass.encode( num_or_bytes )
+  end
+
+  def self.decode( str_or_bytes, klass: configuration.format )
+    klass.decode( str_or_bytes )
+  end
+
+  def self.fmt( str_or_num_or_bytes, klass: configuration.format, group: 4, sep: ' ' )
+    klass.fmt( str_or_num_or_bytes, group: group, sep: sep )
+  end
+
+  def self.bytes( num_or_str, klass: configuration.format )
+    klass.bytes( num_or_str )
+  end
 
-  ## encoding alphabet - letter-to-number by index / array
-  def self.alphabet( klass: configuration.format ) klass::ALPHABET; end
-  ## decoding number-to-letter mapping / hash
-  def self.number( klass: configuration.format ) klass::NUMBER; end
 
+  ####
+  # (private) helper - note: leading underscore in name e.g. _bytes
+  def self._bytes( num )
+    b = []
+    while num >= BASE
+      mod = num % BASE
+      b << mod
+      num = (num - mod) / BASE
+    end
+    b << num
+    b = b.reverse
+    b
+  end
+
+  def self._pack( bytes )
+    num = 0
+    bytes.reverse.each_with_index do |byte,index|
+      num += byte * (BASE**(index))
+    end
+    num
+  end
+
+
+
+  ## encoding alphabet - letter-to-number by index / array
+  def self.alphabet( klass: configuration.format ) klass.alphabet; end
+
+  ## decoding letter-to-number mapping / hash
+  def self.number( klass: configuration.format ) klass.number; end
+  ## decoding letter-to-code mapping / hash
+  def self.code( klass: configuration.format ) klass.code; end
+  ## decoding letter-to-binary mapping / hash
+  def self.binary( klass: configuration.format ) klass.binary; end
 end # module Base32

data/lib/base32-alphabets/crockford.rb

@@ -11,12 +11,13 @@ class Crockford < Base
 ALPHABET = %w[ 0 1 2 3 4 5 6 7
                8 9 a b c d e f
                g h j k m n p q
-               r s t v w x y z]
+               r s t v w x y z ]
 
-def self.encode( num ) super( num, klass: self ); end
+def self.alphabet() ALPHABET; end
 
 
-NUMBER = {    ## rename INTEGER /INT - why? why not??
+
+NUMBER = {
   '0' => 0, 'o' => 0, 'O'=> 0,
   '1' => 1, 'l' => 1, 'L'=> 1, 'i'=> 1, 'I' => 1,
   '2' => 2,
@@ -50,16 +51,19 @@ NUMBER = {    ## rename INTEGER /INT - why? why not??
   'y' => 30, 'Y' => 30,
   'z' => 31, 'Z' => 31
 }
-
-def self.decode( str ) super( str, klass: self ); end
+def self.number() NUMBER; end
 
 
 ## simple hash map (helper) for conversion to binary string
-BINARY = build_binary( ALPHABET )
+BINARY = _build_binary()
+CODE   = _build_code()
 
 ## add shortcuts (convenience) aliases
 BIN = BINARY
 NUM = NUMBER
 
+def self.code() CODE; end
+def self.binary() BINARY; end
+
 end # class Crockford
 end # module Base32

data/lib/base32-alphabets/electrologica.rb

@@ -1,33 +1,17 @@
 # encoding: utf-8
 
 module Base32
-class Electrologica   ## Base32  (2^5 - 5-bits)
+class Electrologica < Base  ## Base32  (2^5 - 5-bits)
 
   ALPHABET = %w[ 00 01 02 03 04 05 06 07
                  08 09 10 11 12 13 14 15
                  16 17 18 19 20 21 22 23
                  24 25 26 27 28 29 30 31 ]
 
-  # Converts a base10 integer to a base32 string.
-  def self.encode( num )
-    buf = String.new
-    while num >= BASE
-      # puts "num=#{num}"
-      mod = num % BASE
-      # puts "  mod=#{mod} == #{ALPHABET[mod]}"
-      buf = "-" + ALPHABET[mod] + buf    ## note: add - separator
-      # puts "buf=#{buf}"
-      num = (num - mod)/BASE
-    end
-    ALPHABET[num] + buf
-  end
+  def self.alphabet() ALPHABET; end    ## add alpha / char aliases - why? why not?
 
-  ## Note:
-  ##   for decoding allow (misspelled) l/L for 1
-  ##    and               (misspelled)  0  for o/O - why? why not?
-  ##    and UPPERCASE letters - why? why not?
 
-  NUMBER = {    ## rename INTEGER /INT - why? why not??
+  NUMBER = {
     '00' => 0,  '0' => 0,
     '01' => 1,  '1' => 1,
     '02' => 2,  '2' => 2,
@@ -62,40 +46,59 @@ class Electrologica   ## Base32  (2^5 - 5-bits)
     '31' => 31,
   }
 
+  def self.number() NUMBER; end
+
+  BINARY = _build_binary()
+  CODE   = _build_code()
 
   ## add shortcuts (convenience) aliases
-  ## BIN = BINARY
+  BIN = BINARY
   NUM = NUMBER
 
-  # Converts a base32 string to a base10 integer.
-  def self.decode( str )
-    ## note: allow spaces or slash (/) for dashes (-)
-    str = str.strip  ## remove leading and trailing spaces (first)
-    str = str.tr( ' /', '-' )
-    str = str.gsub( /-{2,}/, '-' )  ## fold more than one dash into one
+  def self.code() CODE; end
+  def self.binary() BINARY; end
+
+
 
-    num = 0
-    str.split('-').reverse.each.with_index do |char,index|
-      code = NUMBER[char]
-      raise ArgumentError, "Value passed not a valid base32 string - >#{char}< not found in alphabet"  if code.nil?
-      num += code * (BASE**(index))
+  # Converts a base10 integer to a base32 string.
+  def self._encode( bytes )
+    bytes.each_with_index.reduce(String.new) do |buf, (byte,i)|
+      buf << "-"    if i > 0   ## add separator (-) EXCEPT for first char
+      buf << alphabet[byte]
+      buf
     end
-    num
   end
 
+  def self._fmt( str, group: 4, sep: ' ' )
+    ## todo/fix: check sep - MUST be space () or slash (/) for now!!!!!
 
-  def self.fmt( str, sep: '-' )
-    ## note: allow spaces or slash (/) for dashes (-)
-    str = str.strip  ## remove leading and trailing spaces (first)
-    str = str.tr( ' /', '-' )
-    str = str.gsub( /-{2,}/, '-' )  ## fold more than one dash into one
+    str = _clean( str )
 
     ## format in groups of four (4) separated by space
-    ##  e.g.  ccac7787fa7fafaa16467755f9ee444467667366cccceede
-    ##     :  ccac 7787 fa7f afaa 1646 7755 f9ee 4444 6766 7366 cccc eede
+    ##  e.g.  09-09-09-09-06-07-07-04-01-01-14-01-09-15-14-14-00-05-05-00
+    ##     :  09-09-09-09 06-07-07-04 01-01-14-01 09-15-14-14 00-05-05-00
 
     ## note: use reverse - if not divided by four that leading slice gets cut short
-    str.split('-').reverse.each_slice(4).map { |slice| slice.reverse.join( sep ) }.reverse.join( ' ' )
+    str.split('-').reverse.each_slice( group ).map { |slice| slice.reverse.join( '-' ) }.reverse.join( sep )
+  end
+
+
+  # Converts a base32 string to a base10 integer.
+  def self._decode( str )
+    str = _clean( str )
+    str.split('-').reduce([]) do |bytes,char|
+      byte = number[char]
+      raise ArgumentError, "Value passed not a valid base32 string - >#{char}< not found in alphabet"  if byte.nil?
+      bytes << byte
+      bytes
+    end
+  end
+
+  def self._clean( str )
+    ## note: allow spaces or slash (/) for dashes (-)
+    str = str.strip  ## remove leading and trailing spaces (first)
+    str = str.tr( ' /', '-' )
+    str = str.gsub( /-{2,}/, '-' )  ## fold more than one dash into one
   end
 
 end # class Electrologica

data/lib/base32-alphabets/kai.rb

@@ -8,21 +8,24 @@
 
 module Base32
 class Kai < Base
+
 # See https://en.wikipedia.org/wiki/Base58
 ## Note: aplpabet used for encoding
 ALPHABET = %w[ 1 2 3 4 5 6 7 8
                9 a b c d e f g
                h i j k m n o p
-               q r s t u v w x]
+               q r s t u v w x ]
+
+def self.alphabet() ALPHABET; end    ## add alpha / char aliases - why? why not?
+
 
-def self.encode( num ) super( num, klass: self ); end
 
 ## Note:
 ##   for decoding allow (misspelled) l/L for 1
 ##    and               (misspelled)  0  for o/O - why? why not?
 ##    and UPPERCASE letters - why? why not?
 
-NUMBER = {    ## rename INTEGER /INT - why? why not??
+NUMBER = {
   '1' => 0, 'l' => 0, 'L'=> 0,
   '2' => 1,
   '3' => 2,
@@ -57,52 +60,19 @@ NUMBER = {    ## rename INTEGER /INT - why? why not??
   'x' => 31, 'X' => 31
 }
 
-def self.decode( str ) super( str, klass: self ); end
+def self.number() NUMBER; end        ## add num alias - why? why not?
 
 
-=begin
-BINARY = {
-  '1' => '00000',    # 0
-  '2' => '00001',    # 1
-  '3' => '00010',    # 2
-  '4' => '00011',    # 3
-  '5' => '00100',    # 4
-  '6' => '00101',    # 5
-  '7' => '00110',    # 6
-  '8' => '00111',    # 7
-  '9' => '01000',    # 8
-  'a' => '01001',    # 9
-  'b' => '01010',    # 10
-  'c' => '01011',    # 11
-  'd' => '01100',    # 12
-  'e' => '01101',    # 13
-  'f' => '01110',    # 14
-  'g' => '01111',    # 15
-  'h' => '10000',    # 16
-  'i' => '10001',    # 17
-  'j' => '10010',    # 18
-  'k' => '10011',    # 19
-  'm' => '10100',    # 20
-  'n' => '10101',    # 21
-  'o' => '10110',    # 22
-  'p' => '10111',    # 23
-  'q' => '11000',    # 24
-  'r' => '11001',    # 25
-  's' => '11010',    # 26
-  't' => '11011',    # 27
-  'u' => '11100',    # 28
-  'v' => '11101',    # 29
-  'w' => '11110',    # 30
-  'x' => '11111'     # 31
-}
-=end
-
 ## simple hash map (helper) for conversion to binary string
-BINARY = build_binary( ALPHABET )
+BINARY = _build_binary()
+CODE   = _build_code()
 
 ## add shortcuts (convenience) aliases
 BIN = BINARY
 NUM = NUMBER
 
+def self.code() CODE; end
+def self.binary() BINARY; end        ## add bin alias - why? why not?
+
 end # class Kai
 end # module Base32

data/lib/base32-alphabets/version.rb

@@ -4,7 +4,7 @@ module Base32
 
 
   MAJOR = 1
-  MINOR = 0
+  MINOR = 1
   PATCH = 0
   VERSION = [MAJOR,MINOR,PATCH].join('.')
 

data/test/test_base32_crockford.rb

@@ -47,15 +47,10 @@ class TestBase32Crockford < MiniTest::Test
     assert_raises(ArgumentError) { Base32::Crockford.decode("'+?") }
   end
 
-
-=begin
-  def test_length_and_hyphenization
-    assert_equal "0016J", Base32::Crockford.encode(1234, :length => 5)
-    assert_equal "0-01-6J",
-      Base32::Crockford.encode(1234, :length => 5, :split => 2)
-    assert_equal "00-010",
-      Base32::Crockford.encode(32, :length => 5, :split => 3)
+  def test_group_and_hyphens
+    assert_equal "16j",  Base32::Crockford.fmt( 1234, group: 5)
+    assert_equal "1-6j", Base32::Crockford.fmt( 1234, group: 2, sep: '-')
+    assert_equal "10",   Base32::Crockford.fmt(   32, group: 3)
   end
-=end
 
 end  # class TestBase32Crockford

data/test/test_base32_electrologica.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_base32_electrologica.rb
+
+
+require 'helper'
+
+
+class TestBase32Electrologia < MiniTest::Test
+
+
+def test_electrologica
+
+  ## Kitty #1001
+  ##  see https://cryptokittydex.com/kitties/1001
+
+   binary = 0b0000000000000000010010100101001010010011000111001110010000001000010111000001010010111101110011100000000101001010000000110001100010000100011010100000110010000000100011000110000000101001010010100110001100010100101000110100101000010010100101011011100111001110  # binary
+   hex    = 0x00004a52931ce4085c14bdce014a0318846a0c808c60294a6314a34a_1295_b9ce   # hex
+
+   el        = "09-09-09-09-06-07-07-04-01-01-14-01-09-15-14-14-00-05-05-00-06-06-04-04-13-08-06-08-01-03-03-00-05-05-05-06-06-05-05-03-09-08-09-09-11-14-14-14"
+   el_fmt    = "09-09-09-09 06-07-07-04 01-01-14-01 09-15-14-14 00-05-05-00 06-06-04-04 13-08-06-08 01-03-03-00 05-05-05-06 06-05-05-03 09-08-09-09 11-14-14-14"
+   el_fmt_ii = "09-09-09-09/06-07-07-04/01-01-14-01/09-15-14-14/00-05-05-00/06-06-04-04/13-08-06-08/01-03-03-00/05-05-05-06/06-05-05-03/09-08-09-09/11-14-14-14"
+
+   assert_equal binary, hex
+
+
+   Base32.format = :electrologica
+   el2 = Base32.encode( hex )
+   pp el
+   pp el2
+
+   assert_equal el, el2
+   assert_equal el_fmt,    Base32::Electrologica.fmt( el2 )
+   assert_equal el_fmt_ii, Base32::Electrologica.fmt( el2, sep: '/' )
+
+   assert_equal el_fmt,    Base32::Electrologica.fmt( hex, group: 4 )
+   assert_equal el_fmt_ii, Base32::Electrologica.fmt( hex, group: 4, sep: '/' )
+
+
+   hex2 = Base32.decode( el2 )
+   pp hex2
+   assert_equal hex, hex2
+
+   el3  = Base32::Electrologica.encode( hex )
+   hex3 = Base32::Electrologica.decode( el3 )
+   assert_equal hex, hex3
+   assert_equal el,  el3
+end
+
+
+end  # class TestBase32Electrologia

data/test/{test_base32.rb → test_base32_kai.rb}

@@ -2,13 +2,13 @@
 
 ###
 #  to run use
-#     ruby -I ./lib -I ./test test/test_base32.rb
+#     ruby -I ./lib -I ./test test/test_base32_kai.rb
 
 
 require 'helper'
 
 
-class TestBase32 < MiniTest::Test
+class TestBase32Kai < MiniTest::Test
 
 
 def test_kai
@@ -19,7 +19,9 @@ def test_kai
    binary = 0b0000000000000000010010100101001010010011000111001110010000001000010111000001010010111101110011100000000101001010000000110001100010000100011010100000110010000000100011000110000000101001010010100110001100010100101000110100101000010010100101011011100111001110  # binary
    hex    = 0x00004a52931ce4085c14bdce014a0318846a0c808c60294a6314a34a_1295_b9ce   # hex
 
-   kai_fmt = "aaaa 7885 22f2 agff 1661 7755 e979 2441 6667 7664 a9aa cfff"
+   kai_fmt    = "aaaa 7885 22f2 agff 1661 7755 e979 2441 6667 7664 a9aa cfff"
+   kai_fmt_ii = "aaaa/7885/22f2/agff/1661/7755/e979/2441/6667/7664/a9aa/cfff"
+   kai_fmt8   = "aaaa7885 22f2agff 16617755 e9792441 66677664 a9aacfff"
    kai     = kai_fmt.gsub( ' ', '' )
 
    assert_equal binary, hex
@@ -30,22 +32,29 @@ def test_kai
    pp hex
 
    Base32.format = :kai
-   kai2 = Base32.encode( hex )
+   kai2  = Base32.encode( hex )
    pp kai
    pp kai2
 
    assert_equal kai, kai2
-   assert_equal kai_fmt, Base32::Kai.fmt( kai2 )
+   assert_equal kai_fmt,    Base32::Kai.fmt( kai2 )
+   assert_equal kai_fmt_ii, Base32::Kai.fmt( kai2, sep: '/' )
+   assert_equal kai_fmt8,   Base32::Kai.fmt( kai2, group: 8 )
+
+   assert_equal kai_fmt,    Base32::Kai.fmt( hex, group: 4 )
+   assert_equal kai_fmt_ii, Base32::Kai.fmt( hex, group: 4, sep: '/' )
+   assert_equal kai_fmt8,   Base32::Kai.fmt( hex, group: 8 )
 
 
    hex2 = Base32.decode( kai2 )
    pp hex2
    assert_equal hex, hex2
 
-   kai3 = Base32::Kai.encode( hex )
-   hex3 = Base32::Kai.decode( kai3 )
-   assert_equal hex, hex3
-   assert_equal kai, kai3
+   kai3  = Base32::Kai.encode( hex )
+   hex3  = Base32::Kai.decode( kai3 )
+   assert_equal hex,   hex3
+   assert_equal kai,   kai3
+
 
    puts "kai.length: #{kai.length}"  ## 48
    puts "  first: #{kai[0]}"

data/test/test_bytes.rb

@@ -0,0 +1,160 @@
+# encoding: utf-8
+
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_bytes.rb
+
+
+require 'helper'
+
+
+class TestBytes < MiniTest::Test
+
+
+def hex
+  ## Kitty #1001
+  ##  see https://cryptokittydex.com/kitties/1001
+  0x00004a52931ce4085c14bdce014a0318846a0c808c60294a6314a34a_1295_b9ce   # hex
+end
+
+def bytes
+  [9,9,9,9,6,7,7,4,1,1,14,1,9,15,14,14,0,5,5,0,6,6,4,4,13,8,6,8,1,3,3,0,5,5,5,6,6,5,5,3,9,8,9,9,11,14,14,14]
+end
+
+
+def test_bytes_kai
+   kai_fmt    = "aaaa 7885 22f2 agff 1661 7755 e979 2441 6667 7664 a9aa cfff"
+   kai_fmt2   = "AAAA 7885 22F2 AGFF 1661 7755 E979 2441 6667 7664 A9AA CFFF"
+   kai     = kai_fmt.gsub( ' ', '' )
+
+   Base32.format = :kai
+
+   pp bytes2  = Base32._bytes( hex )
+   pp bytes3  = Base32.bytes( hex )
+   pp bytes4  = Base32.bytes( kai )
+   pp bytes5  = Base32.bytes( kai_fmt )
+   pp bytes6  = Base32.bytes( kai_fmt2 )
+
+   pp bytes7  = Base32::Kai.bytes( hex )
+   pp bytes8  = Base32::Kai.bytes( kai )
+   pp bytes9  = Base32::Kai.bytes( kai_fmt )
+   pp bytes10 = Base32::Kai.bytes( kai_fmt2 )
+
+   assert_equal 48,    bytes.size
+   assert_equal bytes, bytes2
+   assert_equal bytes, bytes3
+   assert_equal bytes, bytes4
+   assert_equal bytes, bytes5
+   assert_equal bytes, bytes6
+   assert_equal bytes, bytes7
+   assert_equal bytes, bytes8
+   assert_equal bytes, bytes9
+   assert_equal bytes, bytes10
+
+   ## try encode bytes
+   assert_equal kai,     Base32.encode( bytes )
+   assert_equal kai_fmt, Base32.fmt( bytes )
+
+   assert_equal kai,     Base32::Kai.encode( bytes )
+   assert_equal kai_fmt, Base32::Kai.fmt( bytes )
+
+   ## try decode/pack bytes
+   hex = Base32::Kai.decode( kai )
+   assert_equal hex,                  Base32._pack( bytes )
+   assert_equal Base32._bytes( hex ), Base32._bytes( Base32._pack( bytes ))
+   assert_equal bytes,                Base32._bytes( hex )
+
+   assert_equal hex, Base32.decode( bytes )
+   assert_equal hex, Base32::Kai.decode( bytes )
+end
+
+
+def test_bytes_crockford
+   crockford_fmt =  "9999 6774 11e1 9fee 0550 6644 d868 1330 5556 6553 9899 beee"
+   crockford_fmt2 = "9999 6774 11E1 9FEE 0550 6644 D868 1330 5556 6553 9899 BEEE"
+   crockford     = crockford_fmt.gsub( ' ', '' )
+
+   Base32.format = :crockford
+
+   pp bytes2  = Base32._bytes( hex )
+   pp bytes3  = Base32.bytes( hex )
+   pp bytes4  = Base32.bytes( crockford )
+   pp bytes5  = Base32.bytes( crockford_fmt )
+   pp bytes6  = Base32.bytes( crockford_fmt2 )
+
+   pp bytes7  = Base32::Crockford.bytes( hex )
+   pp bytes8  = Base32::Crockford.bytes( crockford )
+   pp bytes9  = Base32::Crockford.bytes( crockford_fmt )
+   pp bytes10 = Base32::Crockford.bytes( crockford_fmt2 )
+
+   assert_equal 48,    bytes.size
+   assert_equal bytes, bytes2
+   assert_equal bytes, bytes3
+   assert_equal bytes, bytes4
+   assert_equal bytes, bytes5
+   assert_equal bytes, bytes6
+   assert_equal bytes, bytes7
+   assert_equal bytes, bytes8
+   assert_equal bytes, bytes9
+   assert_equal bytes, bytes10
+
+   ## try encode bytes
+   assert_equal crockford,     Base32.encode( bytes )
+   assert_equal crockford_fmt, Base32.fmt( bytes )
+
+   assert_equal crockford,     Base32::Crockford.encode( bytes )
+   assert_equal crockford_fmt, Base32::Crockford.fmt( bytes )
+
+   ## try decode/pack bytes
+   hex = Base32::Crockford.decode( crockford )
+   assert_equal hex,                  Base32._pack( bytes )
+   assert_equal Base32._bytes( hex ), Base32._bytes( Base32._pack( bytes ))
+   assert_equal bytes,                Base32._bytes( hex )
+
+   assert_equal hex, Base32.decode( bytes )
+   assert_equal hex, Base32::Crockford.decode( bytes )
+end
+
+
+def test_bytes_electrologica
+   el_fmt = "09-09-09-09 06-07-07-04 01-01-14-01 09-15-14-14 00-05-05-00 06-06-04-04 13-08-06-08 01-03-03-00 05-05-05-06 06-05-05-03 09-08-09-09 11-14-14-14"
+   el     = "09-09-09-09-06-07-07-04-01-01-14-01-09-15-14-14-00-05-05-00-06-06-04-04-13-08-06-08-01-03-03-00-05-05-05-06-06-05-05-03-09-08-09-09-11-14-14-14"
+
+   Base32.format = :electrologica
+
+   pp bytes2  = Base32._bytes( hex )
+   pp bytes3  = Base32.bytes( hex )
+   pp bytes4  = Base32.bytes( el )
+   pp bytes5  = Base32.bytes( el_fmt )
+
+   pp bytes6  = Base32::Electrologica.bytes( hex )
+   pp bytes7  = Base32::Electrologica.bytes( el )
+   pp bytes8  = Base32::Electrologica.bytes( el_fmt )
+
+   assert_equal 48,    bytes.size
+   assert_equal bytes, bytes2
+   assert_equal bytes, bytes3
+   assert_equal bytes, bytes4
+   assert_equal bytes, bytes5
+   assert_equal bytes, bytes6
+   assert_equal bytes, bytes7
+   assert_equal bytes, bytes8
+
+   ## try encode bytes
+   assert_equal el,     Base32.encode( bytes )
+   assert_equal el_fmt, Base32.fmt( bytes )
+
+   assert_equal el,     Base32::Electrologica.encode( bytes )
+   assert_equal el_fmt, Base32::Electrologica.fmt( bytes )
+
+   ## try decode/pack bytes
+   hex = Base32::Electrologica.decode( el )
+   assert_equal hex,                  Base32._pack( bytes )
+   assert_equal Base32._bytes( hex ), Base32._bytes( Base32._pack( bytes ))
+   assert_equal bytes,                Base32._bytes( hex )
+
+   assert_equal hex, Base32.decode( bytes )
+   assert_equal hex, Base32::Electrologica.decode( bytes )
+end
+
+end  # class TestBytes

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: base32-alphabets
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-13 00:00:00.000000000 Z
+date: 2019-01-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdoc
@@ -44,12 +44,12 @@ email: wwwmake@googlegroups.com
 executables: []
 extensions: []
 extra_rdoc_files:
-- HISTORY.md
+- CHANGELOG.md
 - LICENSE.md
 - Manifest.txt
 - README.md
 files:
-- HISTORY.md
+- CHANGELOG.md
 - LICENSE.md
 - Manifest.txt
 - README.md
@@ -62,8 +62,10 @@ files:
 - lib/base32-alphabets/kai.rb
 - lib/base32-alphabets/version.rb
 - test/helper.rb
-- test/test_base32.rb
 - test/test_base32_crockford.rb
+- test/test_base32_electrologica.rb
+- test/test_base32_kai.rb
+- test/test_bytes.rb
 homepage: https://github.com/cryptocopycats/base32-alphabets
 licenses:
 - Public Domain