base_convert 6.0.210201 → 7.0.221226

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e29e85eacc7c4fb82ae72be4dec517de21f2e0c1be03a6dc2670fa1296a9b12
-  data.tar.gz: 999da6376a8025b1c5dedd696b5e5c97fb9423b9dfc6f0c59dbefe270dc72dea
+  metadata.gz: '0468363560e386197373265ab15994e9f75b97965f01fd7c7d039ba659fb9e5d'
+  data.tar.gz: e22bdb75673cb9e2bedc6edd7c7dd1349234ff8709b77b7e1159e74b79b37975
 SHA512:
-  metadata.gz: 52b687612311825f4bc0877d9e5b4483d58006749dd12ec35ae954864a7b091c5c4a20e796a89aff383a1fe7db331446a13fd575924a1129fe29e78db037c24e
-  data.tar.gz: 768e66ca83303a4d4e36c2310291c480923a8a7758a1d18afc67a0c2dee88c8175b65180cb6dbde46cab71095f9a54302cec170da544f65657cc58f1f2ff0a27
+  metadata.gz: 6dfa9704f01b5145bdb9ad4070d59aa4027dafcb8431fd24c42134d861475f33c97a3db30549c606dffd60acdca15768211abac2b648ee6de147481038f405cc
+  data.tar.gz: '0948eea3537cc52a521d633c68aa6a4121646bfe20af41e3d11ca902a8cb3f814468ad022c8b5879726de4c24bf4433dbb88b9fc690f53d03d33a0a4bc0c1e52'

data/README.md

@@ -1,15 +1,13 @@
 # BaseConvert
 
