make_id 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 90cbe0cbac923318d4badd6c848042404633a27c6fbecdd7e2509aee6c31ab5c
-  data.tar.gz: 41f946d9367bb73257ac31ffce792bd309f2e707c44b39003d66dcc3d1890a49
+  metadata.gz: 30fbadcaf247ed032060da86a3634f1124cc550b6061fd8599dd63f8f07ce473
+  data.tar.gz: 1fed2e5cd4c0ace07c5457a7b0f3839ea0756d737a842f2876390121cf88374e
 SHA512:
-  metadata.gz: da8822e1194eb4ed1e51f1090f120db17cdd421fc330f84dbe4b4556c1dd71eac4dc33dff678768999cee03ad21749a9f3bbb5a2949ced4f83c7f7afd802128a
-  data.tar.gz: '038ae0b3bc50252cd75eec5fb7283feb27381e3362bd2681fbba6ff225865727ef4fa560f84d24e8c4703f5ba96ce168c9278462b9469b97323ab981869e387d'
+  metadata.gz: 234e0c71427fd3ec7f522862c42698afb475702baf6e70bf9e524d98ded74c26f9652b404e4afea82bbb0b0e2cd8daf181c505bb2a44c25ac12d5611418feb43
+  data.tar.gz: 2f682f097b4d791c956b381c9007c14a4748dc2e3e97c21f5e8a5942f54e1369c5cc361033a41aa88e65f2ce9f1fada51fac98b4f22c1684e36d3fbf6a46bc05

data/README.md

@@ -40,18 +40,19 @@ numeric codes.
 
 Bases supported are:
 
-- Base62: digits, upper, and lower-case letters. No special characters
+- Base94: Base64 (Upper, Lower, Digits) with 30 extra special characters
+- Base64: Url-Safe version. Base64 but swaps the plus and slash by dash and underscore respectively.
+- Base62: digits, upper, and lower-case letters. No special characters. The default.
 - Base32: digits and upper case without ambiguous characters "1lI" or "oO0"
 - Base 2 through 36 (except 32): Ruby's `Integer#to_s(base)` is used
-- Base64: Uses the `Base64.urlsafe_encode64` such has 2 special characters.
-- Base63: It is not implemented.
 
-The Base32 may seem out of place, but is useful for alpha-numeric codes the users are required to type, such as redemption codes.
-All letter are folded to upper-case, and ambiguous characters are converted to the canonical ones.
+The Base32 may seem out of place, but is useful for alpha-numeric codes the users are required to type or speak,
+such as serial numbers or license codes.
+All letters are upper-case, and ambiguous characters are converted to the canonical ones.
 
-    MakeId.int_to_base(123456789, 32) #=> "3nqk8n"
-    MakeId.from_base("3nqk8n", 10)    #=> 123456789
-    MakeId.int_to_base(123456789, 32) #=> "3nqk8n"
+    MakeId.int_to_base(123456789, 32) #=> "3NQK8N"
+    MakeId.from_base("3NQK8N", 10)    #=> 123456789
+    MakeId.int_to_base(123456789, 32) #=> "3NQK8N"
     MakeId.verify_base32_id("...")    #=> corrected_id or nil if error
 
 ### Random Integer
@@ -120,7 +121,7 @@ You can also pass in options to return it as a different base, and with a check
 
     MakeId.app_worker_id = 234
     MakeId.snowflake_id => 618905333721374720
-    MakeId.snowflake_id(worker_id: 12, base: 32, sequence_method: :random) #=> "2tmxk6ne81jd5"
+    MakeId.snowflake_id(worker_id: 12, base: 32, sequence_method: :random) #=> "2TMXK6NE81JD5"
 
 The `snowflake_uuid` method provides a time-based identifier, great for sorting just as sequential numbers, but unique enough to fit the bill.
 

data/lib/make_id/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MakeId
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/make_id.rb

@@ -2,7 +2,6 @@
 
 require_relative "make_id/version"
 require "securerandom"
-require "base64"
 require "zlib"
 
 # MakeID generates record Identifiers other than sequential integers.
@@ -11,10 +10,27 @@ require "zlib"
 # Adopt   - Copy this file to your application with the above attribution to
 #           allow others to find fixes, documentation, and new features.
 module MakeId
-  # class Error < StandardError; end
+  class Error < StandardError; end
 
