bases 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 902a4986a5074750b2a81f17eaccb1e8bd944e3d
+  data.tar.gz: d639c6bb2b3b3f71f1a42dd009f046d2fe5bf721
+SHA512:
+  metadata.gz: 5377cb3c5ef10f7a28854c42f373cb3afbb43ad9b9c1e09a4f337607bec6c6d6c769e3979300b0eab1f7a8427cb87674637418da8ed02c65aac1f984e6d3db32
+  data.tar.gz: 9ec434e817b7563702b584c64f619a06000c410c5343744f8460786bf20f719b447346f482263e5277ea5e69f2b4299b30b577dbff75fba4915a9620512b7ca0

data/.coveralls.yml

@@ -0,0 +1 @@
+service_name: travis-ci

data/.gitignore

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

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 2.1.3
+  - 2.1.1
+  - 2.0.0
+  - 1.9.3

data/.yardopts

@@ -0,0 +1 @@
+--markup markdown --private

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Andrea Leopardi
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,174 @@
+# Bases
+
+[![Build Status](https://travis-ci.org/whatyouhide/bases.svg?branch=master)](https://travis-ci.org/whatyouhide/bases)
+[![Gem Version](https://badge.fury.io/rb/bases.svg)](http://badge.fury.io/rb/bases)
+[![Coverage Status](https://img.shields.io/coveralls/whatyouhide/bases.svg)](https://coveralls.io/r/whatyouhide/bases)
+[![Code Climate](https://codeclimate.com/github/whatyouhide/bases/badges/gpa.svg)](https://codeclimate.com/github/whatyouhide/bases)
+[![Dependency Status](https://gemnasium.com/whatyouhide/bases.svg)](https://gemnasium.com/whatyouhide/bases)
+[![Inline docs](http://inch-ci.org/github/whatyouhide/bases.svg?branch=master&style=flat)](http://inch-ci.org/github/whatyouhide/bases)
+
+Convert **from** and **to** any base you can think of.
+
+A bunch of features:
+
+* Convert to bases up to **whatever you want!**
+* Use custom bases defined as arrays, like this binary base: `['↑', '↓']`.
+* Use multicharacter digits.
+* Use **emojis** as digits!
+* Fall back to Ruby's `Integer#to_s` and `String#to_i` when the base is less
+    than 36.
+* Superdocumented, tested like shuttle launches were depending on it (this may
+    not be true).
+* Supports MRI Ruby (yeah, just Ruby) from version 1.9.3.
+
+
+## Why
+
+Ruby can convert bases, but only with bases up to 36. But converting to bigger
+basis is just as fun (if not even more!), since you can easily reduce the number
+of character used to represent a number.
+
+I only know of gem that does this, [radix][radix]. Radix isn't bad, but I don't
+like it because it monkeypatches everything. It provides the `b`
+method on strings, which on recent versions of Ruby is also a [default
+method][ruby-string-b].
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+``` ruby
+gem 'bases'
+```
+
+And then execute:
+
+```
+$ bundle
+```
+
+Or install it yourself as:
+
+``` bash
+$ gem install bases
+```
+
+
+## Usage
+
+The main hub for the usage of this gem is the `Bases.val` method.
+It takes a parameter that can be a bunch of things.
+
+* An integer: in this case, the source base is assumed to be the decimal base.
+* An array: no base is assumed, you have to manually specify it (keep reading!).
+    The array is assumed to be a list of digits (each element is a digit) from
+    the most significant one to the least significant one, like you'd expect.
+* A string: no base is assumed. If the string doesn't contain whitespace, each
+    character is assumed to be a digit; otherwise, whitespace is assumed to
+    separate multicharacter digits (wow, multicharacter digits!).
+
+The return value of `Bases.val` is junk (sort of), so you want to
+call some methods to specify a *source base* and a *destination base*.
+
+Those methods are the `in_base` and `to_base` methods:
+
+``` ruby
+Bases.val('100').in_base(2).to_base(10)  #=> '4'
+Bases.val('1111').in_base(2).to_base(16) #=> 'f'
+Bases.val('A').in_base(16).to_base(10)   #=> '10'
+```
+
+The `to_base` method always returns a `String`, even with `to_base(10)`. To
+overcome that, just call `to_i` on the string.
+
+When you pass an integer to `val`, base 10 is assumed:
+
+``` ruby
+Bases.val(10).to_base(Bases::HEX) #=> 'A'
+Bases.val(0b1011).to_base(2)                  #=> '1011'
+```
+
+#### Bracket syntax
+
+`Bases.val` is aliased to `Bases.[]`, so that you can
+easily create values with a clean syntax:
+
+``` ruby
+Bases[5].to_base(2) #=> '101'
+```
+
+#### Array bases
+
+You can use arrays everywhere you can use a base. The elements of the array will
+be the digits of the new base, from left to right. Defining a base through an
+array is easy:
+
+``` ruby
+# An alternative way of defining base 2:
+base2 = [0, 1]
+
+# A very cool alternative binary base:
+christmas_star_base = %w(+ ≈)
+
+# A (contrived) example of base64:
+base64 = ('A'..'Z').to_a + ('a'..'z').to_a + (0..9).to_a + %w(+ /)
+```
+
+#### Predefined bases
+
+Some default (common) bases are offered as constants:
+
+``` ruby
+Bases::B62    #=> base 62 (alphanumeric)
+Bases::B64    #=> base64
+```
+
+#### Common bases
+
+The gem provides a bunch of methods for dealing with common bases. These methods
+should be used in place of the `in_base` and `to_base` methods.
+
+They are:
+
+- `in_binary`/`to_binary`
+- `in_hex`/`to_hex` (`in_hex` solves the issue noted in the [hexadecimal base
+    section](#hex))
+
+Since the decimal is also common, a `to_i` method is included. This method
+returns an integer, not a string, in order to conform with the Ruby standard
+library.
+
+``` ruby
+Bases.val('1010').in_binary.to_i #=> 10
+```
+
+### Monkeypatching
+
+I can see the appeal of monkeypatching (can I?). So, you can specifically
+require to monkeypatch the `Integer`, `Array` and `String` Ruby classes:
+
+``` ruby
+# Instead of just 'bases':
+require 'bases/monkeypatches'
+
+2.to_base [:a, :b] #=> 'ba'
+10.to_binary #=> '1010'
+15.to_hex #=> 'f'
+
+'A'.in_hex.to_i #=> 10
+'baba'.in_base([:a, :b]).to_base(2) #=> '1010'
+
+['foo', 'bar'].in_base(['foo', 'bar', 'baz']).to_i #=> 1
+```
+
+
+## Contributing
+
+Fork, make changes, commit those changes, push to your fork, create a new Pull
+Request here. Thanks!
+
+
+
+[radix]: https://github.com/rubyworks/radix
+[ruby-string-b]: http://www.ruby-doc.org/core-2.1.3/String.html#method-i-b

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/*_test.rb']
+end
+
+# Default task is 'test', as used by Travis CI.
+task default: :test

data/bases.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'bases/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'bases'
+  spec.version       = Bases::VERSION
+  spec.authors       = ['Andrea Leopardi']
+  spec.email         = 'an.leopardi@gmail.com'
+  spec.summary       = 'Convert bases like a mofo.'
+  spec.homepage      = 'https://github.com/whatyouhide/bases'
+  spec.license       = 'MIT'
+  spec.description   = <<-DESC
+    This gem lets you convert integers from and to whatever base you like. You
+    can use array bases where you specify all the digits in the base,
+    multicharacter digits and other niceties.  By default, this gem avoids
+    monkeypatching core Ruby classes, but it can be configured to monkeypatch
+    too.
+  DESC
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake', '~> 10'
+  spec.add_development_dependency 'minitest', '~> 5'
+  spec.add_development_dependency 'minitest-reporters', '~> 1.0'
+  spec.add_development_dependency 'coveralls', '~> 0.7'
+end

data/lib/bases.rb

@@ -0,0 +1,24 @@
+# encoding: UTF-8
+
+# Constants
+require 'bases/version'
+require 'bases/constants'
+# Modules
+require 'bases/helpers'
+require 'bases/algorithms'
+# Classes
+require 'bases/number'
+
+# The main module.
+module Bases
+  # Create a new instance of `Number` from `value`.
+  # @param [String|Integer] value A value as in `Number.new`
+  # @return [Number]
+  def self.val(value)
+    Bases::Number.new(value)
+  end
+
+  class << self
+    alias_method :[], :val
+  end
+end

data/lib/bases/algorithms.rb

@@ -0,0 +1,43 @@
+# encoding: UTF-8
+
+# This module encapsulates the practical algorithms used to change bases.
+module Bases::Algorithms
+  # The common base conversion algorithm, which converts a number in base 10
+  # (`value`) to its value in base `new_base`.
+  # @param [Integer] value The value in base 10
+  # @param [Array<String>] new_base
+  # @return [Array<String>] An array of digits (as strings) from the most
+  #   significant to the least significant one
+  def self.convert_to_base(value, new_base)
+    # Return early if the is 0, as it is the first digit of the base array.
+    return [new_base.first] if value == 0
+
+    result = []
+    numeric_base = new_base.count
+
+    while value > 0
+      remainder = value % numeric_base
+      value /= numeric_base
+      result.unshift(new_base[remainder])
+    end
+
+    result
+  end
+
+  # Convert a value in a source base to an integer in base 10.
+  # @param [Array<String>] digits_ary An array of digits, from the most
+  #   significant to the least significant.
+  # @param [Array<String>] source_base A base expressed as a list of digits
+  # @return [Integer]
+  def self.convert_from_base(digits_ary, source_base)
+    # The numeric base is the number of digits in the source base.
+    numeric_base = source_base.count
+
+    digits_ary.reverse.each.with_index.reduce(0) do |value, (digit, position)|
+      #  The value of `digit` in the source base is simply the index of `digit`
+      #  in the `@source_base` array.
+      digit_value_in_base10 = source_base.find_index(digit)
+      value + (digit_value_in_base10 * (numeric_base**position))
+    end
+  end
+end

data/lib/bases/constants.rb

@@ -0,0 +1,32 @@
+# encoding: UTF-8
+
+module Bases
+  # Base 62, the alphanumeric characters.
+  B62 = (
+    ('A'..'Z').to_a +
+    ('a'..'z').to_a +
+    (0..9).to_a
+  ).map(&:to_s)
+
+  # Base 64.
+  # @see http://en.wikipedia.org/wiki/Base64.
+  B64 = B62 + %w(+ /)
+
+
+  # This error is thrown when an invalid value is passed to `Number`'s
+  # constructor.
+  InvalidValueError = Class.new(StandardError)
+
+  # This error is thrown when you try to convert a number without a specified
+  # base to another base.
+  NoBaseSpecifiedError = Class.new(StandardError)
+
+  # This error is thrown when there are digits in a value which aren't in the
+  # specified source base.
+  WrongDigitsError = Class.new(StandardError)
+
+  # This error is thrown when there are duplicates digits in a base.
+  # @example
+  #   bad_base_3 = [0, 1, 0]
+  DuplicateDigitsError = Class.new(StandardError)
+end

data/lib/bases/helpers.rb

@@ -0,0 +1,39 @@
+# encoding: UTF-8
+
+# Some miscellaneous helper functions.
+module Bases::Helpers
+  # Return `true` if there are duplicate elements in `ary`.
+  # @param [Array] ary
+  # @return [bool]
+  def self.are_there_duplicates?(ary)
+    ary.uniq.size != ary.size
+  end
+
+  # Return an array version of `base`. An *array version* of `base` means an
+  # array of **strings**. If `base` is already an array, a copy of that array
+  # but with all elements converted to strings is returned. If `base` is an
+  # integer (in base 10 :D) a range-like array going from 0 to `base` is
+  # returned.
+  # @param [Integer|Array] base
+  # @return [Array<String>]
+  # @raise [DuplicateDigitsError] if there are duplicate digits in the base (if
+  #   it was passed as an array).
+  def self.base_to_array(base)
+    base = (base.is_a?(Array) ? base : (0...base)).map(&:to_s)
+
+    if are_there_duplicates?(base)
+      fail Bases::DuplicateDigitsError,
+        'There are duplicate digits in the base'
+    else
+      base
+    end
+  end
+
+  # Check whether `digits` contains some digits that are not in `base`.
+  # @param [Array<String>] digits An array of digits
+  # @param [Array] base The base expressed as an array as everywhere else
+  # @return [boolean]
+  def self.only_valid_digits?(digits, base)
+    digits.all? { |digit| base.include?(digit) }
+  end
+end

data/lib/bases/monkeypatches.rb

@@ -0,0 +1,6 @@
+# encoding: UTF-8
+
+require 'bases'
+require 'bases/monkeypatches/integer'
+require 'bases/monkeypatches/string'
+require 'bases/monkeypatches/array'

data/lib/bases/monkeypatches/array.rb

@@ -0,0 +1,29 @@
+# encoding: UTF-8
+
+# Some monkeypatches to the `Array` class.
+class Array
+  # Return a `Bases::Number` instance with the current array as the
+  # value and the source base set to `base`.
+  # @param (see Bases::Number#in_base)
+  # @return [Number]
+  # @see Bases::Number#in_base
+  def in_base(base)
+    Bases.val(self).in_base(base)
+  end
+
+  # Return a `Bases::Number` instance with the current array as the
+  # value and the source base set to the binary base.
+  # @return [Number]
+  # @see Bases::Number#in_binary
+  def in_binary
+    Bases.val(self).in_binary
+  end
+
+  # Return a `Bases::Number` instance with the current array as the
+  # value and the source base set to the hexadecimale base.
+  # @return [Number]
+  # @see Bases::Number#in_hex
+  def in_hex
+    Bases.val(self).in_hex
+  end
+end

data/lib/bases/monkeypatches/integer.rb

@@ -0,0 +1,26 @@
+# encoding: UTF-8
+
+# Some monkeypatches to the `Integer` class.
+class Integer
+  # Convert this number to a given `base`.
+  # @param (see Bases::Number#to_base)
+  # @return [String]
+  # @see Bases::Number#to_base
+  def to_base(base, opts = {})
+    Bases.val(self).to_base(base, opts)
+  end
+
+  # Convert this number in binary form.
+  # @return [String]
+  # @see Bases::Number#to_binary
+  def to_binary
+    to_base(2)
+  end
+
+  # Convert this number in hexadecimal form.
+  # @return [String]
+  # @see Bases::Number#to_hex
+  def to_hex
+    to_base(16)
+  end
+end

data/lib/bases/monkeypatches/string.rb

@@ -0,0 +1,29 @@
+# encoding: UTF-8
+
+# Some monkeypatches to the `String` class.
+class String
+  # Return a `Bases::Number` instance with the current string as the
+  # value and the source base set to `base`.
+  # @param (see Bases::Number#in_base)
+  # @return [Number]
+  # @see Bases::Number#in_base
+  def in_base(base)
+    Bases.val(self).in_base(base)
+  end
+
+  # Return a `Bases::Number` instance with the current string as the
+  # value and the source base set to the binary base.
+  # @return [Number]
+  # @see Bases::Number#in_binary
+  def in_binary
+    Bases.val(self).in_binary
+  end
+
+  # Return a `Bases::Number` instance with the current string as the
+  # value and the source base set to the hexadecimale base.
+  # @return [Number]
+  # @see Bases::Number#in_hex
+  def in_hex
+    Bases.val(self).in_hex
+  end
+end

data/lib/bases/number.rb

@@ -0,0 +1,164 @@
+# encoding: UTF-8
+
+# The main class provided by Bases. It represents a base-agnostic
+# number which can be forced to be interpreted in any base and then converted in
+# any base.
+class Bases::Number
+  # Create a new instance from a given `value`. If that value is an intance of a
+  # subclass of `Integer` (a `Bignum` or a `Fixnum`), it will be assumed to be
+  # in base 10 and any call to `in_base` on the new instance will result in an
+  # exception.
+  #
+  # If it is a `String`, no base will be assumed; if there are spaces
+  # in the string, they're used to separate the *multicharacter* digits,
+  # otherwise each character is assumed to be a digit.
+  #
+  # It `value` is an `Array`, each element in the array is assumed to be a
+  # digit. The array is read like a normal number, where digits on the left are
+  # more significative than digits on the right.
+  #
+  # @param [Integer|String|Array] value
+  # @raise [InvalidValueError] if `value` isn't a `String`, an `Integer` or an
+  #   `Array`
+  def initialize(value)
+    case value
+    when Integer
+      @source_base = helpers.base_to_array(10)
+      @value = value
+    when String
+      @digits = (value =~ /\s/) ? value.split : value.split('')
+    when Array
+      @digits = value.map(&:to_s)
+    else
+      fail Bases::InvalidValueError, "#{value} isn't a valid value"
+    end
+  end
+
+  # Set the source base of the current number. The `base` can be either a number
+  # (like 2 for binary or 16 for hexadecimal) or an array. In the latter case,
+  # the array is considered the whole base. For example, the binary base would
+  # be represented as `[0, 1]`; another binary base could be `[:a, :b]` and so
+  # on.
+  #
+  # **Note** that when the base is an integer up to 36, the native Ruby
+  # `Integer#to_i(base)` method is used for efficiency and clarity. However,
+  # this means that digits in a base 36 are numbers *and* letters, while digits
+  # in base 37 and more are only numbers (interpreted as multichar digits).
+  #
+  # `self` is returned in order to allow nice-looking chaining.
+  #
+  # @param [Integer|Array] base
+  # @return self
+  # @raise [WrongDigitsError] if there are digits in the previously specified
+  #   value that are not present in `base`.
+  def in_base(base)
+    @source_base = helpers.base_to_array(base)
+
+    if native_ruby_base?(base)
+      @value = @digits.join('').to_i(base)
+      return self
+    end
+
+    # Make sure `@digits` contains only valid digits.
+    unless helpers.only_valid_digits?(@digits, @source_base)
+      fail Bases::WrongDigitsError,
+        "Some digits weren't in base #{base}"
+    end
+
+    @value = algorithms.convert_from_base(@digits, @source_base)
+    self
+  end
+
+  # Return a string representation of the current number in a `new_base`.
+  # A **string** representation is always returned, even if `new_base` is 10. If
+  # you're using base 10 and want an integer, just call `to_i` on the resulting
+  # string.
+  #
+  # @example With the default separator
+  #   Number.new(3).to_base(2) #=> '11'
+  # @example With a different separator
+  #   Number.new(3).to_base(2, separator: ' ~ ') #=> '1 ~ 1'
+  #
+  # @param [Integer|Array] new_base The same as in `in_base`
+  # @param [Hash] opts A small hash of options
+  # @option opts [bool] :array If true, return the result as an array of digits;
+  #   otherwise, return a string. This defaults to `false`.
+  # @return [Array<String>|String]
+  # @raise [NoBaseSpecifiedError] if no source base was specified (either by
+  #   passing an integer to the constructor or by using the `in_base` method)
+  def to_base(new_base, opts = {})
+    opts[:array] = false if opts[:array].nil?
+
+    unless defined?(@source_base)
+      fail Bases::NoBaseSpecifiedError, 'No base was specified'
+    end
+
+    # Let's apply the base conversion algorithm, which returns an array of
+    # digits.
+    res = if native_ruby_base?(new_base)
+            @value.to_s(new_base).split('')
+          else
+            algorithms.convert_to_base(@value, helpers.base_to_array(new_base))
+          end
+
+    opts[:array] ? res : res.join('')
+  end
+
+  # This function assumes you want the output in base 10 and returns an integer
+  # instead of a string (which would be returned after a call to `to_base(10)`).
+  # This was introduced so that `to_i` is adapted to the standard of returning
+  # an integer (in base 10, as Ruby represents integers).
+  # @return [Integer]
+  def to_i
+    to_base(10).to_i
+  end
+
+  # Specify that the current number is in hexadecimal representation.
+  # @note If you want to parse an hexadecimal number ignoring case-sensitivity,
+  #   you **can't** use `in_base(Bases::HEX)` since that assumes
+  #   upper case digits. You **have** to use `in_hex`, which internally just
+  #   calls `String#hex`.
+  # @return [self]
+  def in_hex
+    @source_base = helpers.base_to_array(16)
+    @value = @digits.join('').hex
+    self
+  end
+
+  # Specify that the current number is in binary representation. This is just a
+  # shortcut for `in_base(2)` or `in_base([0, 1])`.
+  # @return [self]
+  def in_binary
+    in_base(2)
+  end
+
+  # Just an alias to `to_base(2)`.
+  # @see Number#to_base
+  # @return [String]
+  def to_binary
+    to_base(2)
+  end
+
+  # Just an alias to `to_base(Bases::HEX)`.
+  # @see Numer#to_base
+  # @return [String]
+  def to_hex
+    to_base(16)
+  end
+
+  private
+
+  def native_ruby_base?(base)
+    base.is_a?(Fixnum) && base.between?(2, 36)
+  end
+
+  # A facility method for accessing the `Algorithms` module.
+  def algorithms
+    Bases::Algorithms
+  end
+
+  # A facility method for accessing the `Helpers` module.
+  def helpers
+    Bases::Helpers
+  end
+end

data/lib/bases/version.rb

@@ -0,0 +1,6 @@
+# encoding: UTF-8
+
+module Bases
+  # The version of the Bases gem.
+  VERSION = '1.0.0'
+end

data/test/helpers_test.rb

@@ -0,0 +1,34 @@
+# encoding: UTF-8
+
+require_relative 'test_helper'
+
+class HelpersTest < Minitest::Test
+  def test_are_there_duplicates?
+    assert helpers.are_there_duplicates?([0, 1, 0])
+    assert helpers.are_there_duplicates?([2, 2, 2])
+    assert helpers.are_there_duplicates?([nil, nil])
+    refute helpers.are_there_duplicates?([])
+    refute helpers.are_there_duplicates?([1, '1'])
+  end
+
+  def test_base_to_array
+    assert_equal %w(0 1), helpers.base_to_array(2)
+    assert_equal %w(0 1), helpers.base_to_array([0, 1])
+    assert_equal (0...10).map(&:to_s), helpers.base_to_array(10)
+    assert_equal %w(foo bar), helpers.base_to_array(%w(foo bar))
+  end
+
+  def test_only_valid_digits
+    assert helpers.only_valid_digits?(%w(f o o), %(f o))
+    assert helpers.only_valid_digits?(%w(f o o), %(foo bar))
+    assert helpers.only_valid_digits?(%w(foo bar foo), %(foo bar))
+    refute helpers.only_valid_digits?(%w(foo bar baz), %(foo bar))
+    refute helpers.only_valid_digits?(%w(012), %(0 1))
+  end
+
+  private
+
+  def helpers
+    Bases::Helpers
+  end
+end

data/test/misc_test.rb

@@ -0,0 +1,32 @@
+# encoding: UTF-8
+
+require_relative 'test_helper'
+
+class MiscTest < Minitest::Test
+  def test_some_basic_bases_are_defined
+    assert_const_defined :B62
+    assert_const_defined :B64
+  end
+
+  def test_val
+    assert_respond_to mod, :val
+    assert_instance_of mod::Number, mod.val(33)
+  end
+
+  def test_brackets
+    assert_respond_to mod, :[]
+    assert_instance_of mod::Number, mod[0xba]
+    assert_equal 044, mod['44'].in_base(8).to_i
+  end
+
+  private
+
+  def assert_const_defined(const)
+    assert mod.const_defined?(const),
+      "#{const} is not defined in module #mod"
+  end
+
+  def mod
+    Bases
+  end
+end

data/test/monkeypatches_test.rb

@@ -0,0 +1,46 @@
+# encoding: UTF-8
+
+require_relative 'test_helper'
+require_relative '../lib/bases/monkeypatches'
+
+module MonkeypatchesTests
+  class IntegerTest < Minitest::Test
+    def test_to_base
+      assert_equal '10', 10.to_base(10)
+      assert_equal '10', 0b1010.to_base(10)
+      assert_equal 'A', 0xa.to_base(16).upcase
+
+      assert_equal %w(1 0), 2.to_base(2, array: true)
+    end
+
+    def test_common_methods
+      assert_equal '1010', 10.to_binary
+      assert_equal 'A', 10.to_hex.upcase
+    end
+  end
+
+  class StringTest < Minitest::Test
+    def test_in_base
+      assert_equal '2', '10'.in_base(2).to_hex
+      assert_equal '1010', 'A'.in_base(16).to_base(2)
+      assert_equal '1010', 'baba'.in_base([:a, :b]).to_base(2)
+    end
+
+    def test_common_methods
+      assert_equal 2, '10'.in_binary.to_i
+      assert_equal 2, 'bar foo'.in_base(%w(foo bar)).to_i
+      assert_equal 10, 'a'.in_hex.to_i
+    end
+  end
+
+  class ArrayTest < Minitest::Test
+    def test_in_base
+      assert_equal 11, [1, 0, 1, 1].in_base(2).to_i
+    end
+
+    def test_common_methods
+      assert_equal 2, [1, 0].in_binary.to_i
+      assert_equal 171, ['a', 'b'].in_hex.to_i
+    end
+  end
+end

data/test/number_test.rb

@@ -0,0 +1,138 @@
+# encoding: UTF-8
+
+require_relative 'test_helper'
+require 'digest'
+
+class NumberTest < Minitest::Test
+  BASE64 = Bases::B64
+
+  NUMBERS_FROM_BASE10 = [
+    { base10: 0,  base: 2,       value: '0' },
+    { base10: 1,  base: 2,       value: '1' },
+    { base10: 2,  base: 2,  value: '10' },
+    { base10: 4,  base: 2,  value: '100' },
+    { base10: 9,  base: 2,  value: '1001' },
+    { base10: 0,  base: 16,     value: '0' },
+    { base10: 15, base: 16,     value: 'f' },
+    { base10: 16, base: 16,     value: '10' },
+    { base10: 3,  base: 3,       value: '10' },
+    { base10: 0,  base: %w(≈ y), value: '≈' },
+    { base10: 8,  base: %w(≈ +), value: '+≈≈≈' },
+    { base10: 63, base: BASE64,  value: '/' }
+  ]
+
+  def test_from_base10_integer_to_any_base
+    NUMBERS_FROM_BASE10.each do |num_data|
+      result = n(num_data[:base10]).to_base(num_data[:base])
+      assert_equal num_data[:value], result
+    end
+  end
+
+  def test_from_any_base_to_base10
+    NUMBERS_FROM_BASE10.each do |num_data|
+      result = n(num_data[:value]).in_base(num_data[:base]).to_i
+      assert_equal num_data[:base10], result
+    end
+  end
+
+  def test_easy_to_see_numbers_and_identities
+    assert_equal 'fade', n(0xfade).to_base(16).downcase
+    assert_equal '71', n(071).to_base(8)
+    assert_equal '1010110', n(0b1010110).to_base(2)
+
+    assert_equal '10', n('10').in_base(2).to_base(2)
+    assert_equal 10, n(10).to_i
+
+    val = 'fwrfwasgefrfqf1r3f43131'
+    assert_equal val, n(val).in_base(BASE64).to_base(BASE64)
+  end
+
+  def test_facility_methods
+    assert_equal 10, n('a').in_hex.to_base(10).to_i
+    assert_equal 10, n('1010').in_binary.to_base(10).to_i
+    assert_equal '1010', n(10).to_binary
+    assert_equal 'A', n(10).to_hex.upcase
+  end
+
+  def test_multichar_digits
+    assert_equal 2, n(%w(bar foo)).in_base(%w(foo bar)).to_i
+    assert_equal 1, n('hello world').in_base(%w(hello world)).to_i
+  end
+
+  def test_duplicate_digits_are_checked
+    ex = Bases::DuplicateDigitsError
+    assert_raises(ex) { n(2).to_base([0, 1, 0]) }
+    assert_raises(ex) { n('foo bar').in_base(%w(foo foo)) }
+  end
+
+  def test_initial_value_type_is_checked
+    ex = Bases::InvalidValueError
+
+    assert_raises(ex) { n({}) }
+    assert_raises(ex) { n(nil) }
+    assert_raises(ex) { n(0..10) }
+    assert_raises(ex) { n(Object.new) }
+  end
+
+  def test_digits_are_checked_for_belonging_to_the_base
+    ex = Bases::WrongDigitsError
+    assert_raises(ex) { n('foo bar baz').in_base(%w(foo bar)) }
+  end
+
+  def test_an_exception_is_thrown_if_no_base_is_specified
+    ex = Bases::NoBaseSpecifiedError
+    assert_raises(ex) { n('10').to_base(10) }
+    assert_raises(ex) { n('A').to_i }
+    assert_raises(ex) { n(%w(foo bar)).to_base(3) }
+    assert_raises(ex) { n([0, 2]).to_i }
+  end
+
+  def test_leading_zeros_are_harmless
+    assert_equal 2, n('00000010').in_base(2).to_i
+    assert_equal 10, n('0a').in_hex.to_i
+    assert_equal 1, n(%w(foo bar)).in_base(%w(foo bar)).to_i
+  end
+
+  def test_to_i
+    assert_equal 10, n('A').in_base(16).to_i
+    assert_equal 10, n('a').in_base(16).to_i
+    assert_equal 10, n('1010').in_base(2).to_i
+  end
+
+  def test_edge_cases
+    assert_equal 0, n([]).in_base(2).to_i
+    assert_equal 0, n('').in_base(10).to_i
+  end
+
+  def test_bignums_are_supported
+    value = n('//////////////').in_base(BASE64).to_i
+    assert_instance_of Bignum, value
+
+    # MD5 are hex numbers, very big ones too!
+    hex = Digest::MD5.hexdigest('foo bar')
+
+    # They convert easily to bignums...
+    assert_instance_of Bignum, n(hex).in_base(16).to_i
+
+    # ...and to base 3 numbers (check that the resulting number is composed of
+    # only the 0, 1 and 2 digits.
+    binary_digits = n(hex).in_base(16).to_base(3)
+      .split('').uniq.map(&:to_i).sort
+    assert_equal [0, 1, 2], binary_digits
+  end
+
+  def test_to_base_outputting_an_array
+    assert_equal %w(b a b a), n(10).to_base([:a, :b], array: true)
+    assert_equal %w(1 0), n(2).to_base(2, array: true)
+  end
+
+  def test_emojis_are_fun_and_💙
+    assert_equal '💙💚', n(2).to_base(['💚', '💙'])
+  end
+
+  private
+
+  def n(val)
+    Bases::Number.new(val)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,13 @@
+# encoding: UTF-8
+
+# Coveralls coverage metrics.
+require 'coveralls'
+Coveralls.wear!
+
+require 'minitest/autorun'
+require 'minitest/pride'
+require 'minitest/reporters'
+
+require_relative '../lib/bases'
+
+Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: bases
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Andrea Leopardi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+description: |2
+      This gem lets you convert integers from and to whatever base you like. You
+      can use array bases where you specify all the digits in the base,
+      multicharacter digits and other niceties.  By default, this gem avoids
+      monkeypatching core Ruby classes, but it can be configured to monkeypatch
+      too.
+email: an.leopardi@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".coveralls.yml"
+- ".gitignore"
+- ".travis.yml"
+- ".yardopts"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bases.gemspec
+- lib/bases.rb
+- lib/bases/algorithms.rb
+- lib/bases/constants.rb
+- lib/bases/helpers.rb
+- lib/bases/monkeypatches.rb
+- lib/bases/monkeypatches/array.rb
+- lib/bases/monkeypatches/integer.rb
+- lib/bases/monkeypatches/string.rb
+- lib/bases/number.rb
+- lib/bases/version.rb
+- test/helpers_test.rb
+- test/misc_test.rb
+- test/monkeypatches_test.rb
+- test/number_test.rb
+- test/test_helper.rb
+homepage: https://github.com/whatyouhide/bases
+licenses:
+- MIT
+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 bases like a mofo.
+test_files:
+- test/helpers_test.rb
+- test/misc_test.rb
+- test/monkeypatches_test.rb
+- test/number_test.rb
+- test/test_helper.rb
+has_rdoc: