lite-uxid 1.5.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5c35d2426c2fffc91f8195a96c94ff26df0c41ffdb79041c5499952c93ccd240
-  data.tar.gz: 5a72d11d4fc6d3cec87411a623d072dec4ba1f17b810814b15c543da3a512d7b
+  metadata.gz: 767645737040b210cc058a0a781f89751f447e991aa03c527f5d12b039d1980a
+  data.tar.gz: 1c777db2675144f26b24ed2ec75d175c83f55d5ede9e83ab5d0d75ca2b76e692
 SHA512:
-  metadata.gz: 0a84caf603e6393456ac15d30afaf23fda68eec1480997ce64a54339abefcfc5fadf1afe4fb505f6b3f54119188e3f3405e040771e4a76cc4cae3f8b7f842693
-  data.tar.gz: 0d345ae245719fcfe669230925aee58feab58153c978c6089379cc750ae417325d98bd6b660aba695e2df85d540d88a543bfd5a11ce88556fb2ef835f81a860d
+  metadata.gz: 313da972f69d52e8951d552c3269500767e7fb80255de25c44d1bbe0d6497aaa3b0c398736b2e451d393ad0642446e298ebbad36a225528f010a96a8684f221e
+  data.tar.gz: 61ce05436d5e2793164007f1b28edd28ea138c9efbf02f0a6ac6ef021708d3171b61c77e2811dfe9c65ef764b46d55713e6121eefd57d87a22cb10e80a9c0eef

data/.rubocop.yml

@@ -23,6 +23,8 @@ Layout/LineLength:
   Enabled: false
 Layout/SpaceAroundMethodCallOperator:
   Enabled: true
+Lint/MissingSuper:
+  Enabled: false
 Lint/RaiseException:
   Enabled: true
 Lint/StructNewOverride:

data/CHANGELOG.md

