base_convert 2.2.0 → 3.0.191214

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: e753042b328396548538387c9494a3acf86541d9
-  data.tar.gz: 1c390e5702aaed4264d1910bac2869c7282205cb
+SHA256:
+  metadata.gz: 143b58ce952648fedb71d60c1b428438820b9b39b47c2cb58a54efa06695b6f3
+  data.tar.gz: 78917a3080a0cdb82dfd2cc626e958b7f988b38da047dba56ca7ba306279238b
 SHA512:
-  metadata.gz: f62bcf42823b88be9141e42861966d57bfb95192fb5a04b99bb91402b788349c1008d719e942a4012977066e4954ba790f7789378470ce96a1caef471ad27bcd
-  data.tar.gz: 0d1a75b8292188192ec18c95948f3b9c80c1d52f321c00a2df48b9fdce3f28fb36848554210eb92fece961935d6563615cd55be94ca12c55a936ff8bf818ed54
+  metadata.gz: bb733ffdba99c28b82cefca3150f7c08768b1e11f0385cdcfc8be9e9f2865546baf956a97b9da9fa4685599ab449990ccee485414f22f81580ba2ef6049807ee
+  data.tar.gz: 95d9a9dc8764a6ce432facbc7917760ee2d94df31ea066408ec6c45b978abd5e3a6cfefd3a43ca193f05ea2dbea802814f95ad6b6701c5e4001acce6122abe7e

data/README.md

@@ -17,139 +17,137 @@ See also rosettacode.org's [Non-decimal radices convert](http://rosettacode.org/
 ## SYNOPSIS:
 
     require 'base_convert'
-    include BaseConvert
-    h2o = FromTo.new(16, 8)
-    o2h = FromTo.new(8, 16)
-    a = h2o.convert('FFFF') #=> "177777"
-    b = o2h.convert('177777') #=> "FFFF"
+
+    #toi string, base, digits #=> integer
+    BaseConvert.toi 'FF', 16, '0123456789ABCDEF' #=> 255
+
+    #tob integer, base, digits #=> string
+    BaseConvert.tob 255, 16, '0123456789ABCDEF' #=> "FF"
+
+    # FromTo
+    c = BaseConvert::FromTo.new base: 16, digits: '0123456789ABCDEF', to_base: 7, to_digits: 'abcdefg'
+    c['FFF'] #=> "begea"
+
+    # Number
+    n = BaseConvert::Number.new 'FF', base: 16, digits: '0123456789ABCDEF'
+    n.to_i #=> 255
+    n.to_s #=> "FF"
+    #
+    n = n.to_base 64, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
+    n.to_s #=> "D/"
+    n.to_i #=> 255
+
+## INSTALL:
+
+    $ gem install base_convert
 
 ## BUT WAIT, THERE'S MORE:
 
 Using `irb` to demonstrate the features.
 The components are scoped under `BaseConvert`:
 
-    # irb
-    # Welcome to IRB...
-    require 'base_convert' #=> true
-    include BaseConvert #=> Object
+    > irb
+    Welcome to IRB...
+    >> require 'base_convert' #=> true
+    >> include BaseConvert #=> Object
 
 `base_convert` provides three ways to convert a string representation of a number.
 The first is functional.  One can extend(import) the functions that do the conversions.
-The conversion functions are `to_integer` and `to_base`.
+The conversion functions are `toi` and `tob`.
 For example, the octal number "7777":
 
-    extend Functions #=> main
+    extend BaseConvert #=> main
     digits = '01234567'
     base = digits.length #=> 8
-    to_integer('7777', base, digits) #=> 4095
-    to_base(4095, base, digits) #=> "7777"
+    toi('7777', base, digits) #=> 4095
+    tob(4095, base, digits) #=> "7777"
 
 You can work with arbitrary digits:
 
     digits = ')!@#$%^&'
     base = digits.length #=> 8
-    to_integer('&&&&', base, digits) #=> 4095
-    to_base(4095, base, digits) #=> "&&&&"
-
-For convenience, `base_convert` provides some predefined sets of digits.
-`GRAPH` are the ASCII graph characters.
-`QGRAPH` are the ASCII graph characters except quotes: double-quote, single-quote, and back-tick.
-`WORD_` are the ASCII word characters including underscore(_).
-`WORD` are the ASCII word characters except underscore(_).
-`UNAMBIGUOUS` are the characters in `WORD` without the `AMBIGUOUS` characters(B8G6I1l0OQDS5Z2).
+    toi('&&&&', base, digits) #=> 4095
+    tob(4095, base, digits) #=> "&&&&"
 