-  CHARS32 = "0123456789abcdefghjkmnpqrstvwxyz" # Avoiding ambiguous 0/o i/l/I
-  CHARS62 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+  # Base32 avoids ambiguous letters for 0/o/O and i/I/l/1. This is useful
+  # for human-interpreted codes for serial numbers, license keys, etc.
+  BASE32 = "0123456789ABCDEFGHJKMNPQRSTVWXYZ"
+
+  # Ruby's Integer.to_s(2..36) uses extended Hexadecimal: 0-9,a-z.
+  # Base62 includes upper-case letters as well, maintaining ASCII cardinality.
+  BASE62 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+
+  # Base64 Does not use ASCII-collating (sort) character set
+  BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
+
+  # Base94 extends Base64 with all printable ASCII special characters.
+  # Using Base of 90 won't use quotes, backslash
+  BASE94 = BASE64 + %q(!$%&()*,-.:;<=>?@[]^_{|}~#`'"\\)
+
+  # URL-Encoded Base64 swaps the + and / for - and _ respectively to avoid URL Encoding
+  URL_BASE64 = BASE64.tr("+/", "-_")
+
+  # TWitter Snowflake starts its epoch at this time.
   EPOCH_TWITTER = Time.utc(2006, 3, 21, 20, 50, 14)
 
   @@app_worker_id = ENV.fetch("APP_WORKER_ID", 0)
@@ -64,16 +80,9 @@ module MakeId
   # Base 64 uses URL-safe characters. Bases 19-32 and below use a special
   # character set that avoids visually ambiguous characters. Other bases
   # utilize the full alphanumeric characer set (digits, lower/upper letters).
-  def self.random(size = 16, base: 62)
-    raise "Base must be between 2 and 62, or 64, not #{base}" unless base < 63 || base == 64
-    if base == 62
-      SecureRandom.alphanumeric(size)
-    elsif base == 64
-      SecureRandom.urlsafe_base64(size)
-    else
-      alpha = (base <= 32) ? CHARS32 : CHARS62
-      (1..size).map { alpha[SecureRandom.rand(base - 1)] }.join
-    end
+  def self.random(size = 16, base: 62, chars: nil)
+    _, chars = base_characters(base, chars)
+    SecureRandom.alphanumeric(size, chars: chars.chars)
   end
 
   ##############################################################################
@@ -89,6 +98,12 @@ module MakeId
     id
   end
 
+  def self.random_id_password(bytes: 8, base: 10, absolute: true, alpha: nil)
+    id = random_id(bytes: bytes)
+    pass = random_id(bytes: 16)
+    [int_to_base(id, base), encode_alphabet(pass, alpha || BASE94, seed: id)]
+  end
+
   ##############################################################################
   # UUID - Universally Unique Identifier
   ##############################################################################
@@ -113,7 +128,7 @@ module MakeId
   # suitable for URL's or where you don't want to show a sequential number.
   # A check digit is added to the end to help prevent typos.
   def self.nano_id(size: 20, base: 62, check_digit: true)
-    # alpha = (base <= 32) ? CHARS32 : CHARS62
+    # alpha = (base <= 32) ? BASE32 : BASE62
     size -= 1 if check_digit
     id = random(size, base: base)
     check_digit ? append_check_digit(id, base) : id
@@ -148,20 +163,20 @@ module MakeId
   end
 
   ##############################################################################
-  # Event Id - A nano_id, but timestamped event identifier: YMDHMSUUrrrrc
+  # TEMPORAL ID's
   ##############################################################################
 
-  # Returns an event timestamp of the form YMDHMSUUrrrrc
+  # Event Id - A nano_id, but timestamped event identifier: YMDHMSUUrrrrc
   def self.event_id(size: 12, check_digit: false, time: nil)
     time ||= Time.new.utc
     usec = int_to_base((time.subsec.to_f * 62 * 62).to_i, 62)
     parts = [
-      CHARS62[time.year % @@epoch.year],
-      CHARS62[time.month],
-      CHARS62[time.day],
-      CHARS62[time.hour],
-      CHARS62[time.min],
-      CHARS62[time.sec],
+      BASE62[time.year % @@epoch.year],
+      BASE62[time.month],
+      BASE62[time.day],
+      BASE62[time.hour],
+      BASE62[time.min],
+      BASE62[time.sec],
       usec.rjust(2, "0") # 2-chars, 0..3843
     ]
     nano_size = size - 8 - (check_digit ? 1 : 0)
@@ -183,10 +198,10 @@ module MakeId
     end
 
     [
-      CHARS62[time.year % @@epoch.year],
-      CHARS62[time.month],
-      CHARS62[time.day], # "-",
-      CHARS62[time.hour].downcase,
+      BASE62[time.year % @@epoch.year],
+      BASE62[time.month],
+      BASE62[time.day], # "-",
+      BASE62[time.hour].downcase,
       int_to_base(seconds, 32).rjust(3, "0"), # 3 chars
       int_to_base((time.subsec.to_f * 32 * 32).to_i, 32), # 2 chars
       sequence.to_s(32).rjust(2, "0"), # 2 chars "-",
@@ -298,23 +313,9 @@ module MakeId
   # Ruby's int.to_s(base) only goes to 36. Base 32 is special as it does not
   # contain visually ambiguous characters (1, not i, I, l, L) and (0, not o or O)
   # Which is useful for serial numbers or codes the user has to read or type
-  def self.int_to_base(int, base = 62, check_digit: false)
-    int = int.to_i
-    if base == 10
-      id = int.to_s
-    elsif base == 64
-      id = Base64.urlsafe_encode64(int.to_s).delete("=")
-    elsif base == 32 || base > 36
-      alpha = (base <= 32) ? CHARS32 : CHARS62
-      id = ""
-      while int > (base - 1)
-        id = alpha[int % base] + id
-        int /= base
-      end
-      id = alpha[int] + id
-    else
-      id = int.to_s(base)
-    end
+  def self.int_to_base(int, base = 62, check_digit: false, chars: nil)
+    base, chars = base_characters(base, chars)
+    id = encode_alphabet(int, chars)
     check_digit ? append_check_digit(id, base) : id
   end
 
@@ -323,20 +324,56 @@ module MakeId
   # Parses a string as a base n number and returns its decimal integer value
   def self.base_to_int(string, base = 62, check_digit: false)
     # TODO check_digit
-    if base == 64
-      int = Base64.urlsafe_decode64(string.to_s + "==")
-    elsif base == 32 || base > 36
-      alpha = (base <= 32) ? CHARS32 : CHARS62
-      string = string.to_s
-      int = 0
-      string.each_char { |c| int = int * base + alpha.index(c) }
-    else
-      int = string.to_i(base)
+    _, chars = base_characters(base, chars)
+    decode_alphabet(string, chars)
+  end
+
+  singleton_class.alias_method :from_base, :base_to_int
+
+  def self.encode_alphabet(int, alpha = BASE62, seed: nil)
+    base = alpha.size
+    alpha = alpha.chars.shuffle(random: Random.new(seed)).join if seed
+    id = ""
+    while int > (base - 1)
+      id = alpha[int % base] + id
+      int /= base
     end
+    alpha[int] + id
+  end
+
+  def self.decode_alphabet(string, alpha = BASE32, seed: nil, base: nil)
+    base ||= alpha.size
+    alpha = alpha.chars.shuffle(random: Random.new(seed)).join if seed
+    int = 0
+    string.each_char { |c| int = int * base + alpha.index(c) }
     int
+  rescue
+    nil
   end
 
-  singleton_class.alias_method :from_base, :base_to_int
+  # Returns the refined base and characters used for the base conversions
+  def self.base_characters(base, chars = nil, shuffle_seed: nil)
+    if chars
+      base ||= chars.size
+      chars = chars[0..(base - 1)]
+    elsif base > 94 || base < 2
+      raise Error.new("Base#{base} is not supported")
+    elsif base > 64
+      chars = BASE94[0..(base - 1)]
+    elsif base > 62
+      chars = URL_BASE64[0..(base - 1)]
+    elsif base == 32
+      chars = BASE32
+    else
+      chars = BASE62[0..(base - 1)]
+    end
+    if shuffle_seed
+      chars = chars.chars.shuffle(random: Random.new(shuffle_seed)).join
+    end
+    base = chars.size
+
+    [base, chars]
+  end
 
   ##############################################################################
   # Check Digit

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: make_id
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Allen Fair
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-13 00:00:00.000000000 Z
+date: 2024-11-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64