base_convert 3.1.191231 → 4.0.200111

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '09e96875804850531f1e4e890eeac10d8a53275be55d875f3ea262a03624218d'
-  data.tar.gz: c374bb673c441bb11c314accdcd1b2afef057cf1e23252225cbf08347c83c9ef
+  metadata.gz: 8c43a6429ac3a041f6f01f535b4159087a89e1373c95069617bd134b4f0e5e03
+  data.tar.gz: 7cbd6306d8ece168d0b5548f1b1e208911be94040d405753c4fb83e1c08af83a
 SHA512:
-  metadata.gz: 05ddba6c9079bf3c8a737b8e176e52f560beb6d19ed8aadda1230bd2f09691c112ffbf52cf5b329853f5dd96ab31ade73553938fb83eb7c29783337105bbd31b
-  data.tar.gz: 2b246aeea822d1aa57b281bc6bc93eb118751c86f938dea9c2eb719741efb53c0ca4e5dc7c26f2d38eb81ee535adc9a8d8cc7226c40de931dd087561f5fa741f
+  metadata.gz: 1b1ce6da4bdeb6d589b2b486519b91894eef24502968dc2fa1034e3007704d8791031f89af1e42d92116067c52f50d0b5c2a73ae21ff743975b1b6718d388042
+  data.tar.gz: 11cd53a28e2c169186f2c911345c751990ff48843133add22153bb35ff857208b09252f6c117df737601817b4b41d1870ab32eec6678f2e846ee41887cf30d3c

data/README.md

@@ -1,5 +1,6 @@
 # BaseConvert
 