-    Configuration::WORD #=> "01...AB...ab...yz"
-    Configuration::QGRAPH #=> "!#...01...AB...ab...}~"
-    to_base(4095, 8, Configuration::WORD) #=> "7777"
-    to_base(4095, 8, Configuration::QGRAPH) #=> "****"
+For convenience, `base_convert` provides under `module BaseConvert::Configuration` some predefined sets of digits.
 
-The second way to convert is via a conversion object of `BaseConvert::FromTo`.
-For example, to convert from hexadecimal to octal, and back:
+* `GRAPH` are the ASCII graph characters.
+* `QGRAPH` are the ASCII graph characters except quotes: double-quote, single-quote, and back-tick.
+* `BASE64` is the standard base 64 digits from people with no sense of order.
+* `WORD_` are the ASCII word characters including underscore(`_`).
+* `WORD` are the ASCII word characters except underscore(`_`).
+* `UNAMBIGUOUS` are the characters in `WORD` without the `AMBIGUOUS` characters(B8G6I1l0OQDS5Z2).
 
-    h2o = FromTo.new(16, 8)
-    o2h = FromTo.new(8, 16)
-    h2o.convert('FFFF') #=> "177777"
-    o2h.convert('177777') #=> "FFFF"
-
-You can access the conversion alphabets via
-the accessors `FromTo#from_digits` and `FromTo#to_digits`.
-By default, WORD is used for bases upto 62.
-For bigger bases upto 91, QGRAPH is used.
-You can have bigger bases, but
-you will need to come up with a bigger alphabet, perhaps
-by adding greek letters.
-Note that when there's no ambiguity while using WORD,
-FromTo will upcase the string.
-
-    h2o.convert('FFFF') #=> "177777"
-    h2o.convert('ffff') #=> "177777"
-
-FromTo also makes available the intermediary methods that works with integers,
-FromTo#base2integer and FromTo#integer2Base:
-
-    h2o.base2integer('FFFF') #=> 65535
-    h2o.integer2base(65535) #=> "177777"
-
-The third way to convert is via the subclass of String, `BaseConvert::Number`:
-
-    hexadecimal = Number.new('FFFF', 16, Configuration::WORD) #=> "FFFF"
-    # WORD is the default alphabet
-    hexadecimal = Number.new('FFFF', 16) #=> "FFFF"
-    hexadecimal.to_integer #=> 65535
-    # The default base is 10.
-    decimal = Number.new('65535') # "65535"
-    decimal.to_integer #=> 65535
-    decimal.to_base(16) #=> "FFFF"
-    decimal.to_base(8) #=> "177777"
-    # You can also specify the digits to use
-    digits = ')!@#$%^&'
-    decimal.to_base(8, digits) #=> "!&&&&&"
+Some examples:
 
-## Keys (Symbols)
+    Configuration::UNAMBIGUOUS #=> "3479ACEFHJKLMNPRTUVWXYabcdefghijkmnopqrstuvwxyz"
+    # etc...
+    tob 255, 16, Configuration::WORD #=> "FF"
+    include Configuration
+    tob 255, 64, BASE64 #=> "D/"
 
-Instead of stating the base number, one can use a mnemonic key:
+The second way to convert is via a conversion object of `BaseConvert::FromTo`.
+For example, to convert from hexadecimal to octal, and back:
 
-    graph:       GRAPH
-    qgraph:      QGRAPH
-    word_:       WORD_
-    word:        WORD
-    unambiguous: UNAMBIGUOUS
-    hexadecimal: 16
-    hex:         16
-    decimal:     10
-    dec:         10
-    octal:       8
-    oct:         8
-    binary:      2
+    h2o = FromTo.new base: 16, to_base: 8
+    o2h = FromTo.new base: 8, to_base: 16
+    h2o['FFFF'] #=> "177777"
+    o2h['177777'] #=> "FFFF"
 
-The mnemonic key has the advantage of especifying both the base number and the digits to be used.
-Examples:
+The third way to work with variant base and digits numbers is via the `BaseConvert::Number`:
 
-    > require 'base_convert' # => true
-    > BaseConvert::Number.new('FF',  :hex).to_base(:dec)            #=> "255"
-    > BaseConvert::Number.new('255', :dec).to_base(:qgraph)         #=> "$m"
-    > BaseConvert::Number.new('$m',  :qgraph).to_base(:unambiguous) #=> "CX"
-    > BaseConvert::Number.new('CX',  :unambiguous).to_base(:oct)    #=> "377"
-    > BaseConvert::Number.new('377', :oct).to_base(:hexadecimal)    #=> "FF"
+    hexadecimal = Number.new('FFFF', base: 16, digits: WORD)
+    hexadecimal.to_s #=> "FFFF"
+    hexadecimal.to_i #=> 65535
 
