base_x 0.8.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 230c8a8b317282e89b30d188a1801e81201e31f8
+  data.tar.gz: ae6bc2a2bcd543b4f8be6e8116d5db2520d7aecc
+SHA512:
+  metadata.gz: 1bf9a6ad14849a82fa486d205a6e25d4d0c8b80cf4741d8f5cee3435c29daba82ab0095278443e38aa47bccb2c9f0ec8a1f5a058f64bfcd08d1427c9ae0b3ff6
+  data.tar.gz: 61fb7c1933f3b53bf55df57fb4e9dcaff89ec0445ef6a16ef772099017e40b202adc0bd2404a0e625bb701c4772e874fccb12ca9a0476ca8d1312e14a5cdbe2e

data/.gitignore

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

data/.ruby_version

@@ -0,0 +1 @@
+2.1.1

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.1.1
+  - 2.0.0

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+gem "minitest"
+gem "guard-minitest",          require: false
+gem "terminal-notifier-guard", require: false
+gem "minitest-reporters"
+
+gemspec

data/Guardfile

@@ -0,0 +1,14 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :minitest do
+  # with Minitest::Unit
+  watch(%r{^test/(.*)\/?test_(.*)\.rb$})
+  watch(%r{^lib/(.*/)?([^/]+)\.rb$})     { |m| "test/#{m[1]}test_#{m[2]}.rb" }
+  watch(%r{^test/test_helper\.rb$})      { 'test' }
+
+  # with Minitest::Spec
+  # watch(%r{^spec/(.*)_spec\.rb$})
+  # watch(%r{^lib/(.+)\.rb$})         { |m| "spec/#{m[1]}_spec.rb" }
+  # watch(%r{^spec/spec_helper\.rb$}) { 'spec' }
+end

data/LICENSE.txt

@@ -0,0 +1,3 @@
+BaseX is dedicated to the public domain by its author, Brian Hempel. No rights are reserved. No restrictions are placed on the use of BaseX. That freedom also means, of course, that no warrenty of fitness is claimed; use BaseX at your own risk.
+
+Public domain dedication is explained by the CC0 1.0 summary (and only the summary) at https://creativecommons.org/publicdomain/zero/1.0/

data/README.md

