base_convert 3.0.191221 → 6.0.210201

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4f291f3baa22819d9fc33426500a93f8807d099c30bf326ae55287450d31f24f
-  data.tar.gz: 28a6ee75eae21c11a6bc31dd3a82b992b2840bb7e14030398947a6a9c1de5716
+  metadata.gz: 9e29e85eacc7c4fb82ae72be4dec517de21f2e0c1be03a6dc2670fa1296a9b12
+  data.tar.gz: 999da6376a8025b1c5dedd696b5e5c97fb9423b9dfc6f0c59dbefe270dc72dea
 SHA512:
-  metadata.gz: d526f406b53f4fdc66341c78ff927ed45f76c6f61237b10fb1c65c93fa2a015045c9f5175feefe2773843e771deb4cf58dfac3c9daa3a96fdd62698b6fd094fb
-  data.tar.gz: bb753fe647787556bba5ce5708554e3a7ecad88525c11a5be69c43976c29de3ff777b0e050ca3edafeda27e226a6b1451c5f53afb91e4b1f9c60877c7322640f
+  metadata.gz: 52b687612311825f4bc0877d9e5b4483d58006749dd12ec35ae954864a7b091c5c4a20e796a89aff383a1fe7db331446a13fd575924a1129fe29e78db037c24e
+  data.tar.gz: 768e66ca83303a4d4e36c2310291c480923a8a7758a1d18afc67a0c2dee88c8175b65180cb6dbde46cab71095f9a54302cec170da544f65657cc58f1f2ff0a27

data/README.md

@@ -1,159 +1,240 @@
 # BaseConvert
 
+* [VERSION 6.0.210201](https://github.com/carlosjhr64/base_convert/releases)
 * [github](https://www.github.com/carlosjhr64/base_convert)
 * [rubygems](https://rubygems.org/gems/base_convert)
 
+## INSTALL:
+
+```shell
+$ gem install base_convert
+```
+
 ## 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).
 
 See also rosettacode.org's [Non-decimal radices convert](http://rosettacode.org/wiki/Non-decimal_radices/Convert).
 
 ## SYNOPSIS:
 
-    require 'base_convert'
+```ruby
+require 'base_convert'
 
-    #toi string, base, digits #=> integer
-    BaseConvert.toi 'FF', 16, '0123456789ABCDEF' #=> 255
+#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"
-
-    # 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:
+# FromTo
+c = BaseConvert::FromTo.new base: 16, digits: '0123456789ABCDEF', to_base: 7, to_digits: 'abcdefg'
+c['FFF'] #=> "begea"
+c.inspect   #=> "16:P95,7:abfg"
 
-    $ gem install base_convert
+# 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
+```
 
 ## 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
-
-`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) #=> "&&&&"
-
-For convenience, `base_convert` provides under `module BaseConvert::Configuration` 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.
-* `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).
-
-Some examples:
-
-    Configuration::UNAMBIGUOUS #=> "3479ACEFHJKLMNPRTUVWXYabcdefghijkmnopqrstuvwxyz"
-    # etc...
-    tob 255, 16, Configuration::WORD #=> "FF"
-    include Configuration
-    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', 16).to_i #=> 255
-
-    # And given a string of at least length 8,
-    # it'll go ahead and guess at your meaning:
-    Number.new('FFFFFFFF').to_i #=> 4294967295
-
-    # 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)
-
-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          |
+### 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:
+
+```ruby
+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:
+
+```ruby
+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:
+
+```ruby
+# 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`
+
+Example:
+
+```ruby
+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"
+```
+
+### class Number
+
+* `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:
+
+```ruby
+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) 2014 CarlosJHR64
+Copyright (c) 2021 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,30 +1,11 @@
-# http://rosettacode.org/wiki/Non-decimal_radices/Convert#Ruby
 module BaseConvert
-  VERSION = '3.0.191221'
-
-  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'
+  VERSION = '6.0.210201'
+  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'
 end
 #`ruby`

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

@@ -0,0 +1,29 @@
+# http://rosettacode.org/wiki/Non-decimal_radices/Convert#Ruby
+module BaseConvert
+  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)
+      integer = integer * base + index
+    end
+    integer
+  end
+
+  def tos(integer=to_i, base=@base, digits=@digits)
+    return '' if integer.nil?
+    return digits[0] if integer == 0
+    string = ''
+    while integer > 0
+      integer, index = integer.divmod(base)
+      string = string.prepend digits[index]
+    end
+    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,60 +1,88 @@
 module BaseConvert