-## New in 2.2.0
+    # Number will infer your most likely meaning:
+    Number.new('FF', 16).to_i #=> 255
 
-I forgot to map the new digit sets added in 2.1.0 to a key, as listed above.
+    # And given a string of at least length 8,
+    # it'll go ahead and guess at your meaning:
+    Number.new('FFFFFFFF').to_i #=> 4294967295
 
-## New in 2.1.0
+    # But best practice is to fully specify,
+    # which is easy to do with keys:
+    n = Number.new 'F', base: :hex, digits: :word
+    n.to_i #=> 15
+    n.to_s #=> "F"
 
-    # GRAPH.length == 94
-    # !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
+    # One can make a change of digits:
+    n = n.to_digits '0123456789abcdef'
+    n.to_s #=> "f"
+    n.to_i #=> 15
 
-    # WORD_.length == 63
-    # 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz
+    # One can make of change of base:
+    n = n.to_base 8
+    n.to_s #=> "17"
 
-    # UNAMBIGUOUS.length == 47
-    # 3479ACEFHJKLMNPRTUVWXYabcdefghijkmnopqrstuvwxyz
+    # One can make of change of base and digits:
+    n = n.to_base 32, :base64
+    # or vice-versa
+    n = n.to_digits :base64, 32
+    n.to_s #=> "P"
 
-## INSTALL:
+## Keys (Symbols)
 
-    $ sudo gem install base_convert
+Instead of giving the base number or the digits' string,
+one can use a mnemonic key:
+
+| long key       | short key | DIGITS        | BASE NUMBER |
+| -------------- | --------- | ------------- | ----------- |
+| `:graph`       | `:g`      | `GRAPH`       | 94          |
+| `:qgraph`      | `:q`      | `QGRAPH`      | 91          |
+| `:base64`      | `:b64`    | `BASE64`      | 64          |
+| `:word_`       | `:w_`     | `WORD_`       | 63          |
+| `:word`        | `:w`      | `WORD`        | 62          |
+| `:unambiguous` | `:u`      | `UNAMBIGUOUS` | 47          |
+
+| long key       | short keys | BASE NUMBER |
+| -------------- | ---------- | ----------- |
+| `:hexadecimal` | `:hex, :h` | 16          |
+| `:decimal`     | `:dec, :d` | 10          |
+| `:octal`       | `:oct, :o` |  8          |
+| `:binary`      | `:bin, :b` |  2          |
 
 ## LICENSE:
 

data/lib/base_convert.rb

@@ -1,9 +1,30 @@
+# http://rosettacode.org/wiki/Non-decimal_radices/Convert#Ruby
 module BaseConvert
-  VERSION = '2.2.0'
+  VERSION = '3.0.191214'
+
+  def toi(string=@string, base=@base, digits=@digits)
+    integer = 0
+    string.each_char do |c|
+      index = digits.index(c)
+      integer = integer * base + index
+    end
+    integer
+  end
+
+  def tob(integer=@integer, base=@base, digits=@digits)
+    return digits[0] if integer == 0
+    string = ''
+    while integer > 0
+      integer, index = integer.divmod(base)
+      string = string.insert(0, digits[index])
+    end
+    string
+  end
+
+  extend self
+
+  autoload :Configuration, 'base_convert/configuration'
+  autoload :FromTo,        'base_convert/from_to'
+  autoload :Number,        'base_convert/number'
 end
-require 'base_convert/configuration'
-require 'base_convert/functions'
-require 'base_convert/helpers'
-require 'base_convert/number'
-require 'base_convert/from_to'
 #`ruby`

data/lib/base_convert/configuration.rb

@@ -6,32 +6,54 @@ module Configuration
 
   WORD_  = 0.upto(255).map{|i| i.chr}.select{|c| c=~/\w/}.join.freeze
   WORD   = WORD_.delete('_').freeze
-  INDEXa = WORD.index('a').freeze
+  INDEXa = WORD.index('a')
 
   AMBIGUOUS   = 'B8G6I1l0OQDS5Z2'.freeze
   UNAMBIGUOUS = WORD.delete(AMBIGUOUS).freeze
 