+* [VERSION 4.0.200111](https://github.com/carlosjhr64/base_convert/releases)
 * [github](https://www.github.com/carlosjhr64/base_convert)
 * [rubygems](https://rubygems.org/gems/base_convert)
 
@@ -9,7 +10,7 @@ BaseConvert - Number base conversion.
 
 Converts positive integers to different bases:
 Binary, octal, hexadecimal, decimal, or any arbitrary base.
-"Out of the box" handling of up to base 94.
+"Out of the box" handling of up to base 95(:print: characters).
 Allows for arbitrary choice of alphabet(digits).
 
 See also rosettacode.org's [Non-decimal radices convert](http://rosettacode.org/wiki/Non-decimal_radices/Convert).
@@ -21,21 +22,24 @@ See also rosettacode.org's [Non-decimal radices convert](http://rosettacode.org/
     #toi string, base, digits #=> integer
     BaseConvert.toi 'FF', 16, '0123456789ABCDEF' #=> 255
 
-    #tob integer, base, digits #=> string
-    BaseConvert.tob 255, 16, '0123456789ABCDEF' #=> "FF"
+    #tos integer, base, digits #=> string
+    BaseConvert.tos 255, 16, '0123456789ABCDEF' #=> "FF"
 
     # FromTo
     c = BaseConvert::FromTo.new base: 16, digits: '0123456789ABCDEF', to_base: 7, to_digits: 'abcdefg'
     c['FFF'] #=> "begea"
+    c.inspect   #=> "16:P95,7:abfg"
 
     # Number
     n = BaseConvert::Number.new 'FF', base: 16, digits: '0123456789ABCDEF'
     n.to_i #=> 255
     n.to_s #=> "FF"
+    n.inspect #=> FF 16:P95
     #
     n = n.to_base 64, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
     n.to_s #=> "D/"
     n.to_i #=> 255
+    n.inspect #=> D/ 64:B64
 
 ## INSTALL:
 
@@ -43,142 +47,180 @@ See also rosettacode.org's [Non-decimal radices convert](http://rosettacode.org/
 
 ## BUT WAIT, THERE'S MORE:
 
-Using `irb` to demonstrate the features.
-The components are scoped under `BaseConvert`:
+### module BaseConvert
+
+* `#toi(string=to_s String, base=@base Integer, digits=@digits String) #=> Integer`
+* `#tos(integer=to_i Integer, base=@base Integer, digits=@digits String) #=> String`
+* `#ascii_ordered?(digits=@digits String) #=> TrueClass|FalseClass`
+
+Exemplar:
+
+    class MyClass
+      include BaseConvert
+      attr_accessor :to_s, :to_i, :base, :digits
+    end
+
+    obj = MyClass.new
+    obj.digits = '!@#$%^&*()'
+    obj.base = 10
+
+    obj.to_s = '@'
+    obj.toi #=> 1
+
+    obj.to_i = 3
+    obj.tos #=> "$"
+
+    obj.ascii_ordered? #=> false
+    obj.digits = 'ABCDEFGHIJKLMNOP'
+    obj.ascii_ordered? #=> true
+
+### Hash DIGITS
+
+#### DIGITS methods
+
+* `DIGITS.get(key Symbol) #=> String|Symbol|NilClass`
+* `DIGITS.registry(digits=nil NilClass|String) #=> Array(Symbol)|Symbol`
+* `DIGITS.label(digits String) #=> String`
+* `DIGITS.memoize!(key=registry Symbol|Array(Symbol))`
+* `DIGITS.forget!(key=registry Symbol|Array(Symbol))`
+
+
+Exemplar:
+
+    include BaseConvert
+    DIGITS.get(:P95) #=> :alnum_bangs_typers_operators_separators_scapes_groupers_quoters_spacers
+    DIGITS[:P95]
+    #=> "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!?$&@*+-/<=>^~,.:;|#\\()[]{}%\"'`_ "
+    DIGITS.registry #=> [:P95, :B64, :U47, :G94, :Q91, :W63]
+    DIGITS.registry('347') #=> :U47
+    DIGITS.registry('0') #=> :P95
+    DIGITS.registry('AB') #=> :B64
+    DIGITS.registry('Cukoe') #=> nil
+    DIGITS.label('Cukoe') #=> :Cuoe
+    DIGITS.label('AaBbCcXxYyZz') #=> :AaZz
+    DIGITS[:N] #=> "0123456789"
+    DIGITS.get(:N) #=> nil
+    DIGITS.memoize!(:N)
+    DIGITS.get(:N) #=> "0123456789"
+    DIGITS.forget!(:N)
+    DIGITS.get(:N) #=> nil
+
+
+#### DIGITS constructions
+
+`BaseConvert::DIGITS` will take a `Symbol` representation of `Regexp` patterns.
+See [Ruby-Doc's Regexp](https://ruby-doc.org/core-2.7.0/Regexp.html) documentation
+for a full list of keys.  The following provides an exemplar survey:
+
+    # Character Classes
+    # Selected from ASCII 32..126
+    DIGITS[:w] #=> "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz"
+    DIGITS[:d] #=> "0123456789"
+    # Note: :h was overridden, see :xdigit.
+    DIGITS[:h] #=> "0123456789ABCDEF"
+    DIGITS[:alpha] #=> "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+    DIGITS[:graph]
+    #=> "!\"\#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
+    DIGITS[:lower] #=> "abcdefghijklmnopqrstuvwxyz"
+    DIGITS[:punct] #=> "!\"\#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"
+    DIGITS[:upper] #=> "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+    DIGITS[:xdigit] #=> "0123456789ABCDEFabcdef"
+
+    # Character Properties
+    # Selected from ASCII 32..126
+    DIGITS[:Alnum] #=> "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+    DIGITS[:Any]
+    #=> " !\"\#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
+
+    # General Category
+    # Selected from ASCII 32..126
+    DIGITS[:Ps] #=> "([{"
+    DIGITS[:Pe] #=> ")]}"
+    DIGITS[:S] #=> "$+<=>^`|~"
+
+    # Ranged Selections
+    # v<hex>w<hex>_<filter>
+    DIGITS[:v1d7d8w1d7e1_Any] #=> "𝟘𝟙𝟚𝟛𝟜𝟝𝟞𝟟𝟠𝟡"
+    # i<dec>j<dec>_<filter>
+    DIGITS[:i120488j120513_Any] #=> "𝚨𝚩𝚪𝚫𝚬𝚭𝚮𝚯𝚰𝚱𝚲𝚳𝚴𝚵𝚶𝚷𝚸𝚹𝚺𝚻𝚼𝚽𝚾𝚿𝛀𝛁"
+
+    # Specified Characters
+    # u<hex>
+    DIGITS[:u61u62] #=> "ab"
+    # k<dec>
+    DIGITS[:k97k98] #=> "ab"
+
+    # BaseConvert's Custom Sets
+    DIGITS[:bangs] #=> "!?"
+    DIGITS[:typers] #=> "$&@"
+    DIGITS[:operators] #=> "*+-/<=>^~"
+    DIGITS[:separators] #=> ",.:;|"
+    DIGITS[:scapes] #=> "#\\"
+    DIGITS[:groupers] #=> "()[]{}"
+    DIGITS[:quotes] #=> "\"'`"
+    DIGITS[:quoters] #=> "%\"'`"
+    DIGITS[:spacers] #=> "_ "
+    DIGITS[:ambiguous] #=> "012568BDGIOQSZl"
+
+    # Composition, add merge:
+    DIGITS[:d_ambiguous] #=> "0123456789BDGIOQSZl"
+    # Composition, add top:
+    DIGITS[:'d+ambiguous'] #=> "3479012568BDGIOQSZl"
+    # Composition, subtract:
+    DIGITS[:'d-ambiguous'] #=> "3479"
+
+    # Compositions used in BaseConvert
+    # :P95 is:
+    DIGITS[:alnum_bangs_typers_operators_separators_scapes_groupers_quoters_spacers]
+    #=> "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!?$&@*+-/<=>^~,.:;|#\\()[]{}%\"'`_ "
+    # :B64 is:
+    DIGITS[:LN_k43k47] #=> "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
+    # :U47 is:
+    DIGITS[:'alnum-ambiguous'] #=> "3479ACEFHJKLMNPRTUVWXYabcdefghijkmnopqrstuvwxyz"
+
+### class FromTo
+
+* `new(base: 10 Integer|Symbol|String, to_base: base, digits: :P95 String|Symbol|Integer, to_digits: digits) #=> FromTo` 
+* `#inspect #=> String`
+* `#convert(counter String|Integer) #=> String`
 
-    > 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 `toi` and `tob`.
-For example, the octal number "7777":
-
-    extend BaseConvert #=> main
-    digits = '01234567'
-    base = digits.length #=> 8
-    toi('7777', base, digits) #=> 4095
-    tob(4095, base, digits) #=> "7777"
-
-You can work with arbitrary digits:
-
-    digits = ')!@#$%^&'
-    base = digits.length #=> 8
-    toi('&&&&', base, digits) #=> 4095
-    tob(4095, base, digits) #=> "&&&&"
-
-Note that one can always explicitly specify the ordered digits to be used.
-But for convenience, `base_convert` provides some predefined sets of digits:
-
-* `GRAPH :graph :g`,  the ASCII graph characters:
-
-    !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
-
-* `QGRAPH :qgraph :q`,  the ASCII graph characters except `QUOTES`:
-
-    !#$%&()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_abcdefghijklmnopqrstuvwxyz{|}~
-
-* `BASE64 :base64 :b64`, the standard base 64 digits from people with no sense of order:
-
-    ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/
-
-* `WORD_ :word_ :w_`, the ASCII word characters including `UNDERSCORE`:
-
-    0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz
-
-* `WORD :word :w`, the ASCII word characters except `UNDERSCORE`:
-
-    0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
-
-* `UNAMBIGUOUS :unambigous :u`, the characters in `WORD` without the `AMBIGUOUS` characters(B8G6I1l0OQDS5Z2):
-
-    3479ACEFHJKLMNPRTUVWXYabcdefghijkmnopqrstuvwxyz
-
-* `G94 :g94` is the library's default defined as `WORD+QGRAPH.delete(WORD_)+QUOTES+UNDERSCORE`
-
-    0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!#$%&()*+,-./:;<=>?@[\]^{|}~"'`_
-
-Some examples:
-
-    UNAMBIGUOUS #=> "3479ACEFHJKLMNPRTUVWXYabcdefghijkmnopqrstuvwxyz"
-    # etc...
-    tob 255, 16, WORD #=> "FF"
-    tob 255, 64, BASE64 #=> "D/"
-
-The second way to convert is via a conversion object of `BaseConvert::FromTo`.
-For example, to convert from hexadecimal to octal, and back:
-
-    h2o = FromTo.new base: 16, to_base: 8
-    o2h = FromTo.new base: 8, to_base: 16
-    h2o['FFFF'] #=> "177777"
-    o2h['177777'] #=> "FFFF"
-
-The third way to work with variant base and digits numbers is via the `BaseConvert::Number`:
-
-    hexadecimal = Number.new('FFFF', base: 16, digits: WORD)
-    hexadecimal.to_s #=> "FFFF"
-    hexadecimal.to_i #=> 65535
-
-    # Number will infer your most likely meaning:
-    Number.new('FF').to_i #=> 255
-
-    # 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"
-
-    # One can make a change of digits:
-    n = n.to_digits '0123456789abcdef'
-    n.to_s #=> "f"
-    n.to_i #=> 15
-
-    # One can make of change of base:
-    n = n.to_base 8
-    n.to_s #=> "17"
-
-    # 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"
-
-## Keys (Symbols)
+Example:
 
-Instead of giving the base number or the digits' string,
-one can use a mnemonic key:
+    h2b = BaseConvert::FromTo.new(base: 16, digits: :P95, to_base: 64, to_digits: :B64)
+    h2b #=> 16:P95,64:B64
+    h2b['FFF'] #=> "//"
+    b2h = BaseConvert::FromTo.new(base: 64, digits: :B64, to_base: 16, to_digits: :P95)
+    b2h #=> 64:B64,16:P95
+    b2h['//'] #=> "FFF"
 
-| long key       | short key | DIGITS        | BASE NUMBER |
-| -------------- | --------- | ------------- | ----------- |
-| `:g94`         |           | `G94`         | 94          |
-| `:graph`       | `:g`      | `GRAPH`       | 94          |
-| `:qgraph`      | `:q`      | `QGRAPH`      | 91          |
-| `:base64`      | `:b64`    | `BASE64`      | 64          |
-| `:word_`       | `:w_`     | `WORD_`       | 63          |
-| `:word`        | `:w`      | `WORD`        | 62          |
-| `:unambiguous` | `:u`      | `UNAMBIGUOUS` | 47          |
+### class Number
 
-| long key       | short keys | BASE NUMBER |
-| -------------- | ---------- | ----------- |
-| `:hexadecimal` | `:hex, :h` | 16          |
-| `:decimal`     | `:dec, :d` | 10          |
-| `:octal`       | `:oct, :o` |  8          |
-| `:binary`      | `:bin, :b` |  2          |
+* `new(counter= 0 Integer|String, base: nil Integer|Symbol|String, digits: nil String|Symbol|Integer, validate: true TrueClass|FalseClass) #=> Number`
+* `#base #=> Integer`
+* `#digits #=> String`
+* `#inspect #=> String`
+* `#to_s #=> String`
+* `#to_i #=> Integer`
+* `#to_base(base Integer|Symbol|String, digits=@digits String|Symbol|Integer, validate=@validate TrueClass|FalseClass) #=> Number`
+* `#to_digits(digits String|Symbol|Integer, base=@base Integer|Symbol|String, validate=@validate TrueClass|FalseClass) #=> Number`
 
 Example:
 
-    # For some pseudo-random string of unambigous characters
-    # of very likely length 16:
-    p = BaseConvert::Number.new(rand(47**16), digits: :u)
-    p.to_s   #=> "CxesjJqHcvpnp7bp"
+    a = BaseConvert::Number.new('FFF', base: 16, digits: :P95)
+    a #=> FFF 16:P95
+    a.to_i #=> 4095
+    b = a.to_digits(:U47)
+    b #=> RRR 16:U47
+    b.to_i #=> 4095
+    c = b.to_base(64, :B64)
+    c #=> // 64:B64
+    c.to_i #=> 4095
 
 ## LICENSE:
 
 (The MIT License)
 
-Copyright (c) 2019 CarlosJHR64
+Copyright (c) 2020 CarlosJHR64
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/lib/base_convert.rb

@@ -1,6 +1,9 @@
 module BaseConvert
-  VERSION = '3.1.191231'
+  VERSION = '4.0.200111'
   require 'base_convert/base_convert'
+  require 'base_convert/chars'
+  require 'base_convert/digits'
+  require 'base_convert/base'
   require 'base_convert/configuration'
   require 'base_convert/from_to'
   require 'base_convert/number'

data/lib/base_convert/base.rb

@@ -0,0 +1,24 @@
+module BaseConvert
+class Base < Hash
+  alias :get :[]
+  def [](key)
+    base = super and return base
+    case key
+    when String
+      base = key.length
+    when Integer
+      base = key
+    when /^\D+(\d+)$/
+      base = $1.to_i
+    else
+      begin
+        base = DIGITS[key].length
+      rescue
+        raise 'unrecognized base key'
+      end
+    end
+    raise 'base must be greater than 1' unless base > 1
+    base
+  end
+end
+end

data/lib/base_convert/base_convert.rb

@@ -1,6 +1,7 @@
 # http://rosettacode.org/wiki/Non-decimal_radices/Convert#Ruby
 module BaseConvert
-  def toi(string=@string, base=@base, digits=@digits)
+  def toi(string=to_s, base=@base, digits=@digits)
+    return nil if string.empty?
     integer = 0
     string.each_char do |c|
       index = digits.index(c)
@@ -9,7 +10,8 @@ module BaseConvert
     integer
   end
 
-  def tob(integer=@integer, base=@base, digits=@digits)
+  def tos(integer=to_i, base=@base, digits=@digits)
+    return '' if integer.nil?
     return digits[0] if integer == 0
     string = ''
     while integer > 0
@@ -19,5 +21,9 @@ module BaseConvert
     string
   end
 
+  def ascii_ordered?(digits=@digits)
+    (1..(digits.length-1)).all?{|i|digits[i-1]<digits[i]}
+  end
+
   extend self
 end

data/lib/base_convert/chars.rb

@@ -0,0 +1,59 @@
+module BaseConvert
+  class Chars < Array
+    attr_accessor :start,:stop
+    def initialize(start=32, stop=126)
+      @start,@stop = start,stop
+    end
+
+    # i<n>: @start=n.to_i
+    # v<n>: @start=n.to_i(16)
+    # j<n>: @stop=n.to_i
+    # w<n>: @stop=n.to_i(16)
+    def set(s)
+      t,n = s[0],s[1..-1]
+      case t
+      when 'i','v'
+        @start = n.to_i((t=='v')? 16 : 10)
+      when 'j','w'
+        @stop = n.to_i((t=='w')? 16 : 10)
+      else
+        raise 'expected /^([ij]\d+)|([vw]\h+)$/'
+      end
+    end
+
+    def chars_in(x)
+      case x
+      when Regexp
+        @start.upto(@stop).each do |l|
+          c = l.chr(Encoding::UTF_8)
+          yield c if x.match? c
+        end
+      when Symbol
+        yield x[1..-1].to_i((x[0]=='u')? 16: 10).chr(Encoding::UTF_8)
+      when String
+        x.chars.each{|c| yield c}
+      when Integer
+        yield x.chr(Encoding::UTF_8)
+      else
+        raise "expected Regexp|Symbol|String|Integer, got #{x.class}"
+      end
+    end
+
+    def add(x)
+      chars_in(x) do |c|
+        self.push(c) unless self.include?(c)
+      end
+    end
+
+    def top(x)
+      chars_in(x) do |c|
+        self.delete(c)
+        self.push(c)
+      end
+    end
+
+    def remove(x)
+      chars_in(x){|c| self.delete(c)}
+    end
+  end
+end

data/lib/base_convert/configuration.rb

@@ -1,61 +1,88 @@
 module BaseConvert
-  QUOTES      = %("'`).freeze
-  UNDERSCORE  = '_'.freeze
-  AMBIGUOUS   = 'B8G6I1l0OQDS5Z2'.freeze
-
-  GRAPH       = 0.upto(255).map{|i| i.chr}.select{|c| c=~/[[:graph:]]/}.join.freeze
-  QGRAPH      = GRAPH.delete(QUOTES).freeze
-  WORD_       = QGRAPH.chars.select{|c| c=~/\w/}.join.freeze
-  WORD        = WORD_.delete(UNDERSCORE).freeze
-  UNAMBIGUOUS = WORD.delete(AMBIGUOUS).freeze
-  G94         = (WORD + QGRAPH.delete(WORD_) + QUOTES + UNDERSCORE).freeze
-
-  BASE64      = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.freeze
-
-  INDEXa = G94.index('a')
-
-  BASE = {
-    :g94         => G94.length,          # 94
-    :graph       => GRAPH.length,        # 94
-    :qgraph      => QGRAPH.length,       # 91
-    :word_       => WORD_.length,        # 63
-    :word        => WORD.length,         # 62
-    :unambiguous => UNAMBIGUOUS.length,  # 47
-    :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 = {
-    :g94         => G94,
-    :graph       => GRAPH,
-    :g           => GRAPH,
-    :qgraph      => QGRAPH,
-    :q           => QGRAPH,
-    :word_       => WORD_,
-    :w_          => WORD_,
-    :word        => WORD,
-    :w           => WORD,
-    :unambiguous => UNAMBIGUOUS,
-    :u           => UNAMBIGUOUS,
-    :base64      => BASE64,
-    :b64         => BASE64,
-  }
+  DIGITS = Digits.new
+
+  # Naming these letter sequences is inpired by
+  # (but not the same as)
+  # Unicode character’s General Category.
+  DIGITS[:bangs]      = '!?'.freeze               # Used as method name suffix
+  DIGITS[:typers]     = '$&@'.freeze              # Used as variable name prefix
+  DIGITS[:operators]  = '*+-/<=>^~'.freeze        # Used as mathematical operators
+  DIGITS[:separators] = ',.:;|'.freeze            # Used to separated items
+  DIGITS[:scapes]     = '#\\'.freeze              # Used to escape what's next
+  DIGITS[:groupers]   = '()[]{}'.freeze           # Used to group items
+  DIGITS[:quotes]     = %("'`).freeze             # Quotes
+  DIGITS[:quoters]    = %(\%"'`).freeze           # Used to quote strings('%' not ASCII ordered)
+  DIGITS[:spacers]    = '_ '.freeze               # 1_000 == 1000 #=> true (Not ASCII ordered)
+  DIGITS[:ambiguous]  = '012568BDGIOQSZl'.freeze  # ASCII ordered ambiguous characters
+
+  ### Recursive string constructors ###
+  # 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!?$&@*+-/<=>^~,.:;|#\\()[]{}%"'`_ 
+  DIGITS[:P95] = :alnum_bangs_typers_operators_separators_scapes_groupers_quoters_spacers
+  INDEXa = DIGITS[:P95].index('a')
+  # 0123456789ABCDEF
+  DIGITS[:hexadecimal] = DIGITS[:hex] = DIGITS[:h] = :P16
+  # 0123456789
+  DIGITS[:decimal] = DIGITS[:dec] = :P10
+  # 01234567
+  DIGITS[:octal] = DIGITS[:oct] = DIGITS[:o] = :P8
+  # 01
+  DIGITS[:b] = DIGITS[:bin] = DIGITS[:binary] = :P2
+
+  # !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
+  DIGITS[:G94] = DIGITS[:g] = :graph
+
+  # !#$%&()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_abcdefghijklmnopqrstuvwxyz{|}~
+  DIGITS[:Q91] = DIGITS[:qgraph] = DIGITS[:q] = :'graph-quotes'
+
+  # ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/
+  DIGITS[:base64] = DIGITS[:b64] = DIGITS[:B64] = :LN_k43k47
+  DIGITS[:letters] = DIGITS[:l] = :B52 # subset of B64
+
+  # 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz
+  DIGITS[:word] = DIGITS[:W63] = :w
+
+  # 3479ACEFHJKLMNPRTUVWXYabcdefghijkmnopqrstuvwxyz
+  DIGITS[:unambiguous] = DIGITS[:U47] = DIGITS[:u] = :'alnum-ambiguous'
+
+  BASE = Base[
+    # 95
+    P95: 95,
+    print: 95,
+    # 94
+    G94: 94, g: 94, graph: 94,
+    # 91
+    Q91: 91, qgraph: 91, q: 91,
+    # 64
+    B64: 64, base64: 64, b64: 64,
+    # 63
+    W63: 63, word: 63, w: 63,
+    # 52
+    letters: 52, l: 52, L: 52,
+    # 47
+    U47: 47, unambiguous: 47, u: 47,
+    # 16
+    hexadecimal: 16, hex: 16, h: 16,
+    # 15
+    ambiguous: 15,
+    # 10
+    decimal: 10, dec: 10, d: 10,
+    # 9
+    operators: 9,
+    # 8
+    octal: 8, oct: 8, o: 8,
+    # 6
+    groupers: 6,
+    # 5
+    separators: 5,
+    # 4
+    quoters: 4,
+    # 3
+    typers: 3,
+    quotes: 3,
+    # 2
+    binary: 2, bin: 2, b: 2,
+    bangs: 2,
+    scapes: 2,
+    spacers: 2,
+  ]
 end

data/lib/base_convert/digits.rb

@@ -0,0 +1,96 @@
+module BaseConvert
+class Digits < Hash
+  alias :get :[]
+  def [](key)
+    if self.has_key?(key)
+      d = super(key)
+      return d.is_a?(Symbol)? self[d]: d
+    end
+    case key
+    when Symbol
+      chars = Chars.new
+      key.to_s.scan(/[+-]?[[:alnum:]]+/).each do |type|
+        if self.has_key?(_=type.to_sym)
+          chars.add super(_)
+          next
+        end
+        case type
+        when /^((u\h+)|(k\d+))+$/
+          type.scan(/[uk]\h+/).each{|s| chars.top s.to_sym}
+        when /^(([ij]\d+)|([vw]\h+))+$/
+          type.scan(/[ijvw]\h+/).each{|s| chars.set s}
+        when /^[a-z][a-z]+$/
+          chars.add Regexp.new "[[:#{type}:]]"
+        when /^[a-z]$/
+          chars.add Regexp.new "\\#{type}"
+        when /^[A-Z]+$/i
+          type.scan(/[A-Z][a-z]*/).each{|property| chars.add /\p{#{property}}/}
+        when /^([+-])(\w+)/
+          d = self[$2.to_sym]
+          case $1
+          when '+'
+            chars.top d
+          when '-'
+            chars.remove d
+          end
+        when /^(\p{L}+)(\d+)$/
+          l,m = $1,$2.to_i-1
+          n = self.keys.select{|_|_=~/^#{l}\d+$/}.map{|_|_.to_s.sub(l,'').to_i}.max
+          raise "no #{l}<n> digits defined" if n.nil?
+          raise "out of range of #{l}#{n}" unless m<n
+          chars.add self[:"#{l}#{n}"][0..m]
+        else
+          raise "unrecognized digits key: #{type}"
+        end
+      end
+      return chars.uniq.join.freeze
+    when String
+      digits = nil # set as a side effect...
+      unless registry.detect{|_|(digits=self[_]).start_with? key}
+        # ...here -------------->^^^^^
+        raise 'need at least 2 digits' unless key.length > 1
+        raise 'digits must not have duplicates' if key.length > key.chars.uniq.length
+        return key
+      end
+      return digits
+    when Integer
+      raise 'need digits to cover base' if key > 95
+      return self[:P95] # Defined below
+    end
+    raise 'digits must be String|Symbol|Integer'
+  end
+
+  def registry(d=nil)
+    # BaseConvert::Number memoizes and uses specifically :P95, :B64, and :U47;
+    # giving these precedence above the rest.
+    @registry ||= [:P95, :B64, :U47, :G94, :Q91, :W63]
+    d ? @registry.detect{|_|self[_].start_with? d}: @registry
+  end
+
+  def label(d)
+    registry(d) or (d[0]+d[1]+d[-2]+d[-1]).to_sym
+  end
+
+  def memoize!(keys=registry)
+    [*keys].each do |k|
+      while s = get(k)
+        break if s.is_a? String # links to a constructed String
+        raise 'expected Symbol' unless s.is_a? Symbol
+        k = s
+      end
+      self[k]=self[k] if s.nil? # if not memoized, memoize!
+    end
+  end
+
+  def forget!(keys=registry)
+    [*keys].each do |k|
+      while s = get(k)
+        break if s.is_a? String # links to a constructed String
+        raise 'expected Symbol' unless s.is_a? Symbol
+        k = s
+      end
+      self.delete(k) if s.is_a? String
+    end
+  end
+end
+end

data/lib/base_convert/from_to.rb

@@ -2,23 +2,29 @@ module BaseConvert
 class FromTo
   include BaseConvert
 
-  def initialize(base: 10, to_base: base, digits: G94, 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
+  def initialize(base: 10, to_base: base, digits: :P95, to_digits: digits)
+    base      = BASE[base]
+    to_base   = BASE[to_base]
+    digits    = DIGITS[digits]
+    to_digits = DIGITS[to_digits]
+    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
+
+  def inspect
+    d0 = DIGITS.label(@digits)
+    d1 = DIGITS.label(@to_digits)
+    "#{@base}:#{d0},#{@to_base}:#{d1}"
+  end
  
   def convert(counter)
     case counter
     when Integer
-      tob(counter, @to_base, @to_digits)
+      tos(counter, @to_base, @to_digits)
     when String
-      tob(toi(counter), @to_base, @to_digits)
+      tos(toi(counter), @to_base, @to_digits)
     else
-      raise "counter must be String|Integer."
+      raise 'counter must be String|Integer'
     end
   end
   alias :[] :convert

data/lib/base_convert/number.rb

@@ -1,23 +1,27 @@
 module BaseConvert
 class Number
   include BaseConvert
+  DIGITS.memoize!
 
   def self.infer(string)
-    return 2, G94 if string.empty?
+    p95 = DIGITS[:P95]
+    return 2, p95  if string.empty?
     chars = string.chars
-    raise 'Need digits.' unless chars.all?{|_|G94.include?_}
-    max = chars.map{|_|G94.index(_)}.max
-    return 2,  G94  if max < 2
-    return 4,  G94  if max < 4
-    return 8,  G94  if max < 8
-    return 10, G94  if max < 10
-    return 16, G94  if max < 16
-    return 32, G94  if max < 32
-    [UNAMBIGUOUS, BASE64].each do |digits|
-      return digits.length, digits  if chars.all?{|_|digits.include?_}
-    end
-    return 64, G94  if max < 64
-    return G94.length, G94  if max < 64
+    raise 'need digits to cover string'  unless chars.all?{|_|p95.include?_}
+    max = chars.map{|_|p95.index(_)}.max
+    return 95, p95  if max == 94 # string has a space digit.
+    return 2,  p95  if max < 2
+    return 4,  p95  if max < 4
+    return 8,  p95  if max < 8
+    return 10, p95  if max < 10
+    return 16, p95  if max < 16
+    return 32, p95  if max < 32
+    u47 = DIGITS[:U47]
+    return 47, u47  if chars.all?{|_|u47.include?_}
+    return 64, p95  if max < 64
+    b64 = DIGITS[:B64]
+    return 64, b64  if chars.all?{|_|b64.include?_}
+    return 94, p95
   end
 
   attr_reader :base, :digits
@@ -27,65 +31,62 @@ class Number
     when true, false
       @validate = validate
     else
-      raise "validate must be either true of false."
+      raise 'validate must be either true or false'
     end
 
     # counter
+    string = nil
     case counter
     when String
-      @string = counter
+      string = counter
       base, digits = Number.infer(counter)  if base.nil? and digits.nil?
     when Integer
       @integer = counter
-      base, digits = 10, G94  if base.nil? and digits.nil?
+      base, digits = 10, DIGITS[:P95]  if base.nil? and digits.nil?
     else
-      raise "Need counter String|Integer."
+      raise 'need counter String|Integer'
     end
 
     # digits
-    if digits.is_a? Symbol
-      digits = DIGITS[digits]
-      raise "Unrecognized digits." if digits.nil?
-    end
-    digits = DIGITS[base] if digits.nil?
-    digits = G94 if digits.nil?
-    raise "digits must be a String of at least length 2." unless digits.is_a?(String) and digits.length > 1
-    @digits = digits
+    @digits = DIGITS[digits || base]
 
     # base
-    if base.is_a? Symbol
-      base = BASE[base]
-      raise "Unrecognized base." if base.nil?
-    end
-    base = @digits.length if base.nil?
-    raise "base must be an Integer greater than 1." unless base.is_a?(Integer) and base > 1
-    @base = base
+    base = digits if base.nil? and digits.is_a? Symbol
+    @base = BASE[base || @digits.length]
 
     # validate
     if @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? or @string.empty?
-        @string.upcase! if @base <= INDEXa and @digits.equal? G94
-        raise "digits must cover string." unless @string.chars.all?{|_|@digits.include?_}
-        raise "digits in string must be under base." unless @base > @string.chars.map{|_|@digits.index(_)}.max
+      raise 'digits must cover base' if @base > @digits.length
+      unless string.nil? or string.empty?
+        indeces = string.chars.map{|_|@digits.index(_)}
+        if missing = indeces.any?{|_|_.nil?} or exceeding = indeces.any?{|_|_>=@base}
+          if @base <= INDEXa and DIGITS[:P95].start_with?(@digits)
+            string = string.upcase
+            indeces = string.chars.map{|_|@digits.index(_)}
+            missing = indeces.any?{|_|_.nil?} or exceeding = indeces.any?{|_|_>=@base}
+          end
+          raise 'digits must cover string' if missing
+          raise 'digits in string must be under base' if exceeding
+        end
       end
       unless @integer.nil?
-        raise "integer can't be negative." if @integer < 0
+        raise 'integer can not be negative' if @integer < 0
       end
     end
 
-    @integer = toi if @integer.nil?
-    @string  = tob if @string.nil?
+    @integer = toi(string) if @integer.nil?
+  end
+
+  def inspect
+    d = DIGITS.label(@digits)
+    "#{to_s} #{@base}:#{d}"
   end
 
   def validate?
     @validate
   end
 
-  def to_s
-    @string
-  end
+  alias to_s tos
 
   def to_i
     @integer

metadata

@@ -1,21 +1,21 @@
 --- !ruby/object:Gem::Specification
 name: base_convert
 version: !ruby/object:Gem::Version
-  version: 3.1.191231
+  version: 4.0.200111
 platform: ruby
 authors:
 - carlosjhr64
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-12-31 00:00:00.000000000 Z
+date: 2020-01-11 00:00:00.000000000 Z
 dependencies: []
 description: |
   BaseConvert - Number base conversion.
 
   Converts positive integers to different bases:
   Binary, octal, hexadecimal, decimal, or any arbitrary base.
-  "Out of the box" handling of up to base 94.
+  "Out of the box" handling of up to base 95(:print: characters).
   Allows for arbitrary choice of alphabet(digits).
 email: carlosjhr64@gmail.com
 executables: []
@@ -24,8 +24,11 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/base_convert.rb
+- lib/base_convert/base.rb
 - lib/base_convert/base_convert.rb
+- lib/base_convert/chars.rb
 - lib/base_convert/configuration.rb
+- lib/base_convert/digits.rb
 - lib/base_convert/from_to.rb
 - lib/base_convert/number.rb
 homepage: https://github.com/carlosjhr64/base_convert