@@ -6,6 +6,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.0.0] - 2024-09-23
+### Added
+- Scatterid reversible lib
+### Changed
+- Reorganize generators into better namespaces
+- Fixed issue where nanoid would return without the prefix
+- Moved charsets to constants
+
+## [1.5.2] - 2024-09-20
+### Changed
+- Fixed nanoid of differing length error
+
 ## [1.5.1] - 2024-09-20
 ### Changed
 - Use after commit on create instead of after create

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    lite-uxid (1.5.1)
+    lite-uxid (2.0.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -29,6 +29,7 @@ Or install it yourself as:
 * [Usage](#usage)
 * [Hashid](#hashid)
 * [NanoID](#nanoid)
+* [Scatterid](#scatterid)
 * [ULID](#ulid)
 * [UUID](#uuid)
 * [Options](#options)
@@ -41,13 +42,17 @@ Or install it yourself as:
 `config/initalizers/lite_uxid.rb`
 
 ```ruby
+Lite::Uxid::ALPHANUMERIC = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+Lite::Uxid::COCKFORDS_32 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+Lite::Uxid::WEB_SAFE     = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_"
+
 Lite::Uxid.configure do |config|
-  config.hashid_charset = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+  config.hashid_charset = ALPHANUMERIC
   config.hashid_salt = 1_369_136
   config.hashid_size = 16
-  config.nanoid_charset = "_-0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+  config.nanoid_charset = WEB_SAFE
   config.nanoid_size = 21
-  config.ulid_charset = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+  config.ulid_charset = COCKFORDS_32
   config.ulid_size = 26
   config.uuid_version = 4
 end
@@ -57,22 +62,22 @@ end
 
 #### Instance
 ```ruby
-coder = Lite::Uxid::Hashid.new(10, size: 12)
+coder = Lite::Uxid::Reversible::Hashid.new(10, size: 12)
 coder.encode #=> '67wGI0'
 ```
 
 #### Class
 ```ruby
-Lite::Uxid::Hashid.decode('67wGI0', size: 12) #=> 10
+Lite::Uxid::Reversible::Hashid.decode('67wGI0', size: 12) #=> 10
 ```
 
-## Hashid
+## HashID
 
 [More information](https://hashids.org)
 
 ```ruby
-Lite::Uxid::Hashid.encode(10)        #=> '1zWr1m0'
-Lite::Uxid::Hashid.decode('1zWr1m0') #=> 10
+Lite::Uxid::Reversible::Hashid.encode(10)        #=> '1zWr1m0'
+Lite::Uxid::Reversible::Hashid.decode('1zWr1m0') #=> 10
 ```
 
 ## NanoID
@@ -80,7 +85,16 @@ Lite::Uxid::Hashid.decode('1zWr1m0') #=> 10
 [More information](https://github.com/ai/nanoid)
 
 ```ruby
-Lite::Uxid::Nanoid.encode #=> 'sMuNUa3Cegn6r5GRQ4Ij2'
+Lite::Uxid::Irreversible::Nanoid.encode #=> 'sMuNUa3Cegn6r5GRQ4Ij2'
+```
+
+## ScatterID
+
+[More information](https://github.com/namick/scatter_swap)
+
+```ruby
+Lite::Uxid::Reversible::Scatterid.encode(10)           #=> '2056964183'
+Lite::Uxid::Reversible::Scatterid.decode('2056964183') #=> 10
 ```
 
 ## ULID
@@ -88,7 +102,7 @@ Lite::Uxid::Nanoid.encode #=> 'sMuNUa3Cegn6r5GRQ4Ij2'
 [More information](https://github.com/ulid/spec)
 
 ```ruby
-Lite::Uxid::Ulid.encode #=> '01GJAY9KGR539EZF4QWYEJGSN7'
+Lite::Uxid::Irreversible::Ulid.encode #=> '01GJAY9KGR539EZF4QWYEJGSN7'
 ```
 
 ## UUID
@@ -96,7 +110,7 @@ Lite::Uxid::Ulid.encode #=> '01GJAY9KGR539EZF4QWYEJGSN7'
 Implements `v4` and `v7` of the specification. [More information](https://en.wikipedia.org/wiki/Universally_unique_identifier)
 
 ```ruby
-Lite::Uxid::Uuid.encode #=> '4376a67e-1189-44b3-a599-7f7566bf105b'
+Lite::Uxid::Irreversible::Uuid.encode #=> '4376a67e-1189-44b3-a599-7f7566bf105b'
 ```
 
 ## Options
@@ -104,7 +118,7 @@ Lite::Uxid::Uuid.encode #=> '4376a67e-1189-44b3-a599-7f7566bf105b'
 Local options can be passed to override global options.
 
 ```ruby
-Lite::Uxid::Ulid.encode(charset: 'abc123', size: 12) #=> 'a3b12c12c3ca'
+Lite::Uxid::Irreversible::Ulid.encode(charset: 'abc123', size: 12) #=> 'a3b12c12c3ca'
 ```
 
 Passable options are:
@@ -114,6 +128,7 @@ Passable options are:
   charset: 'string',  # Available for: hashid, nanoid, ulid
   salt:    'string',  # Available for: hashid
   size:    'integer', # Available for: hashid, nanoid, ulid
+  spin:    'integer', # Available for: scatterid
   version: 'integer', # Available for: uuid
   prefix:  'string'   # Available for: hashid, nanoid
 }
@@ -155,6 +170,13 @@ class User < ActiveRecord::Base
 end
 ```
 
+#### ScatterID
+```ruby
+class User < ActiveRecord::Base
+  include Lite::Uxid::Record::Scatterid
+end
+```
+
 #### ULID
 ```ruby
 class User < ActiveRecord::Base

data/lib/generators/lite/uxid/templates/install.rb

@@ -6,6 +6,7 @@ Lite::Uxid.configure do |config|
   config.hashid_size = 16
   config.nanoid_charset = "_-0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
   config.nanoid_size = 21
+  config.scatterid_spin = 0
   config.ulid_charset = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
   config.ulid_size = 26
   config.uuid_version = 4

data/lib/lite/uxid/base.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Lite
+  module Uxid
+    module Base
+
+      def encode
+        raise NotImplementedError, "override encode method in #{coder_class}"
+      end
+
+      def decode
+        raise NotImplementedError, "override decode method in #{coder_class}"
+      end
+
+      private
+
+      def coder_value_for(key)
+        sym_key = :"#{coder_class.downcase}_#{key}"
+        return unless Lite::Uxid.configuration.respond_to?(sym_key)
+
+        opts.delete(key) || Lite::Uxid.configuration.send(sym_key)
+      end
+
+      def coder_charset
+        @coder_charset ||= coder_value_for(:charset)
+      end
+
+      def coder_class
+        @coder_class ||= self.class.name.split("::").last
+      end
+
+      def coder_length
+        @coder_length ||= coder_charset.size
+      end
+
+      def coder_prefix
+        @coder_prefix ||= opts.delete(:prefix)
+      end
+
+      def coder_salt
+        @coder_salt ||= coder_value_for(:salt)
+      end
+
+      def coder_size
+        @coder_size ||= coder_value_for(:size)
+      end
+
+      def coder_spin
+        @coder_spin ||= coder_value_for(:spin)
+      end
+
+      def coder_version
+        @coder_version ||= coder_value_for(:version)
+      end
+
+    end
+  end
+end

data/lib/lite/uxid/configuration.rb

@@ -3,20 +3,26 @@
 module Lite
   module Uxid
 
+    ALPHANUMERIC = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+    COCKFORDS_32 = "0123456789ABCDEFGHJKMNPQRSTVWXYZ"
+    WEB_SAFE     = "#{ALPHANUMERIC}-_".freeze
+
     class Configuration
 
       attr_accessor :hashid_charset, :hashid_size, :hashid_salt,
                     :nanoid_charset, :nanoid_size,
-                    :ulid_charset,   :ulid_size,
+                    :scatterid_spin,
+                    :ulid_charset, :ulid_size,
                     :uuid_version
 
       def initialize
-        @hashid_charset = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+        @hashid_charset = ALPHANUMERIC
         @hashid_salt = 1_369_136
         @hashid_size = 16
-        @nanoid_charset = "_-0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+        @nanoid_charset = WEB_SAFE
         @nanoid_size = 21
-        @ulid_charset = "0123456789ABCDEFGHJKMNPQRSTVWXYZ"
+        @scatterid_spin = 0
+        @ulid_charset = COCKFORDS_32
         @ulid_size = 26
         @uuid_version = 4
       end

data/lib/lite/uxid/irreversible/base.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Lite
+  module Uxid
+    module Irreversible
+      class Base
+
+        include Lite::Uxid::Base
+
+        attr_reader :opts
+
+        def initialize(opts = {})
+          @opts = opts
+        end
+
+        def self.encode(opts = {})
+          klass = new(opts)
+          klass.encode
+        end
+
+        def self.decode(opts = {})
+          klass = new(opts)
+          klass.decode
+        end
+
+        def decode
+          raise "#{coder_class} does not support decoding"
+        end
+
+      end
+    end
+  end
+end

data/lib/lite/uxid/irreversible/nanoid.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Lite
+  module Uxid
+    module Irreversible
+      class Nanoid < Base
+
+        def encode
+          encoded_id = +""
+
+          loop do
+            cached_bytes = bytes
+
+            (0...step).each do |idx|
+              byte = cached_bytes[idx] & mask
+              char = byte && coder_charset[byte]
+              next unless char
+
+              encoded_id << char
+              return "#{coder_prefix}#{encoded_id}" if encoded_id.size == coder_size
+            end
+          end
+
+          "#{coder_prefix}#{encoded_id}"
+        end
+
+        private
+
+        def bytes
+          SecureRandom.random_bytes(coder_size).bytes
+        end
+
+        def mask
+          @mask ||= (2 << (Math.log(coder_length - 1) / Math.log(2))) - 1
+        end
+
+        def step
+          @step = (1.6 * mask * coder_size / coder_length).ceil
+        end
+
+      end
+    end
+  end
+end

data/lib/lite/uxid/irreversible/ulid.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Lite
+  module Uxid
+    module Irreversible
+      class Ulid < Base
+
+        MASK = 0x1f
+
+        def encode
+          encoded_id = "0" * coder_size
+          oct = octect
+          pos = coder_size - 1
+
+          while oct.positive?
+            encoded_id[pos] = coder_charset[oct & MASK]
+            oct >>= 5
+            pos -= 1
+          end
+
+          encoded_id
+        end
+
+        private
+
+        def bytes
+          "#{unixtime_48bit}#{SecureRandom.random_bytes(10)}"
+        end
+
+        def octect
+          (hi, lo) = bytes.unpack("Q>Q>")
+          (hi << 64) | lo
+        end
+
+        def unixtime_ms
+          time = Time.respond_to?(:current) ? Time.current : Time.now
+          time.to_i * 1_000
+        end
+
+        def unixtime_48bit
+          [unixtime_ms].pack("Q>")[2..-1]
+        end
+
+      end
+    end
+  end
+end

data/lib/lite/uxid/irreversible/uuid.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Lite
+  module Uxid
+    module Irreversible
+      class Uuid < Base
+
+        def encode
+          case coder_version
+          when 7
+            SecureRandom.uuid_v7
+          else
+            SecureRandom.uuid
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/lite/uxid/record/hashid.rb

@@ -1,23 +1,23 @@
 # frozen_string_literal: true
 
-require "active_support" unless defined?(ActiveSupport)
-
 module Lite
   module Uxid
     module Record
       module Hashid
 
-        extend ActiveSupport::Concern
-
-        included do
-          after_commit :callback_generate_uxid!,
-                       if: proc { respond_to?(:uxid) && !uxid? },
-                       on: :create
+        def self.included(base)
+          base.extend ClassMethods
+          base.class_eval do
+            after_commit :callback_generate_uxid!,
+                         if: proc { respond_to?(:uxid) && !uxid? },
+                         on: :create
+          end
         end
 
-        class_methods do
+        module ClassMethods
+
           def find_by_uxid(uxid)
-            decoded_id = Lite::Uxid::Hashid.decode(uxid, prefix: new.uxid_prefix)
+            decoded_id = Lite::Uxid::Reversible::Hashid.decode(uxid, prefix: new.uxid_prefix)
             find_by(id: decoded_id)
           end
 
@@ -27,18 +27,19 @@ module Lite
 
             raise ActiveRecord::RecordNotFound
           end
+
         end
 
         def id_to_uxid
           return unless respond_to?(:uxid)
 
-          Lite::Uxid::Hashid.encode(id, prefix: uxid_prefix)
+          Lite::Uxid::Reversible::Hashid.encode(id, prefix: uxid_prefix)
         end
 
         def uxid_to_id
           return unless respond_to?(:uxid)
 
-          Lite::Uxid::Hashid.decode(uxid, prefix: uxid_prefix)
+          Lite::Uxid::Reversible::Hashid.decode(uxid, prefix: uxid_prefix)
         end
 
         def uxid_prefix

data/lib/lite/uxid/record/nanoid.rb

@@ -1,17 +1,15 @@
 # frozen_string_literal: true
 
-require "active_support" unless defined?(ActiveSupport)
-
 module Lite
   module Uxid
     module Record
       module Nanoid
 
-        extend ActiveSupport::Concern
-
-        included do
-          before_create :callback_generate_uxid!,
-                        if: proc { respond_to?(:uxid) && !uxid? }
+        def self.included(base)
+          base.class_eval do
+            before_create :callback_generate_uxid!,
+                          if: proc { respond_to?(:uxid) && !uxid? }
+          end
         end
 
         def uxid_prefix
@@ -24,7 +22,7 @@ module Lite
           random_nanoid = nil
 
           loop do
-            random_nanoid = Lite::Uxid::Nanoid.encode(prefix: uxid_prefix)
+            random_nanoid = Lite::Uxid::Irreversible::Nanoid.encode(prefix: uxid_prefix)
             break unless self.class.exists?(uxid: random_nanoid)
           end
 

data/lib/lite/uxid/record/scatterid.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Lite
+  module Uxid
+    module Record
+      module Scatterid
+
+        def self.included(base)
+          base.extend ClassMethods
+          base.class_eval do
+            after_commit :callback_generate_uxid!,
+                         if: proc { respond_to?(:uxid) && !uxid? },
+                         on: :create
+          end
+        end
+
+        module ClassMethods
+
+          def find_by_uxid(uxid)
+            decoded_id = Lite::Uxid::Reversible::Scatterid.decode(uxid, prefix: new.uxid_prefix)
+            find_by(id: decoded_id)
+          end
+
+          def find_by_uxid!(uxid)
+            record = find_by_uxid(uxid)
+            return record unless record.nil?
+
+            raise ActiveRecord::RecordNotFound
+          end
+
+        end
+
+        def id_to_uxid
+          return unless respond_to?(:uxid)
+
+          Lite::Uxid::Reversible::Scatterid.encode(id, prefix: uxid_prefix)
+        end
+
+        def uxid_to_id
+          return unless respond_to?(:uxid)
+
+          Lite::Uxid::Reversible::Scatterid.decode(uxid, prefix: uxid_prefix)
+        end
+
+        def uxid_prefix
+          nil
+        end
+
+        private
+
+        def callback_generate_uxid!
+          update_column(:uxid, id_to_uxid)
+        end
+
+      end
+    end
+  end
+end

data/lib/lite/uxid/record/ulid.rb

@@ -1,23 +1,21 @@
 # frozen_string_literal: true
 
-require "active_support" unless defined?(ActiveSupport)
-
 module Lite
   module Uxid
     module Record
       module Ulid
 
-        extend ActiveSupport::Concern
-
-        included do
-          before_create :callback_generate_uxid!,
-                        if: proc { respond_to?(:uxid) && !uxid? }
+        def self.included(base)
+          base.class_eval do
+            before_create :callback_generate_uxid!,
+                          if: proc { respond_to?(:uxid) && !uxid? }
+          end
         end
 
         private
 
         def callback_generate_uxid!
-          self.uxid = Lite::Uxid::Ulid.encode
+          self.uxid = Lite::Uxid::Irreversible::Ulid.encode
         end
 
       end

data/lib/lite/uxid/record/uuid.rb

@@ -1,23 +1,21 @@
 # frozen_string_literal: true
 
-require "active_support" unless defined?(ActiveSupport)
-
 module Lite
   module Uxid
     module Record
       module Uuid
 
-        extend ActiveSupport::Concern
-
-        included do
-          before_create :callback_generate_uxid!,
-                        if: proc { respond_to?(:uxid) && !uxid? }
+        def self.included(base)
+          base.class_eval do
+            before_create :callback_generate_uxid!,
+                          if: proc { respond_to?(:uxid) && !uxid? }
+          end
         end
 
         private
 
         def callback_generate_uxid!
-          self.uxid = Lite::Uxid::Uuid.encode
+          self.uxid = Lite::Uxid::Irreversible::Uuid.encode
         end
 
       end

data/lib/lite/uxid/reversible/base.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Lite
+  module Uxid
+    module Reversible
+      class Base
+
+        include Lite::Uxid::Base
+
+        attr_reader :id, :opts
+
+        def initialize(id, opts = {})
+          @id = id
+          @opts = opts
+        end
+
+        def self.encode(id, opts = {})
+          klass = new(id, opts)
+          klass.encode
+        end
+
+        def self.decode(id, opts = {})
+          klass = new(id, opts)
+          klass.decode
+        end
+
+      end
+    end
+  end
+end

data/lib/lite/uxid/reversible/hashid.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Lite
+  module Uxid
+    module Reversible
+      class Hashid < Base
+
+        def encode
+          encoded_id = encode_chars((id + coder_salt) << coder_size)
+          "#{coder_prefix}#{encoded_id}"
+        end
+
+        def decode
+          encoded_id = id.delete_prefix(coder_prefix.to_s)
+          (decode_chars(encoded_id) >> coder_size) - coder_salt
+        end
+
+        private
+
+        def encode_chars(decoded_id)
+          return "0" if decoded_id.zero?
+          return nil if decoded_id.negative?
+
+          str = ""
+
+          while decoded_id.positive?
+            str = "#{coder_charset[decoded_id % coder_length]}#{str}"
+            decoded_id /= coder_length
+          end
+
+          str
+        end
+
+        def decode_chars(encoded_id)
+          pos = 0
+          num = 0
+          len = encoded_id.size
+          max = len - 1
+
+          while pos < len
+            pow = coder_length**(max - pos)
+            num += coder_charset.index(encoded_id[pos]) * pow
+            pos += 1
+          end
+
+          num
+        end
+
+      end
+    end
+  end
+end

data/lib/lite/uxid/reversible/scatterid.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Lite
+  module Uxid
+    module Reversible
+      class Scatterid < Base
+
+        def encode
+          swap
+          scatter
+
+          "#{coder_prefix}#{joined_array}"
+        end
+
+        def decode
+          @id = id.delete_prefix(coder_prefix.to_s)
+
+          unscatter
+          unswap
+          joined_array.to_i
+        end
+
+        private
+
+        def zero_padded_id
+          @zero_padded_id ||= id.to_s.rjust(10, "0")
+        end
+
+        def coder_array
+          @coder_array ||= zero_padded_id.chars.collect(&:to_i)
+        end
+
+        def joined_array
+          coder_array.join
+        end
+
+        def swapper_map(index)
+          array = (0..9).to_a
+          Array.new(10) { |i| array.rotate!((index + i) ^ coder_spin).pop }
+        end
+
+        def swap
+          coder_array.map!.with_index { |digit, i| swapper_map(i)[digit] }
+        end
+
+        def unswap
+          coder_array.map!.with_index { |digit, i| swapper_map(i).rindex(digit) }
+        end
+
+        def scatter
+          sum_of_digits = coder_array.sum.to_i
+          @coder_array = Array.new(10) { coder_array.rotate!(coder_spin ^ sum_of_digits).pop }
+        end
+
+        def unscatter
+          scattered_array = coder_array
+          sum_of_digits = scattered_array.sum.to_i
+          @coder_array = []
+
+          coder_array.tap do |unscatter|
+            10.times do
+              unscatter.push(scattered_array.pop)
+              unscatter.rotate!((sum_of_digits ^ coder_spin) * -1)
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/lite/uxid/version.rb

@@ -3,7 +3,7 @@
 module Lite
   module Uxid
 
-    VERSION = "1.5.1"
+    VERSION = "2.0.0"
 
   end
 end

data/lib/lite/uxid.rb

@@ -1,16 +1,20 @@
 # frozen_string_literal: true
 
+require "securerandom" unless defined?(SecureRandom)
 require "generators/lite/uxid/install_generator" if defined?(Rails::Generators)
 
 require "lite/uxid/version"
 require "lite/uxid/configuration"
-require "lite/uxid/base/irreversible"
-require "lite/uxid/base/reversible"
+require "lite/uxid/base"
+require "lite/uxid/irreversible/base"
+require "lite/uxid/irreversible/nanoid"
+require "lite/uxid/irreversible/ulid"
+require "lite/uxid/irreversible/uuid"
+require "lite/uxid/reversible/base"
+require "lite/uxid/reversible/hashid"
+require "lite/uxid/reversible/scatterid"
 require "lite/uxid/record/hashid"
 require "lite/uxid/record/nanoid"
+require "lite/uxid/record/scatterid"
 require "lite/uxid/record/ulid"
 require "lite/uxid/record/uuid"
-require "lite/uxid/hashid"
-require "lite/uxid/nanoid"
-require "lite/uxid/ulid"
-require "lite/uxid/uuid"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lite-uxid
 version: !ruby/object:Gem::Version
-  version: 1.5.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Juan Gomez
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-09-20 00:00:00.000000000 Z
+date: 2024-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -217,17 +217,20 @@ files:
 - lib/generators/lite/uxid/install_generator.rb
 - lib/generators/lite/uxid/templates/install.rb
 - lib/lite/uxid.rb
-- lib/lite/uxid/base/irreversible.rb
-- lib/lite/uxid/base/reversible.rb
+- lib/lite/uxid/base.rb
 - lib/lite/uxid/configuration.rb
-- lib/lite/uxid/hashid.rb
-- lib/lite/uxid/nanoid.rb
+- lib/lite/uxid/irreversible/base.rb
+- lib/lite/uxid/irreversible/nanoid.rb
+- lib/lite/uxid/irreversible/ulid.rb
+- lib/lite/uxid/irreversible/uuid.rb
 - lib/lite/uxid/record/hashid.rb
 - lib/lite/uxid/record/nanoid.rb
+- lib/lite/uxid/record/scatterid.rb
 - lib/lite/uxid/record/ulid.rb
 - lib/lite/uxid/record/uuid.rb
-- lib/lite/uxid/ulid.rb
-- lib/lite/uxid/uuid.rb
+- lib/lite/uxid/reversible/base.rb
+- lib/lite/uxid/reversible/hashid.rb
+- lib/lite/uxid/reversible/scatterid.rb
 - lib/lite/uxid/version.rb
 - lite-uxid.gemspec
 homepage: http://drexed.github.io/lite-uxid

data/lib/lite/uxid/base/irreversible.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-require "securerandom" unless defined?(SecureRandom)
-
-module Lite
-  module Uxid
-    module Base
-      class Irreversible
-
-        attr_reader :opts
-
-        def initialize(opts = {})
-          @opts = opts
-        end
-
-        class << self
-
-          def encode(opts = {})
-            klass = new(opts)
-            klass.encode
-          end
-
-          def decode(opts = {})
-            klass = new(opts)
-            klass.decode
-          end
-
-        end
-
-        def encode
-          raise NotImplementedError, "override method in #{coder_class}"
-        end
-
-        def decode
-          raise NotImplementedError, "coder does not support decoding"
-        end
-
-        private
-
-        def coder_value_for(key)
-          sym_key = :"#{coder_class.downcase}_#{key}"
-          return unless Lite::Uxid.configuration.respond_to?(sym_key)
-
-          opts.delete(key) || Lite::Uxid.configuration.send(sym_key)
-        end
-
-        def coder_bytes
-          @coder_bytes ||= SecureRandom.random_bytes(coder_size).bytes
-        end
-
-        def coder_charset
-          @coder_charset ||= coder_value_for(:charset)
-        end
-
-        def coder_class
-          @coder_class ||= self.class.name.split("::").last
-        end
-
-        def coder_length
-          @coder_length ||= coder_charset.size
-        end
-
-        def coder_prefix
-          @coder_prefix ||= opts.delete(:prefix)
-        end
-
-        def coder_salt
-          @coder_salt ||= coder_value_for(:salt)
-        end
-
-        def coder_size
-          @coder_size ||= coder_value_for(:size)
-        end
-
-        def coder_version
-          @coder_version ||= coder_value_for(:version)
-        end
-
-      end
-    end
-  end
-end

data/lib/lite/uxid/base/reversible.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module Lite
-  module Uxid
-    module Base
-      class Reversible < Irreversible
-
-        attr_reader :id
-
-        def initialize(id, opts = {})
-          @id = id
-          super(opts)
-        end
-
-        class << self
-
-          def encode(id, opts = {})
-            klass = new(id, opts)
-            klass.encode
-          end
-
-          def decode(id, opts = {})
-            klass = new(id, opts)
-            klass.decode
-          end
-
-        end
-
-        def decode
-          raise NotImplementedError, "override method in #{coder_class}"
-        end
-
-      end
-    end
-  end
-end

data/lib/lite/uxid/hashid.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module Lite
-  module Uxid
-    class Hashid < Base::Reversible
-
-      def encode
-        uxid = encode_chars((id + coder_salt) << coder_size)
-        "#{coder_prefix}#{uxid}"
-      end
-
-      def decode
-        uxid = id.delete_prefix(coder_prefix.to_s)
-        (decode_chars(uxid) >> coder_size) - coder_salt
-      end
-
-      private
-
-      def encode_chars(decoded_id)
-        return "0" if decoded_id.zero?
-        return nil if decoded_id.negative?
-
-        str = ""
-
-        while decoded_id.positive?
-          str = "#{coder_charset[decoded_id % coder_length]}#{str}"
-          decoded_id /= coder_length
-        end
-
-        str
-      end
-
-      def decode_chars(encoded_id)
-        pos = 0
-        num = 0
-        len = encoded_id.size
-        max = len - 1
-
-        while pos < len
-          pow = coder_length**(max - pos)
-          num += coder_charset.index(encoded_id[pos]) * pow
-          pos += 1
-        end
-
-        num
-      end
-
-    end
-  end
-end

data/lib/lite/uxid/nanoid.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module Lite
-  module Uxid
-    class Nanoid < Base::Irreversible
-
-      def encode
-        uxid = (0...coder_size).each_with_object(+"") do |i, str|
-          str << coder_charset[coder_bytes[i] & 63]
-        end
-
-        "#{coder_prefix}#{uxid}"
-      end
-
-    end
-  end
-end

data/lib/lite/uxid/ulid.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module Lite
-  module Uxid
-    class Ulid < Base::Irreversible
-
-      MASK = 0x1f
-
-      def encode
-        oct = octect
-        ele = "0" * coder_size
-        pos = coder_size - 1
-
-        while oct.positive?
-          ele[pos] = coder_charset[oct & MASK]
-          oct >>= 5
-          pos -= 1
-        end
-
-        ele
-      end
-
-      private
-
-      def bytes
-        "#{unixtime_48bit}#{SecureRandom.random_bytes(10)}"
-      end
-
-      def octect
-        (hi, lo) = bytes.unpack("Q>Q>")
-        (hi << 64) | lo
-      end
-
-      def unixtime_ms
-        time = Time.respond_to?(:current) ? Time.current : Time.now
-        time.to_i * 1_000
-      end
-
-      def unixtime_48bit
-        [unixtime_ms].pack("Q>")[2..-1]
-      end
-
-    end
-  end
-end

data/lib/lite/uxid/uuid.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module Lite
-  module Uxid
-    class Uuid < Base::Irreversible
-
-      def encode
-        case coder_version
-        when 7
-          SecureRandom.uuid_v7
-        else
-          SecureRandom.uuid
-        end
-      end
-
-    end
-  end
-end