+  BASE64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+
   BASE = {
     :graph       => GRAPH.length,
     :qgraph      => QGRAPH.length,
     :word_       => WORD_.length,
     :word        => WORD.length,
     :unambiguous => UNAMBIGUOUS.length,
+    :base64      => 64,
+    :b64         => 64,
     :hexadecimal => 16,
     :hex         => 16,
+    :h           => 16,
     :decimal     => 10,
     :dec         => 10,
+    :d           => 10,
     :octal       => 8,
     :oct         => 8,
+    :o           => 8,
     :binary      => 2,
+    :bin         => 2,
+    :b           => 2,
   }
 
+  BASE[:g]   = BASE[:graph]
+  BASE[:q]   = BASE[:qgraph]
+  BASE[:w_]  = BASE[:word_]
+  BASE[:w]   = BASE[:word]
+  BASE[:u]   = BASE[:unambiguous]
+
   DIGITS = {
     :graph       => GRAPH,
+    :g           => GRAPH,
     :qgraph      => QGRAPH,
-    :word_       => WORD,
+    :q           => QGRAPH,
+    :word_       => WORD_,
+    :w_          => WORD_,
     :word        => WORD,
+    :w           => WORD,
     :unambiguous => UNAMBIGUOUS,
+    :u           => UNAMBIGUOUS,
+    :base64      => BASE64,
+    :b64         => BASE64,
   }
 
 end

data/lib/base_convert/from_to.rb

@@ -1,35 +1,27 @@
 module BaseConvert
 class FromTo
   include Configuration
-  extend Functions
-  extend Helpers
+  include BaseConvert
 
-  attr_accessor :from_digits, :to_digits
-  def initialize(basefrom, baseto=basefrom)
-    @basefrom    = FromTo.base(basefrom)
-    @baseto      = FromTo.base(baseto)
-    @from_digits = FromTo.digits(basefrom)
-    @to_digits   = FromTo.digits(baseto)
-
-    FromTo.validate(@baseto, @to_digits)
-    FromTo.validate(@basefrom, @from_digits)
-  end
- 
-  def base2integer(string)
-    string = string.upcase if FromTo.upcase?(@basefrom, @from_digits) # covenience
-    FromTo.validate_string(string, @basefrom, @from_digits)
-    FromTo.to_integer(string, @basefrom, @from_digits)
+  def initialize(base: 10, to_base: base, digits: WORD, to_digits: digits)
+    base      = BASE[base]         if base.is_a?      Symbol
+    to_base   = BASE[to_base]      if to_base.is_a?   Symbol
+    digits    = DIGITS[digits]     if digits.is_a?    Symbol
+    to_digits = DIGITS[to_digits]  if to_digits.is_a? Symbol
+    raise "base must cover digits." if base > digits.length or to_base > to_digits.length
+    @base, @to_base, @digits, @to_digits = base, to_base, digits, to_digits
   end
-  alias base2dec base2integer 
  
-  def integer2base(integer)
-    FromTo.to_base(integer, @baseto, @to_digits)
+  def convert(counter)
+    case counter
+    when Integer
+      tob(counter, @to_base, @to_digits)
+    when String
+      tob(toi(counter), @to_base, @to_digits)
+    else
+      raise "counter must be String|Integer."
+    end
   end
-  alias dec2base integer2base
-
-  def convert(string)
-    integer2base base2integer string.to_s
-  end
-
+  alias :[] :convert
 end
 end

data/lib/base_convert/number.rb

@@ -1,31 +1,144 @@
 module BaseConvert
-class Number < String
+class Number
   include Configuration