-* [VERSION 6.0.210201](https://github.com/carlosjhr64/base_convert/releases)
+* [VERSION 7.0.221226](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.
@@ -19,49 +17,45 @@ Binary, octal, hexadecimal, decimal, or any arbitrary base.
 "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:
-
 ```ruby
 require 'base_convert'
 
 #toi string, base, digits => integer
-BaseConvert.toi 'FF', 16, '0123456789ABCDEF' #=> 255
+BaseConvert::Methods.toi 'FF', 16, '0123456789ABCDEF' #=> 255
 
 #tos integer, base, digits => string
-BaseConvert.tos 255, 16, '0123456789ABCDEF' #=> "FF"
+BaseConvert::Methods.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"
+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.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.to_s    #=> "D/"
+n.to_i    #=> 255
 n.inspect #=> D/ 64:B64
 ```
-
 ## BUT WAIT, THERE'S MORE:
 
-### module BaseConvert
+### module BaseConvert::Methods
 
 * `#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`
+* `#chars_ordered?(digits=@digits String) #=> TrueClass|FalseClass`
 
 Exemplar:
-
 ```ruby
 class MyClass
-  include BaseConvert
+  include BaseConvert::Methods
   attr_accessor :to_s, :to_i, :base, :digits
 end
 
@@ -75,12 +69,11 @@ obj.toi #=> 1
 obj.to_i = 3
 obj.tos #=> "$"
 
-obj.ascii_ordered? #=> false
+obj.chars_ordered? #=> false
 obj.digits = 'ABCDEFGHIJKLMNOP'
-obj.ascii_ordered? #=> true
+obj.chars_ordered? #=> true
 ```
-
-### Hash DIGITS
+### BaseConvert::DIGITS < Hash
 
 #### DIGITS methods
 
@@ -90,54 +83,51 @@ obj.ascii_ordered? #=> true
 * `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.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.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[:N]                   #=> "0123456789"
+DIGITS.get(:N)               #=> nil
 DIGITS.memoize!(:N)
-DIGITS.get(:N) #=> "0123456789"
+DIGITS.get(:N)               #=> "0123456789"
 DIGITS.forget!(:N)
-DIGITS.get(:N) #=> nil
+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[:h]     #=> "0123456789ABCDEF"
 DIGITS[:alpha] #=> "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
 DIGITS[:graph]
 #=> "!\"\#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
-DIGITS[:lower] #=> "abcdefghijklmnopqrstuvwxyz"
-DIGITS[:punct] #=> "!\"\#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"
-DIGITS[:upper] #=> "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+DIGITS[:lower]  #=> "abcdefghijklmnopqrstuvwxyz"
+DIGITS[:punct]  #=> "!\"\#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"
+DIGITS[:upper]  #=> "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 DIGITS[:xdigit] #=> "0123456789ABCDEFabcdef"
 
 # Character Properties
 # Selected from ASCII 32..126
-DIGITS[:Alnum] #=> "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+DIGITS[:Alnum]
+#=> "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
 DIGITS[:Any]
 #=> " !\"\#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
 
@@ -149,7 +139,7 @@ DIGITS[:S] #=> "$+<=>^`|~"
 
 # Ranged Selections
 # v<hex>w<hex>_<filter>
-DIGITS[:v1d7d8w1d7e1_Any] #=> "𝟘𝟙𝟚𝟛𝟜𝟝𝟞𝟟𝟠𝟡"
+DIGITS[:v1d7d8w1d7e1_Any]   #=> "𝟘𝟙𝟚𝟛𝟜𝟝𝟞𝟟𝟠𝟡"
 # i<dec>j<dec>_<filter>
 DIGITS[:i120488j120513_Any] #=> "𝚨𝚩𝚪𝚫𝚬𝚭𝚮𝚯𝚰𝚱𝚲𝚳𝚴𝚵𝚶𝚷𝚸𝚹𝚺𝚻𝚼𝚽𝚾𝚿𝛀𝛁"
 
@@ -160,19 +150,19 @@ DIGITS[:u61u62] #=> "ab"
 DIGITS[:k97k98] #=> "ab"
 
 # BaseConvert's Custom Sets
-DIGITS[:bangs] #=> "!?"
-DIGITS[:typers] #=> "$&@"
-DIGITS[:operators] #=> "*+-/<=>^~"
+DIGITS[:bangs]      #=> "!?"
+DIGITS[:typers]     #=> "$&@"
+DIGITS[:operators]  #=> "*+-/<=>^~"
 DIGITS[:separators] #=> ",.:;|"
-DIGITS[:scapes] #=> "#\\"
-DIGITS[:groupers] #=> "()[]{}"
-DIGITS[:quotes] #=> "\"'`"
-DIGITS[:quoters] #=> "%\"'`"
-DIGITS[:spacers] #=> "_ "
-DIGITS[:ambiguous] #=> "012568BDGIOQSZl"
+DIGITS[:scapes]     #=> "#\\"
+DIGITS[:groupers]   #=> "()[]{}"
+DIGITS[:quotes]     #=> "\"'`"
+DIGITS[:quoters]    #=> "%\"'`"
+DIGITS[:spacers]    #=> "_ "
+DIGITS[:ambiguous]  #=> "012568BDGIOQSZl"
 
 # Composition, add merge:
-DIGITS[:d_ambiguous] #=> "0123456789BDGIOQSZl"
+DIGITS[:d_ambiguous]   #=> "0123456789BDGIOQSZl"
 # Composition, add top:
 DIGITS[:'d+ambiguous'] #=> "3479012568BDGIOQSZl"
 # Composition, subtract:
@@ -183,11 +173,12 @@ DIGITS[:'d-ambiguous'] #=> "3479"
 DIGITS[:alnum_bangs_typers_operators_separators_scapes_groupers_quoters_spacers]
 #=> "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!?$&@*+-/<=>^~,.:;|#\\()[]{}%\"'`_ "
 # :B64 is:
-DIGITS[:LN_k43k47] #=> "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
+DIGITS[:LN_k43k47]
+#=> "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
 # :U47 is:
-DIGITS[:'alnum-ambiguous'] #=> "3479ACEFHJKLMNPRTUVWXYabcdefghijkmnopqrstuvwxyz"
+DIGITS[:'alnum-ambiguous']
+#=> "3479ACEFHJKLMNPRTUVWXYabcdefghijkmnopqrstuvwxyz"
 ```
-
 ### class FromTo
 
 * `new(base: 10 Integer|Symbol|String, to_base: base, digits: :P95 String|Symbol|Integer, to_digits: digits) #=> FromTo` 
@@ -195,16 +186,14 @@ DIGITS[:'alnum-ambiguous'] #=> "3479ACEFHJKLMNPRTUVWXYabcdefghijkmnopqrstuvwxyz"
 * `#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        #=> 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"
+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`
@@ -217,24 +206,22 @@ b2h['//'] #=> "FFF"
 * `#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      #=> FFF 16:P95
 a.to_i #=> 4095
 b = a.to_digits(:U47)
-b #=> RRR 16:U47
+b      #=> RRR 16:U47
 b.to_i #=> 4095
 c = b.to_base(64, :B64)
-c #=> // 64:B64
+c      #=> // 64:B64
 c.to_i #=> 4095
 ```
-
 ## LICENSE:
 
 (The MIT License)
 
-Copyright (c) 2021 CarlosJHR64
+Copyright (c) 2022 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/base.rb

@@ -1,24 +1,65 @@
 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'
+  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
-    raise 'base must be greater than 1' unless base > 1
-    base
   end
-end
+  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/chars.rb

@@ -1,33 +1,38 @@
 module BaseConvert
-  class Chars < Array
-    attr_accessor :start,:stop
-    def initialize(start=32, stop=126)
-      @start,@stop = start,stop
+  # Chars provides ways of populating an ordered(as constructed) set
+  # with characters in UTF-8.
+  class Chars
+    def initialize
+      @start,@stop,@a = 32,126,[]
     end
 
+    attr_accessor :start,:stop
+    def to_a = @a
+    def to_s = @a.join
+
+    # Chars can search a range in UTF-8 for character classes.
+    # Use Chars#set to set the start and stop of the range.
     # 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)
+      unless /^([ij]\d+)|([vw]\h+)$/.match?(s)
+        raise 'expected /^([ij]\d+)|([vw]\h+)$/'
+      end
       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
+        (@start..@stop).each{x.match?(c=_1.chr(Encoding::UTF_8)) && yield(c)}
       when Symbol
         yield x[1..-1].to_i((x[0]=='u')? 16: 10).chr(Encoding::UTF_8)
       when String
@@ -39,21 +44,8 @@ module BaseConvert
       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
+    def add(x)    = chars_in(x){@a.push _1 unless @a.include?_1}
+    def top(x)    = chars_in(x){@a.delete _1;@a.push _1}
+    def remove(x) = chars_in(x){@a.delete _1}
   end
 end

data/lib/base_convert/digits.rb

@@ -1,96 +1,134 @@
 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
+  class Digits < Hash
+    def initialize
+      @registry = [:P95, :B64, :U47, :G94, :Q91, :W63]
     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
+
+    # Set super's [] definition as get
+    alias :get :[]
+    def [](key)
+      return (_=get key).is_a?(Symbol)?self[_]:_ if self.has_key? key
+      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+))+$/ # add single char by code
+            type.scan(/[uk]\h+/).each{chars.top _1.to_sym}
+          when /^(([ij]\d+)|([vw]\h+))+$/ # set start/stop range
+            type.scan(/[ijvw]\h+/).each{chars.set _1}
+          when /^[a-z][a-z]+$/ # add by POSIX bracket expression
+            chars.add Regexp.new "[[:#{type}:]]"
+          when /^[a-z]$/ # add by metacharacter
+            chars.add Regexp.new "\\#{type}"
+          when /^[A-Z]+$/i # add by property
+            type.scan(/[A-Z][a-z]*/).each{chars.add(/\p{#{_1}}/)}
+          when /^([+-])(\w+)$/ # top or remove chars of key given
+            (_=self[$2.to_sym]) and ($1=='+')? chars.top(_): chars.remove(_)
+          when /^(\p{L}+)(\d+)$/ # a registered set
+            l,m = $1,$2.to_i-1
+            n = self.keys.select{_1=~/^#{l}\d+$/}
+              .map{_1.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
-        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 -------------->^^^^^
+        return chars.to_s.freeze
+      when String
+        _=@registry.lazy.map{self[_1]}.detect{_1.start_with? key} and return _
         raise 'need at least 2 digits' unless key.length > 1
-        raise 'digits must not have duplicates' if key.length > key.chars.uniq.length
+        if key.length > key.chars.uniq.length
+          raise 'digits must not have duplicates'
+        end
         return key
+      when Integer
+        raise 'need digits to cover base' if key > 95
+        return self[:P95] # Defined in configuration.rb
       end
-      return digits
-    when Integer
-      raise 'need digits to cover base' if key > 95
-      return self[:P95] # Defined in configuration.rb
+      raise 'digits must be String|Symbol|Integer'
     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 registry(d=nil)
+      # BaseConvert::Number memoizes and uses specifically :P95, :B64, and :U47;
+      # giving these precedence above the rest.
+      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 label(d)
+      registry(d) or (d[0..1]+d[-2..-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
+    def memoize!(keys=@registry)
+      [*keys].each do |k|
+        # follow Symbol links 'till nil|String
+        while s=get(k) and not s.is_a? String
+          raise 'expected Symbol' unless s.is_a? Symbol
+          k = s
+        end
+        self[k]=self[k] unless s # memoize if needed
       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
+    def forget!(keys=@registry)
+      [*keys].each do |k|
+        # follow Symbol links 'till nil|String
+        while s = get(k) and not s.is_a? String
+          raise 'expected Symbol' unless s.is_a? Symbol
+          k = s
+        end
+        self.delete(k) if s
       end
-      self.delete(k) if s.is_a? String
     end
   end
-end
+
+  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
+  # 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'
 end

data/lib/base_convert/from_to.rb

@@ -1,6 +1,6 @@
 module BaseConvert
 class FromTo
-  include BaseConvert
+  include Methods
 
   def initialize(base: 10, to_base: base, digits: :P95, to_digits: digits)
     base      = BASE[base]

data/lib/base_convert/{base_convert.rb → methods.rb}

@@ -1,13 +1,9 @@
 # http://rosettacode.org/wiki/Non-decimal_radices/Convert#Ruby
 module BaseConvert
+module Methods
   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
+    string.chars.inject(0){_1*base + digits.index(_2)}
   end
 
   def tos(integer=to_i, base=@base, digits=@digits)
@@ -21,9 +17,10 @@ module BaseConvert
     string
   end
 
-  def ascii_ordered?(digits=@digits)
-    (1..(digits.length-1)).all?{|i|digits[i-1]<digits[i]}
+  def chars_ordered?(digits=@digits)
+    digits.chars.each_cons(2).all?{_1<_2}
   end
 
   extend self
 end
+end

data/lib/base_convert/number.rb

@@ -1,13 +1,14 @@
 module BaseConvert
 class Number
-  include BaseConvert
+  include Methods
   DIGITS.memoize!
+  INDEXa = DIGITS[:P95].index('a')
 
-  def self.infer(string)
+  def self.infer(string, error:'digits not all in P95')
     p95 = DIGITS[:P95]
     return 2, p95  if string.empty?
     chars = string.chars
-    raise 'need digits to cover string'  unless chars.all?{|_|p95.include?_}
+    raise error 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
@@ -26,20 +27,16 @@ class Number
 
   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
+    @validate = !!validate # ensure boolean
 
     # counter
     string = nil
     case counter
     when String
       string = counter
-      base, digits = Number.infer(counter)  if base.nil? and digits.nil?
+      if base.nil? and digits.nil?
+        base, digits = Number.infer(counter, error:'need digits to cover string')
+      end
     when Integer
       @integer = counter
       base, digits = 10, DIGITS[:P95]  if base.nil? and digits.nil?
@@ -51,21 +48,22 @@ class Number
     @digits = DIGITS[digits || base]
 
     # base
-    base = digits if base.nil? and digits.is_a? Symbol
+    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}
+        indeces = string.chars.map{@digits.index _1}
+        if missing = indeces.any?{_1.nil?} or exceeding = indeces.any?{_1>=@base}
           if @base <= INDEXa and DIGITS[:P95].start_with?(@digits)
+            # User ignored case, so fix it...
             string = string.upcase
-            indeces = string.chars.map{|_|@digits.index(_)}
-            missing = indeces.any?{|_|_.nil?} or exceeding = indeces.any?{|_|_>=@base}
+            indeces = string.chars.map{@digits.index _1}
+            missing = indeces.any?{_1.nil?} or exceeding = indeces.any?{_1>=@base}
           end
-          raise 'digits must cover string' if missing
+          raise 'digits must cover string'  if missing
           raise 'digits in string must be under base'  if exceeding
         end
       end
@@ -82,15 +80,9 @@ class Number
     "#{to_s} #{@base}:#{d}"
   end
 
-  def validate?
-    @validate
-  end
-
+  def validate? = @validate
   alias to_s tos
-
-  def to_i
-    @integer
-  end
+  def to_i = @integer
 
   def to_base(base, digits=(base.is_a?Symbol)? DIGITS[base] : @digits, validate=@validate)
     Number.new @integer, base: base, digits: digits, validate: validate

data/lib/base_convert.rb

@@ -1,11 +1,10 @@
 module BaseConvert
-  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'
+  VERSION = '7.0.221226'
+  autoload :Methods, 'base_convert/methods.rb'
+  autoload :Chars,   'base_convert/chars.rb'
+  autoload :DIGITS,  'base_convert/digits.rb'
+  autoload :BASE,    'base_convert/base.rb'
+  autoload :FromTo,  'base_convert/from_to.rb'
+  autoload :Number,  'base_convert/number.rb'
 end
 #`ruby`

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: base_convert
 version: !ruby/object:Gem::Version
-  version: 6.0.210201
+  version: 7.0.221226
 platform: ruby
 authors:
-- carlosjhr64
-autorequire:
+- CarlosJHR64
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-02-01 00:00:00.000000000 Z
+date: 2022-12-26 00:00:00.000000000 Z
 dependencies: []
 description: |
   BaseConvert - Number base conversion.
@@ -25,17 +25,16 @@ 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/methods.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
@@ -50,9 +49,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements:
-- 'ruby: ruby 3.0.0p0 (2020-12-25 revision 95aff21468) [x86_64-linux]'
-rubygems_version: 3.2.3
-signing_key:
+- 'ruby: ruby 3.1.2p20 (2022-04-12 revision 4491bb740a) [aarch64-linux]'
+rubygems_version: 3.3.7
+signing_key: 
 specification_version: 4
 summary: BaseConvert - Number base conversion.
 test_files: []

data/lib/base_convert/configuration.rb

@@ -1,88 +0,0 @@
-module BaseConvert
-  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