@@ -0,0 +1,197 @@
+# BaseX
+
+BaseX is a arbitrary base conversion library that, in addition to converting to/from integers, also supports encoding and decoding arbitrary binary data into and out of any base.
+
+Many known bases are included, such as [Bitcoin Base58](https://en.bitcoin.it/wiki/Base58Check_encoding).
+
+BaseX is useful for generating human-friendly cryptographic tokens and ID's, and could even be usde for encoding, transmitting, and decoding binary data over binary-unsafe mediums.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'base_x'
+```
+
+And then execute:
+
+```
+$ bundle
+```
+
+Or install it yourself as:
+
+```
+$ gem install base_x
+```
+
+## Usage
+
+Let's convert some numbers.
+
+```ruby
+# Emulate hex, just for fun.
+BaseX.integer_to_string(241,  numerals: "0123456789abcdef")
+# => "f1"
+BaseX.string_to_integer("f1", numerals: "0123456789abcdef")
+# => 241
+
+# Bitcoin Base58 numerals. No O, 0, I, or l
+BaseX.integer_to_string(456724510, numerals: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
+# => "hMqHX"
+BaseX.string_to_integer("hMqHX",   numerals: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
+# => 456724510
+
+# That was rather clumsy, so let's use the provided Base58 object
+BaseX::Base58.integer_to_string(456724510)
+# => "hMqHX"
+```
+
+If you use a base more than once, make it a constant.
+
+```ruby
+Base24Greek = BaseX.new("αβγδεζηθικλμνξοπρστυφχψω")
+
+Base24Greek.integer_to_string(456724510)
+# => "ιψια"
+Base24Greek.string_to_integer("ιψια")
+# => 456724510
+```
+
+## Encoding
+
+Use the `encode` and `decode` methods to convert arbitary binary data to and from the desired base.
+
+```ruby
+BaseX::Base30L.encode("Hello World!")
+# => "3xtzc85paptyrbdjgd27"
+BaseX::Base30L.decode("3xtzc85paptyrbdjgd27")
+# => "Hello World!"
+
+BaseX.encode("SOS", numerals: "01")
+# => "010100110100111101010011"
+BaseX.decode("010100110100111101010011", numerals: "01")
+# => "SOS"
+```
+
+The encoding scheme is simple: BaseX treats the whole binary blob as one large big-endian binary number and then converts that number into the desired base. If the original binary had leading 0 bytes, leading "0"'s are added to the converted number.
+
+```ruby
+Base10 = BaseX.new("0123456789")
+
+Base10.encode("Hi")         # => "18537"
+Base10.encode("\x00Hi")     # => "00018537"
+Base10.encode("\x00\x00Hi") # => "0000018537"
+```
+
+## Token Generation
+
+BaseX is great for generating tokens for identification or cryptographic purposes.
+
+```ruby
+require 'securerandom'
+
+bytes = SecureRandom.random_bytes(16) # 128 bits
+
+BaseX::Base30L.encode(bytes)
+# => "347wbrazxkvj59atq5zh2fdk55e"
+BaseX::Base58.encode(bytes)
+# => "SLrA71VABcvExTht6KLr89"
+```
+
+## Provided Bases
+
+BaseX provides some bases you can use right away.
+
+| Constant(s)                                                        | Example (64-bit token)   | Numerals and Explanation                                                             |
+|--------------------------------------------------------------------|--------------------------|-----------------------------------------------------------------------------------|
+| `BaseX::Binary`                                                    | `"1111110010001110001…"` | `0-1`<br>Binary!                                                            |
+| `BaseX::Base16` `BaseX::Base16L` `BaseX::Hex` `BaseX::Hexadecimal` | `"fc8e3c917d58368b"`     | `0-9a-f`<br>Lowercase [hexadecimal](http://en.wikipedia.org/wiki/Hexadecimal). |
+| `BaseX::Base16U`                                                   | `"FC8E3C917D58368B"`     | `0-9A-F`<br>Uppercase [hexadecimal](http://en.wikipedia.org/wiki/Hexadecimal). |
+| `BaseX::Base30L`                                                   | `"369be5e68tfqth"`       | `2-9a-hj-km-np-tv-z`<br>(`0 1 i l o u` omitted.)<br>A BaseX special. All characters that could be confused in uppercase or lowercase are removed, so it is suitable for case-insensitive tokens. See `BaseX::CrockfordBase32` for why "u" is removed. |
+| `BaseX::Base30U`                                                   | `"369BE5E68TFQTH"`       | `2-9A-HJ-KM-NP-TV-Z`<br>(`0 1 I L O U` omitted.)<br>Uppercase version of above. I think lowercase is easier to read. |
+| `BaseX::Base31L`                                                   | `"s59ez2tk5bep7"`        | `0-9a-hj-km-np-z`<br>(`0 1 i l o` omitted.)<br>A BaseX special. All characters that could be confused in uppercase or lowercase are removed, so it is suitable for case-insensitive tokens. The "u" is retained. |
+| `BaseX::Base31U`                                                   | `"S59EZ2TK5BEP7"`        | `0-9A-HJ-KM-NP-Z`<br>(`0 1 I L O` omitted.)<br>Uppercase version of above. I think lowercase is easier to read. |
+| `BaseX::RFC4648Base32`                                             | `"PZDR4SF6VQNUL"`        | `A-Z2-7`<br>(`0 1 8 9` omitted.)<br>The base 32 numerals of [RFC 4648](http://tools.ietf.org/html/rfc4648#page-8). |
+| `BaseX::CrockfordBase32`                                           | `"FS3HWJ5YNGDMB"`        | `0-9A-HJ-KM-NP-TV-Z`<br>(`I L O U` omitted.)<br>The numerals of Douglas Crockford's [Base32 proposal](http://www.crockford.com/wrmg/base32.html). Crockford fears that allowing "u" may result in "accidental obscenity". What's the actually probability of a problem? I calculate that, with "u" as a possible numeral, a random 3-numeral string has about a 1/8000 chance of phonetically dropping the f-bomb on a viewer; a 128-bit token encoded in base32 has 26 numerals and thus 24 3-numeral strings, consequently about 1 in every 340 such tokens would be vulgar. |
+| `BaseX::Base58` `BaseX::BitcoinBase58`                             | `"jF78uMwAKKg"`          | `1-9A-HJ-NP-Za-km-z`<br>(`0 I O l` omitted.)<br>The numeral scheme used in [Bitcoin addresses](https://en.bitcoin.it/wiki/Base58Check_encoding). |
+| `BaseX::FlickrBase58`                                              | `"Jf78UmWajjF"`          | `1-9a-km-zA-HJ-NP-Z`<br>(`0 I O l` omitted.)<br>The numeral scheme in [Flickr short URLs](https://www.flickr.com/groups/api/discuss/72157616713786392/). Same as Bitcoin, but lowercase preceeds uppercase. |
+| `BaseX::GMPBase58`                                                 | `"gE67qKs9IId"`          | `0-9A-Za-v`<br>(`w x y z` omitted.)<br>The numeral scheme used for [base conversions in the GMP arbitary-precision math library](https://gmplib.org/manual/Converting-Integers.html). |
+| `BaseX::NewBase60`                                                 | `"W5pTz7hmhxF"`          | `0-9A-HJ-NP-Z_a-km-z`<br>(`I O l` omitted, `_` added.)<br>A [scheme by Tantek Çelik](http://tantek.pbworks.com/w/page/19402946/NewBase60), originally for use in a URL shortener. The "_" still allows the whole text to be selected when double-clicking. |
+| `BaseX::Base62` `BaseX::Base62DUL`                                 | `"LgLY9aNSIf5"`          | `0-9A-Za-z`<br>All alphanumeric characters: digits then uppercase then lowercase. |
+| `BaseX::Base62DLU`                                                 | `"lGly9AnsiF5"`          | `0-9a-zA-Z`<br>All alphanumeric characters: digits then lowercase then uppercase. |
+| `BaseX::Base62LDU`                                                 | `"vGv8jAx2sFf"`          | `a-z0-9A-Z`<br>All alphanumeric characters: lowercase then digits then uppercase. |
+| `BaseX::Base62LUD`                                                 | `"vQvIjKxCsPf"`          | `a-zA-Z0-9`<br>All alphanumeric characters: lowercase then uppercase then digits. |
+| `BaseX::Base62UDL`                                                 | `"VgV8JaX2SfF"`          | `A-Z0-9a-z`<br>All alphanumeric characters: uppercase then digits then lowercase. |
+| `BaseX::Base62ULD`                                                 | `"VqViJkXcSpF"`          | `A-Za-z0-9`<br>All alphanumeric characters: uppercase then lowercase then digits. |
+| `BaseX::URLBase64`                                                 | `"PyOPJF9WDaL"`          | `A-Za-z0-9-_`<br>(`- _` added.)<br>Alphanumerics plus `-` and `_`. Intended as a base 64 that can be used in URLs; part of [RFC 4648](http://tools.ietf.org/html/rfc4648#page-7). I find URL base 64 annoying because double-clicking won't select through the `-`. |
+| `BaseX::Z85`                                                       | `"]MO]Dt%j>*"`           | `0-9a-zA-Z.-:+=^!/*?&<>()[]{}@%$#`<br>(`. - : + = ^ ! / * ? & < > ( ) [ ] { } @ % $ #` added.)<br>The base 85 numerals used for [ZeroMQ Z85](http://rfc.zeromq.org/spec:32), an encoding standard optimized for 4-byte words and for pasting into single-quoted strings. |
+| `BaseX::Base256`                                                   | `"\xFC\x8E<\x91}X6\x8B"` | `"\x00"-"\xFF"`<br>Byte 0 through byte 255; useful for convert binary strings into a number and back. Used internally by BaseX. |
+
+Note that although the number schemes from various standards are represented here, BaseX is a number converter only: it does not do padding or other standard-specific details. BaseX is not, for example, a Z85 compliant encoder/decoder. You could, however, easily build one with BaseX.
+
+In Ruby, you can uses `BaseX.bases` and `BaseX.print_bases` to get information similar to the above table.
+
+```
+> BaseX.print_bases
+Binary          2   111111001000111000111… 01
+Base16          16  fc8e3c917d58368b       0123456789abcdef
+Base16L         16  fc8e3c917d58368b       0123456789abcdef
+Base16U         16  FC8E3C917D58368B       0123456789ABCDEF
+Hex             16  fc8e3c917d58368b       0123456789abcdef
+Hexadecimal     16  fc8e3c917d58368b       0123456789abcdef
+Base30L         30  369be5e68tfqth         23456789abcdefghjkmnpqrstvwxyz
+...
+```
+
+### BaseX.base(n)
+
+In addition to the named constants above, you can also quickly generate any alphanumeric base between 2 and 62. This could be handy becuase Ruby's `to_i` and `to_s` methods only support bases 2 to 36.
+
+```ruby
+BaseX.base(49).integer_to_string(456724510)
+# => "1UB4UI"
+BaseX.base(49).string_to_integer("1UB4UI")
+# => 456724510
+
+# The order of numerals is digits then uppercase then lowercase
+BaseX.base(49).numerals
+# => "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklm"
+```
+
+## Use Base30L
+
+If you want your text to be transferred by any means other than copy-paste, I recommend `BaseX::Base30L`. Tokens have a bad habit of landing in places where they cannot be copied and pasted. Anecdotal evidence from my recent past:
+
+- There was an infographic that had cited URLs baked into the image. I wanted to check the sources but could not copy the URLs, so I had to retype them. Also, some of the URLs had "O"'s in them.
+- I recently transferred a shared secret from one computer to another "off the wire". I had my mother read the secret out loud from the other computer. Happily, the secret did not have mixed case: saying "capital L, lowercase u" would have doubled the tedium.
+
+You can't predict what people are going to do with your encoded text, so it makes sense to be prepared.
+
+## Edge Cases
+
+Even though `"".to_i` is `0` in Ruby, BaseX's `string_to_integer` will reject empty strings with a `BaseX::EmptyString` error. An empty string here is probably a bug in your code. (In contrast, the `encode` and `decode` functions do accept empty strings.)
+
+If you try to convert a string that uses a character not in the base, a `BaseX::InvalidNumeral` error will be raised.
+
+## Limitations
+
+If you try to encode/decode in a numeral system larger than base 256 (why would you do this?!), leading 0 bytes may not be properly preserved. Integer conversion will still work as expected.
+
+## License
+
+Public Domain; no rights reserved.
+
+No restrictions are placed on the use of BaseX. That freedom also means, of course, that no warrenty of fitness is claimed; use BaseX at your own risk.
+
+Public domain dedication is explained by the CC0 1.0 summary (and only the summary) at https://creativecommons.org/publicdomain/zero/1.0/
+
+## Contributing
+
+1. Fork it ( http://github.com/brianhempel/base_x/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Run the tests with either `guard` or `minitest`
+4. Commit your changes (`git commit -am 'Add some feature'`)
+5. Push to the branch (`git push -u origin my-new-feature`)
+6. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+
+task :default => :test
+
+desc "Run the tests"
+task :test do
+  Dir.glob(File.expand_path("../test/*.rb", __FILE__)).each do |file|
+    require file
+  end
+end

data/base_x.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'base_x/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "base_x"
+  spec.version       = BaseX::VERSION
+  spec.authors       = ["Brian Hempel"]
+  spec.email         = ["plasticchicken@gmail.com"]
+  spec.summary       = %q{Convert numbers into and out of any base, also allows encoding and decoding binary data. Many bases included.}
+  spec.description   = spec.summary
+  spec.homepage      = "https://github.com/brianhempel/base_x"
+  spec.license       = "Public Domain"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+end

data/lib/base_x.rb

@@ -0,0 +1,201 @@
+require "base_x/version"
+
+class BaseX
+  class InvalidNumeral < RuntimeError
+    def initialize(invalid_char)
+      super "Can't convert to integer, '#{invalid_char}' is not in the numeral list for this base"
+    end
+  end
+
+  class EmptyString < RuntimeError
+    def initialize
+      super "Can't convert empty string into integer"
+    end
+  end
+
+  EXAMPLE_TOKEN = "\xFC\x8E\x3C\x91\x7D\x58\x36\x8B" # Random 64-bit token
+
+  def self.string_to_integer(string, opts)
+    opts[:numerals].respond_to?(:index) or
+      raise ArgumentError.new("A string of numerals must be provided, e.g. BaseX.string_to_integer(\"bcde\", numerals: \"abcdefg\")")
+    new(opts[:numerals]).string_to_integer(string)
+  end
+
+  def self.integer_to_string(int, opts)
+    opts[:numerals].respond_to?(:index) or
+      raise ArgumentError.new("A string of numerals must be provided, e.g. BaseX.integer_to_string(123, numerals: \"abcdefg\")")
+    new(opts[:numerals]).integer_to_string(int)
+  end
+
+  def self.encode(string, opts)
+    opts[:numerals].respond_to?(:index) or
+      raise ArgumentError.new("A string of numerals must be provided, e.g. BaseX.encode(\"Hello World\", numerals: \"abcdefg\")")
+    new(opts[:numerals]).encode(string)
+  end
+
+  def self.decode(encoded, opts)
+    opts[:numerals].respond_to?(:index) or
+      raise ArgumentError.new("A string of numerals must be provided, e.g. BaseX.encode(\"bcaffag\", numerals: \"abcdefg\")")
+    new(opts[:numerals]).decode(encoded)
+  end
+
+  def self.base(n)
+    n.between?(2, 62) or raise ArgumentError.new("Base #{n} is not valid; base must be at least 2 and at most 62")
+    digits_uppercase_lowercase = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+    new(digits_uppercase_lowercase[0...n])
+  end
+
+  # Outputs an array of [base name, base size, example, and numerals] for all built-in bases
+  def self.bases
+    constants
+      .map     { |const_name| [const_name, const_get(const_name)] }
+      .select  { |const_name, base| base.is_a?(BaseX) }
+      .sort_by { |const_name, base| [base.base, const_name.to_s] }
+      .map do |const_name, base|
+        [const_name.to_s, base.base, base.encode(EXAMPLE_TOKEN), base.numerals]
+      end
+  end
+
+  def self.bases_table
+    bases.map do |name, base_size, example, numerals|
+      example = example[0...21] + "…" if example.size > 22
+      [
+        name,
+        base_size,
+        example.inspect.include?("\\")  ? example.inspect  : example,
+        numerals.inspect.include?("\\") ? numerals.inspect : numerals,
+      ]
+    end.map do |array|
+      "%-15s %-3s %-22s %s" % array
+    end.join("\n")
+  end
+
+  def self.print_bases
+    puts bases_table
+  end
+
+  attr_reader :numerals
+  attr_reader :base
+
+  def initialize(numerals)
+    numerals.chars.size > 1 or
+      raise ArgumentError.new("Need at least two numerals to express numbers! Numeral given: #{numerals.inspect}") 
+    numerals.chars.size == numerals.chars.uniq.size or
+      raise ArgumentError.new("Duplicate characters found in numerals definition: #{numerals.inspect}") 
+    @numerals = numerals
+    @base     = numerals.size
+  end
+
+  def string_to_integer(string)
+    raise EmptyString.new unless string.size > 0
+    integer = 0
+    string.each_char do |char|
+      integer *= base
+      numeral_value = @numerals.index(char) or raise InvalidNumeral.new(char)
+      integer += numeral_value
+    end
+    integer
+  end
+
+  def integer_to_string(int)
+    return @numerals[0] if int == 0
+    string = ""
+    while int > 0
+      char = @numerals[int % base]
+      string << char
+      int /= base
+    end
+    string.reverse
+  end
+
+  def encode(string)
+    return "" if string.size == 0
+    int = string.each_byte.reduce(0) { |int, byte| int *= 256; int + byte }
+    encoded = integer_to_string(int)
+    string_number_size = 256**(string.size)
+    encoded_number_size = base**(encoded.size)
+
+    while encoded_number_size < string_number_size
+      encoded = @numerals[0] + encoded
+      encoded_number_size *= base
+    end
+
+    encoded
+  end
+
+  def decode(encoded)
+    return "" if encoded.size == 0
+    int = string_to_integer(encoded)
+    decoded = Base256.integer_to_string(int)
+    decoded_number_size = 256**(decoded.size)
+    encoded_number_size = base**(encoded.size)
+
+    # encoded_number_size / base < decoded_number_size <= encoded_number_size
+    while decoded_number_size <= encoded_number_size / base
+      decoded = "\x00" + decoded
+      decoded_number_size *= 256
+    end
+
+    decoded
+  end
+end
+
+digits    = ("0".."9").to_a
+uppercase = ("A".."Z").to_a
+lowercase = ("a".."z").to_a
+
+# Binary
+BaseX::Binary     = BaseX.new("01")
+
+# Base 16
+BaseX::Base16L     = BaseX.new((digits + %w[a b c d e f]).join)
+BaseX::Base16U     = BaseX.new((digits + %w[A B C D E F]).join)
+BaseX::Base16      = BaseX::Base16L
+BaseX::Hex         = BaseX::Base16
+BaseX::Hexadecimal = BaseX::Base16
+
+# Base 30, in case the number could change case
+# no "u" following Crockford's probabilistic fear of accidental obscenity
+# (I caluclate the probability of obscenity, with "u", is about 1 in 2^13
+# for any given random 3-letter string (about 1 in 8000); when encoding 128bit
+# tokens, after generating about 225 random tokens you have a 50% chance of
+# having produced an "obscene token".)
+BaseX::Base30L = BaseX.new((digits + lowercase - %w[0 1 i l o u]).join)
+BaseX::Base30U = BaseX.new((digits + uppercase - %w[0 1 I L O U]).join)
+
+# Base 31, in case the number could change case
+BaseX::Base31L = BaseX.new((digits + lowercase - %w[0 1 i l o]).join)
+BaseX::Base31U = BaseX.new((digits + uppercase - %w[0 1 I L O]).join)
+
+# Base 32 schemes
+BaseX::RFC4648Base32   = BaseX.new((uppercase + digits - %w[0 1 8 9]).join)
+BaseX::CrockfordBase32 = BaseX.new((digits + uppercase - %w[I L O U]).join)
+
+# Base58 schemes
+BaseX::BitcoinBase58 = BaseX.new((digits + uppercase + lowercase - %w[0 O I l]).join)
+BaseX::FlickrBase58  = BaseX.new((digits + lowercase + uppercase - %w[0 O I l]).join)
+BaseX::GMPBase58     = BaseX.new((digits + uppercase + lowercase - %w[w x y z]).join)
+BaseX::Base58        = BaseX::BitcoinBase58
+
+# NewBase60, has an underscore as per http://tantek.pbworks.com/w/page/19402946/NewBase60
+BaseX::NewBase60 = BaseX.new((digits + uppercase + %w[_] + lowercase - %w[O I l]).join)
+
+# Base62; digits, upper, lower
+BaseX::Base62DUL = BaseX.new((digits + uppercase + lowercase).join)
+BaseX::Base62DLU = BaseX.new((digits + lowercase + uppercase).join)
+BaseX::Base62LDU = BaseX.new((lowercase + digits + uppercase).join)
+BaseX::Base62LUD = BaseX.new((lowercase + uppercase + digits).join)
+BaseX::Base62UDL = BaseX.new((uppercase + digits + lowercase).join)
+BaseX::Base62ULD = BaseX.new((uppercase + lowercase + digits).join)
+BaseX::Base62    = BaseX::Base62DUL
+
+# URL Base 64
+BaseX::URLBase64 = BaseX.new((uppercase + lowercase + digits + %w[- _]).join)
+
+# ZeroMQ Base 85
+# Process your data back and forth between 4-byte and 5-byte chunks and you'll be compatible with the Z85 standard
+BaseX::Z85 = BaseX.new((digits + lowercase + uppercase + %w|. - : + = ^ ! / * ? & < > ( ) [ ] { } @ % $ #|).join)
+
+# Binary string encoding; turn binary strings into Bignums and back
+BaseX::Base256 = BaseX.new((0..255).map(&:chr).join)
+

data/lib/base_x/version.rb

@@ -0,0 +1,3 @@
+class BaseX
+  VERSION = "0.8.0"
+end

data/test/test_base_x.rb

@@ -0,0 +1,280 @@
+require 'bundler/setup'
+Bundler.require(:test)
+
+require 'base_x'
+require 'minitest/autorun'
+require 'minitest/reporters'
+MiniTest::Reporters.use! Minitest::Reporters::DefaultReporter.new
+
+class TestBaseX < Minitest::Test
+  def setup
+    @base_x = BaseX.new("012")
+  end
+
+  attr_reader :base_x
+
+
+  ### Instance Methods ###
+
+
+  def test_complains_if_numerals_has_duplicate_chars
+    BaseX.new("∫©¶çΩ≈") # no error
+    assert_raises(ArgumentError) { BaseX.new("∫©¶çΩ≈Ω") }
+  end
+
+  def test_complains_if_only_one_numeral
+    BaseX.new("∫©") # no error
+    assert_raises(ArgumentError) { BaseX.new("")  }
+    assert_raises(ArgumentError) { BaseX.new("∫") }
+  end
+
+  def test_string_to_integer
+    assert_equal 48, base_x.string_to_integer("01210")
+  end
+
+  def test_string_to_integer_errors_with_invalid_chars
+    assert_raises(BaseX::InvalidNumeral) do
+      base_x.string_to_integer("asdf")
+    end
+  end
+
+  def test_string_to_integer_errors_with_empty_string
+    assert_raises(BaseX::EmptyString) do
+      base_x.string_to_integer("")
+    end
+  end
+
+  def test_integer_to_string
+    assert_equal "1210", base_x.integer_to_string(48)
+  end
+
+  def test_0_to_string
+    assert_equal "0", base_x.integer_to_string(0)
+  end
+
+  def test_encode_decode_empty_string
+    assert_equal "", base_x.decode(base_x.encode(""))
+  end
+
+  def test_encode_decode_zeros
+    assert_equal "\x00\x00\x00\x00", base_x.decode(base_x.encode("\x00\x00\x00\x00"))
+  end
+
+  def test_encode_decode_stuff
+    assert_equal "stuff", base_x.decode(base_x.encode("stuff"))
+  end
+
+  def test_a_bunch_of_zero_strings_in_a_bunch_of_bases
+    (2..10).each do |base|
+      base_x = BaseX.new(('a'..'z').take(base).join)
+      (1..257).to_a.sample(20).each do |size|
+        assert_equal "\x00"*size, base_x.decode(base_x.encode("\x00"*size)), "problem with #{size} length zero string in base #{base}"
+      end
+    end
+  end
+
+  def test_a_bunch_of_random_strings_in_a_bunch_of_bases
+    (2..10).each do |base|
+      base_x = BaseX.new(('a'..'z').take(base).join)
+      (1..257).to_a.sample(20).each do |size|
+        string = SecureRandom.random_bytes(size)
+        assert_equal string.dup, base_x.decode(base_x.encode(string)), "problem encoding/decoding #{string.inspect} in base #{base}"
+      end
+    end
+  end
+
+
+  ### Class Methods ###
+
+
+  def test_integer_to_string_class_method
+    assert_equal "1210", BaseX.integer_to_string(48, numerals: "012")
+  end
+
+  def test_integer_to_string_claass_methods_complains_if_no_numerals_provided
+    assert_raises(ArgumentError) { BaseX.integer_to_string(48, numerals: Object.new) }
+  end
+
+  def test_string_to_integer_class_method
+    assert_equal 48, BaseX.string_to_integer("01210", numerals: "012")
+  end
+
+  def test_string_to_integer_claass_methods_complains_if_no_numerals_provided
+    assert_raises(ArgumentError) { BaseX.string_to_integer("01210", numerals: Object.new) }
+  end
+
+  def test_encode_decode_class_methods
+    assert_equal "stuff", BaseX.decode(BaseX.encode("stuff", numerals: "012"), numerals: "012")
+  end
+
+  def test_encode_class_method_complains_if_no_numerals_provided
+    assert_raises(ArgumentError) { BaseX.encode("stuff", numerals: Object.new) }
+  end
+
+  def test_decode_class_method_complains_if_no_numerals_provided
+    assert_raises(ArgumentError) { BaseX.decode("stuff", numerals: Object.new) }
+  end
+
+  def test_base_class_method
+    assert_equal "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZab", BaseX.base(38).numerals
+  end
+
+  def test_base_class_method_errors
+    BaseX.base(2)  # no error
+    BaseX.base(62) # no error
+    assert_raises(ArgumentError) { BaseX.base(1) }
+    assert_raises(ArgumentError) { BaseX.base(63) }
+  end
+
+  def test_bases_class_method
+    assert_equal ["Binary", 2, "1111110010001110001111001001000101111101010110000011011010001011", "01"], BaseX.bases.first
+    expected_order = %w[
+      Binary
+      Base16
+      Base16L
+      Base16U
+      Hex
+      Hexadecimal
+      Base30L
+      Base30U
+      Base31L
+      Base31U
+      CrockfordBase32
+      RFC4648Base32
+      Base58
+      BitcoinBase58
+      FlickrBase58
+      GMPBase58
+      NewBase60
+      Base62
+      Base62DLU
+      Base62DUL
+      Base62LDU
+      Base62LUD
+      Base62UDL
+      Base62ULD
+      URLBase64
+      Z85
+      Base256
+    ]
+    assert_equal expected_order, BaseX.bases.map(&:first)
+  end
+
+  def test_bases_table_class_method
+    assert_equal String, BaseX.bases_table.class # it doesn't blow up
+  end
+
+
+  ### Base Constants ###
+
+
+  def test_binary
+    assert_equal "111010110111100110100010101",    BaseX::Binary.integer_to_string(123456789)
+    assert_equal "111010110111100110100010110001", BaseX::Binary.integer_to_string(987654321)
+  end
+
+  def test_base16L
+    assert_equal "75bcd15",  BaseX::Base16L.integer_to_string(123456789)
+    assert_equal "3ade68b1", BaseX::Base16L.integer_to_string(987654321)
+  end
+
+  def test_base16U
+    assert_equal "75BCD15",  BaseX::Base16U.integer_to_string(123456789)
+    assert_equal "3ADE68B1", BaseX::Base16U.integer_to_string(987654321)
+  end
+
+  def test_base30L
+    assert_equal "74eg8b",  BaseX::Base30L.integer_to_string(123456789)
+    assert_equal "3cnbspq", BaseX::Base30L.integer_to_string(987654321)
+  end
+    
+  def test_base30U
+    assert_equal "74EG8B",  BaseX::Base30U.integer_to_string(123456789)
+    assert_equal "3CNBSPQ", BaseX::Base30U.integer_to_string(987654321)
+  end
+
+  def test_base31L
+    assert_equal "6bq524",  BaseX::Base31L.integer_to_string(123456789)
+    assert_equal "35hft2u", BaseX::Base31L.integer_to_string(987654321)
+  end
+
+  def test_base31U
+    assert_equal "6BQ524",  BaseX::Base31U.integer_to_string(123456789)
+    assert_equal "35HFT2U", BaseX::Base31U.integer_to_string(987654321)
+  end
+
+  def test_rfc4648_base32
+    assert_equal "DVXTIV", BaseX::RFC4648Base32.integer_to_string(123456789)
+    assert_equal "5N42FR", BaseX::RFC4648Base32.integer_to_string(987654321)
+  end
+
+  def test_crockford_base32
+    assert_equal "3NQK8N", BaseX::CrockfordBase32.integer_to_string(123456789)
+    assert_equal "XDWT5H", BaseX::CrockfordBase32.integer_to_string(987654321)
+  end
+
+  def test_bitcoin_base58
+    assert_equal "BukQL",  BaseX::BitcoinBase58.integer_to_string(123456789)
+    assert_equal "2WGzDn", BaseX::BitcoinBase58.integer_to_string(987654321)
+  end
+
+  def test_flickr_base58
+    assert_equal "bUKpk",  BaseX::FlickrBase58.integer_to_string(123456789)
+    assert_equal "2vgZdM", BaseX::FlickrBase58.integer_to_string(987654321)
+  end
+
+  def test_gmp_base58
+    assert_equal "AqhNJ",  BaseX::GMPBase58.integer_to_string(123456789)
+    assert_equal "1TFvCj", BaseX::GMPBase58.integer_to_string(987654321)
+  end
+
+  def test_new_base60
+    assert_equal "9XZZ9",  BaseX::NewBase60.integer_to_string(123456789)
+    assert_equal "1GCURM", BaseX::NewBase60.integer_to_string(987654321)
+  end
+
+  def test_base62_dul
+    assert_equal "8M0kX",  BaseX::Base62DUL.integer_to_string(123456789)
+    assert_equal "14q60P", BaseX::Base62DUL.integer_to_string(987654321)
+  end
+
+  def test_base62_dlu
+    assert_equal "8m0Kx",  BaseX::Base62DLU.integer_to_string(123456789)
+    assert_equal "14Q60p", BaseX::Base62DLU.integer_to_string(987654321)
+  end
+
+  def test_base62_ldu
+    assert_equal "iwaK7",  BaseX::Base62LDU.integer_to_string(123456789)
+    assert_equal "beQgaz", BaseX::Base62LDU.integer_to_string(987654321)
+  end
+
+  def test_base62_lud
+    assert_equal "iwaUH",  BaseX::Base62LUD.integer_to_string(123456789)
+    assert_equal "be0gaz", BaseX::Base62LUD.integer_to_string(987654321)
+  end
+
+  def test_base62_udl
+    assert_equal "IWAk7",  BaseX::Base62UDL.integer_to_string(123456789)
+    assert_equal "BEqGAZ", BaseX::Base62UDL.integer_to_string(987654321)
+  end
+
+  def test_base62_uld
+    assert_equal "IWAuh",  BaseX::Base62ULD.integer_to_string(123456789)
+    assert_equal "BE0GAZ", BaseX::Base62ULD.integer_to_string(987654321)
+  end
+
+  def test_url_base64
+    assert_equal "HW80V", BaseX::URLBase64.integer_to_string(123456789)
+    assert_equal "63mix", BaseX::URLBase64.integer_to_string(987654321)
+  end
+
+  def test_z85
+    assert_equal "2v2B/", BaseX::Z85.integer_to_string(123456789)
+    assert_equal "i]jLP", BaseX::Z85.integer_to_string(987654321)
+  end
+
+  def test_base256
+    assert_equal "\x07\x5B\xCD\x15".force_encoding("ASCII-8BIT"), BaseX::Base256.integer_to_string(123456789)
+    assert_equal "\x3A\xDE\x68\xB1".force_encoding("ASCII-8BIT"), BaseX::Base256.integer_to_string(987654321)
+  end
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: base_x
+version: !ruby/object:Gem::Version
+  version: 0.8.0
+platform: ruby
+authors:
+- Brian Hempel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Convert numbers into and out of any base, also allows encoding and decoding
+  binary data. Many bases included.
+email:
+- plasticchicken@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby_version"
+- ".travis.yml"
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- base_x.gemspec
+- lib/base_x.rb
+- lib/base_x/version.rb
+- test/test_base_x.rb
+homepage: https://github.com/brianhempel/base_x
+licenses:
+- Public Domain
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Convert numbers into and out of any base, also allows encoding and decoding
+  binary data. Many bases included.
+test_files:
+- test/test_base_x.rb