-module Configuration
-
-  GRAPH  = 0.upto(255).map{|i| i.chr}.select{|c| c=~/[[:graph:]]/}.join.freeze
-  QGRAPH = GRAPH.delete(%('"`)).freeze
-
-  WORD_  = 0.upto(255).map{|i| i.chr}.select{|c| c=~/\w/}.join.freeze
-  WORD   = WORD_.delete('_').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,
-    :q           => QGRAPH,
-    :word_       => WORD_,
-    :w_          => WORD_,
-    :word        => WORD,
-    :w           => WORD,
-    :unambiguous => UNAMBIGUOUS,
-    :u           => UNAMBIGUOUS,
-    :base64      => BASE64,
-    :b64         => BASE64,
-  }
+  DIGITS = Digits.new
 
-end
+  # 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 in configuration.rb
+    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.  Defined in configuration.rb.
+    @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

@@ -1,25 +1,30 @@
 module BaseConvert
 class FromTo
-  include Configuration
   include BaseConvert
 
-  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
+  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,140 +1,98 @@
 module BaseConvert
 class Number
-  include Configuration
   include BaseConvert
+  DIGITS.memoize!
 
-  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
+  def self.infer(string)
+    p95 = DIGITS[:P95]
+    return 2, p95  if string.empty?
+    chars = string.chars
+    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
 
-  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
+  attr_reader :base, :digits
+  def initialize(counter=0, base: nil, digits: nil, validate: true)
+    # validate
+    case validate
+    when true, false
+      @validate = validate
+    else
+      raise 'validate must be either true or false'
     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
+    # counter
+    string = nil
+    case counter
+    when String
+      string = counter
+      base, digits = Number.infer(counter)  if base.nil? and digits.nil?
+    when Integer
+      @integer = counter
+      base, digits = 10, DIGITS[:P95]  if base.nil? and digits.nil?
     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
+      raise 'need counter String|Integer'
     end
-  end
 
-  def _base!
-    if @base.nil?
-      _digits!
-      if @integer.nil?
-        @base = _infer_base_from_string
-      else
-        @base = @digits.length
+    # digits
+    @digits = DIGITS[digits || 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
+      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
-    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
+      unless @integer.nil?
+        raise 'integer can not be negative'  if @integer < 0
       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?_}
-      raise "digits in string must be under base." unless @base > @digits.index(@string.chars.max)
     end
-    unless @integer.nil?
-      raise "integer can't be negative." if @integer < 0
-    end
-  end
 
-  def _integer!
-    _base!
-    @string.upcase! if @base <= INDEXa and @digits == WORD
-    _validate if @validate
-    @integer = toi
+    @integer = toi(string)  if @integer.nil?
   end
 
-  def _string!
-    _base!
-    _validate if @validate
-    @string = tob
+  def inspect
+    d = DIGITS.label(@digits)
+    "#{to_s} #{@base}:#{d}"
   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
+  def validate?
+    @validate
   end
 
-  def to_s
-    @string
-  end
+  alias to_s tos
 
   def to_i
     @integer
   end
 
-  def to_base(base, digits=@digits, validate=@validate)
+  def to_base(base, digits=(base.is_a?Symbol)? DIGITS[base] : @digits, validate=@validate)
     Number.new @integer, base: base, digits: digits, validate: validate
   end
 

metadata

@@ -1,21 +1,21 @@
 --- !ruby/object:Gem::Specification
 name: base_convert
 version: !ruby/object:Gem::Version
-  version: 3.0.191221
+  version: 6.0.210201
 platform: ruby
 authors:
 - carlosjhr64
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-12-21 00:00:00.000000000 Z
+date: 2021-02-01 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,14 +24,18 @@ 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
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -46,9 +50,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements:
-- 'ruby: ruby 2.6.5p114 (2019-10-01 revision 67812) [x86_64-linux]'
-rubygems_version: 3.0.3
-signing_key: 
+- 'ruby: ruby 3.0.0p0 (2020-12-25 revision 95aff21468) [x86_64-linux]'
+rubygems_version: 3.2.3
+signing_key:
 specification_version: 4
 summary: BaseConvert - Number base conversion.
 test_files: []