-  extend Functions
-  extend Helpers
-
-  def initialize(counter, base=10, digits=Number.digits(base), validate=true)
-    super(counter.to_s)
-    @base   = Number.base(base)
-    @digits = digits
-    if validate
-      self.upcase! if Number.upcase?(@base, @digits)
-      Number.validate(@base, @digits)
-      Number.validate_string(self, @base, @digits)
+  include BaseConvert
+
+  def _infer_digits_from_string
+    if @string.chars.all?{|_|WORD_.include?_}
+      @string.include?('_')? WORD_ : WORD
+    elsif @string.chars.all?{|_|GRAPH.include?_}
+      @string.match?(/['"`]/)? GRAPH : QGRAPH
+    else
+      raise "Need digits."
+    end
+  end
+
+  def _infer_base_from_string
+    min = 1 + @digits.index(@string.chars.max)
+    max = @digits.length
+    return max if max==min
+    case @digits
+    when WORD, WORD_
+      if min <= 32
+        raise "Need base for WORD or WORD_." if @string.length < 8
+        return  8 if min <= 8
+        return 16 if min <= 16
+        return 32
+      end
+    when UNAMBIGUOUS
+      if min <= 22
+        raise "Need base for UNAMBIGUOUS." if @string.length < 8
+        return 22
+      end
+    when QGRAPH, GRAPH
+      n = @digits.index 'a'
+      if min <= n
+        raise "Need base for QGRAPH or GRAPH." if @string.length < 8
+        return n
+      end
+    end
+    return max
+  end
+
+  def _digits!
+    if @digits.nil?
+      @digits = @integer.nil? ? _infer_digits_from_string : WORD
+      if @base and @base > @digits.length
+        if @base == 64
+          @digits = BASE64
+        elsif @base <= QGRAPH.length
+          @digits = QGRAPH
+        elsif @base <= GRAPH.length
+          @digits = GRAPH
+        else
+          raise "Need digits that can cover base #{@base}."
+        end
+      end
+    else
+      if @digits.is_a? Symbol
+        digits = DIGITS[@digits]
+        raise "Unrecognized digits #{@digits}." if digits.nil?
+        @digits = digits
+      else
+        raise "digits must be a String of at least length 2." unless @digits.is_a?(String) and @digits.length > 2
+      end
+    end
+  end
+
+  def _base!
+    if @base.nil?
+      _digits!
+      if @integer.nil?
+        @base = _infer_base_from_string
+      else
+        @base = @digits.length
+      end
+    else
+      if @base.is_a? Symbol
+        base = BASE[@base]
+        raise "Unrecognized base #{@base}." if base.nil?
+        @base = base
+      else
+        raise "base must be an Integer greater than 1." unless @base.is_a?(Integer) and @base > 1
+      end
+      _digits!
+    end
+  end
+
+  def _validate
+    raise "digits must cover base." if @base > @digits.length
+    raise "digits must not have duplicates." if @digits.length > @digits.chars.uniq.length
+    unless @string.nil?
+      raise "digits must cover string." unless @string.chars.all?{|_|@digits.include?_}
+    end
+    unless @integer.nil?
+      raise "integer can't be negative." if @integer < 0
+    end
+  end
+
+  def _integer!
+    _base!
+    _validate if @validate
+    @string.upcase! if @base <= INDEXa and @digits == WORD
+    @integer = toi
+  end
+
+  def _string!
+    _base!
+    _validate if @validate
+    @string = tob
+  end
+
+  attr_reader :base, :digits
+  def initialize(counter, base: nil, digits: nil, validate: true)
+    @base, @digits, @validate = base, digits, validate
+    @string, @integer = nil, nil
+    case counter
+    when String
+      @string = counter
+      _integer!
+    when Integer
+      @integer = counter
+      _string!
+    else
+      raise "Need counter String|Integer."
     end
   end
 
-  def to_integer
-    Number.to_integer(self, @base, @digits)
+  def to_s
+    @string
   end
 
-  def to_base(base, digits=Number.digits(base), validate=true)
-    base   = Number.base(base)
-    Number.validate(base, digits) if validate
-    integer = self.to_integer
-    string = Number.to_base(integer, base, digits)
-    Number.new(string, base, digits, false) # no need to validate
+  def to_i
+    @integer
   end
 
+  def to_base(base, digits=@digits, validate=@validate)
+    Number.new @integer, base: base, digits: digits, validate: validate
+  end
+
+  def to_digits(digits, base=@base, validate=@validate)
+    Number.new @integer, base: base, digits: digits, validate: validate
+  end
 end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: base_convert
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 3.0.191214
 platform: ruby
 authors:
 - carlosjhr64
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-21 00:00:00.000000000 Z
+date: 2019-12-15 00:00:00.000000000 Z
 dependencies: []
 description: |
   BaseConvert - Number base conversion.
@@ -26,8 +26,6 @@ files:
 - lib/base_convert.rb
 - lib/base_convert/configuration.rb
 - lib/base_convert/from_to.rb
-- lib/base_convert/functions.rb
-- lib/base_convert/helpers.rb
 - lib/base_convert/number.rb
 homepage: https://github.com/carlosjhr64/base_convert
 licenses:
@@ -48,9 +46,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements:
-- 'ruby: ruby 2.4.2p198 (2017-09-14 revision 59899) [x86_64-linux]'
-rubyforge_project: 
-rubygems_version: 2.6.13
+- 'ruby: ruby 2.6.5p114 (2019-10-01 revision 67812) [x86_64-linux]'
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: BaseConvert - Number base conversion.

data/lib/base_convert/functions.rb

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

data/lib/base_convert/helpers.rb

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