lite-uxid 1.5.2 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d000996f6e79fc0122e86a88c034391d9853146de2af1e44a1da19234ad538b1
-  data.tar.gz: 932aa03aeb3f62c58cb96328d38d9bc97ca09cc15f5f9a617147464448a45856
+  metadata.gz: 9078e4e13dc6877ed30a6a0028ad4327ff95d3056a5303f789137272e2bb0f12
+  data.tar.gz: c25e8acbb22ad4e4381bf9b07018eaf12daaf8e1d0123cee24f5fa9c8af8e87a
 SHA512:
-  metadata.gz: 1241d664904c1db3b9008bbd70bfb509070dc7adab95313ab5cac6a859fafeb6254f902ab0664086163bfa6d5998643d7f74f059525206d9354214f5595767ac
-  data.tar.gz: 51df74a8df875bbe8e67179960953d6ab54f8f49c11ab5783e90e5c31f6b8e8022ecf1074439083341cbdf9c40dce070c102d29bb947dd148b362f1dabdfc6a6
+  metadata.gz: bd5d7ef2cd4c425fb798dea874a7f395e20e5514ca07fb807d673feb75187e8a236236bd7f833084983a820d71a05a7a27c80d72138a13f888fb5b088a4c869f
+  data.tar.gz: 24462c53958076c1435e1012f3608002d23fdb01b3d59d00ac9d7d78c81f8f1d91b3a80fcac78d9a6a9ce358d9db728af6dd6df3d6815037a1c7dfa25515ba3f

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,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.0.1] - 2024-09-23
+### Changed
+- Renamed `Scatterid` to `Obfuscateid`
+### Removed
+- Removed prefix option from obfuscateid
+
+## [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

data/Gemfile.lock

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

data/README.md

@@ -27,8 +27,9 @@ Or install it yourself as:
 
 * [Configuration](#configuration)
 * [Usage](#usage)
-* [Hashid](#hashid)
+* [HashID](#hashid)
 * [NanoID](#nanoid)
+* [ObfuscateID](#obfuscateid)
 * [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'
+```
+
+## ObfuscateID
+
+[More information](https://github.com/namick/scatter_swap)
+
+```ruby
+Lite::Uxid::Reversible::Obfuscateid.encode(10)         #=> '2056964183'
+Lite::Uxid::Reversible::Obfuscateid.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: obfuscateid
   version: 'integer', # Available for: uuid
   prefix:  'string'   # Available for: hashid, nanoid
 }
@@ -144,27 +159,11 @@ t.uuid :uxid, null: false, index: { unique: true }
 #### HashID
 ```ruby
 class User < ActiveRecord::Base
+  # Pick one:
   include Lite::Uxid::Record::Hashid
-end
-```
-
-#### NanoID
-```ruby
-class User < ActiveRecord::Base
   include Lite::Uxid::Record::Nanoid
-end
-```
-
-#### ULID
-```ruby
-class User < ActiveRecord::Base
+  include Lite::Uxid::Record::Obfuscateid
   include Lite::Uxid::Record::Ulid
-end
-```
-
-#### UUID
-```ruby
-class User < ActiveRecord::Base
   include Lite::Uxid::Record::Uuid
 end
 ```
@@ -176,16 +175,16 @@ class User < ActiveRecord::Base
   include Lite::Uxid::Record::Hashid
 
   def uxid_prefix
-    "sub_"
+    "usr_"
   end
 end
 ```
 
 **Usage**
 
-Using one of the mixins above provides a handy method to find records by uxid.
+Using the `hashid` and `nanoid` above provide handy methods to find records by uxid.
 
-#### HashID methods
+#### Hashing methods
 ```ruby
 user = User.new
 user.id_to_uxid #=> Encodes the records id to uxid
@@ -200,15 +199,10 @@ User.find_by_uxid!('x123') #=> Raises an ActiveRecord::RecordNotFound error if n
 
 ## Benchmarks
 
-The classes ranked from fastest to slowest are `UUID`, `Hashid`, `Nanoid`, and `Ulid`.
+The classes ranked from fastest to slowest are `UUID`, `HashID`, `NanoID`, `ULID`, and `ObfuscateID`.
 
 View how each compares by running the [benchmarks](https://github.com/drexed/lite-uxid/tree/master/benchmarks).
 
-#### Alternatives
-
-Learn more about alternative functions and more advance hashing setups:
-[hashids.org](https://hashids.org)
-
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/benchmarks/compare.rb

@@ -8,22 +8,30 @@ require "lite/uxid"
 Benchmark.ips do |x|
   x.report("Hashid") do
     id = rand(1..1_000_000)
-    Lite::Uxid::Hashid.encode(id)
+    Lite::Uxid::Reversible::Hashid.encode(id)
   end
 
+  x.report("Obfuscateid") do
+    id = rand(1..1_000_000)
+    Lite::Uxid::Reversible::Obfuscateid.encode(id)
+  end
+
+  # The irreversible examples include `rand` simulate
+  # the extra work just like reversible examples.
+
   x.report("NanoID") do
-    _id = rand(1..1_000_000) # To simulate the extra work from `rand`
-    Lite::Uxid::Nanoid.encode
+    _id = rand(1..1_000_000)
+    Lite::Uxid::Irreversible::Nanoid.encode
   end
 
   x.report("ULID") do
-    _id = rand(1..1_000_000) # To simulate the extra work from `rand`
-    Lite::Uxid::Ulid.encode
+    _id = rand(1..1_000_000)
+    Lite::Uxid::Irreversible::Ulid.encode
   end
 
   x.report("UUID") do
-    _id = rand(1..1_000_000) # To simulate the extra work from `rand`
-    Lite::Uxid::Uuid.encode
+    _id = rand(1..1_000_000)
+    Lite::Uxid::Irreversible::Uuid.encode
   end
 
   x.compare!

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.obfuscateid_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,
+                    :obfuscateid_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"
+        @obfuscateid_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/obfuscateid.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Lite
+  module Uxid
+    module Record
+      module Obfuscateid
+
+        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::Obfuscateid.decode(uxid)
+            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::Obfuscateid.encode(id)
+        end
+
+        def uxid_to_id
+          return unless respond_to?(:uxid)
+
+          Lite::Uxid::Reversible::Obfuscateid.decode(uxid)
+        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/obfuscateid.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Lite
+  module Uxid
+    module Reversible
+      class Obfuscateid < Base
+
+        def encode
+          swap
+          scatter
+          result
+        end
+
+        def decode
+          unscatter
+          unswap
+          result
+        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 result
+          coder_array.join.to_i
+        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.2"
+    VERSION = "2.0.1"
 
   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/obfuscateid"
 require "lite/uxid/record/hashid"
 require "lite/uxid/record/nanoid"
+require "lite/uxid/record/obfuscateid"
 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.2
+  version: 2.0.1
 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/obfuscateid.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/obfuscateid.rb
 - lib/lite/uxid/version.rb
 - lite-uxid.gemspec
 homepage: http://drexed.github.io/lite-uxid

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

@@ -1,78 +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_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,42 +0,0 @@
-# frozen_string_literal: true
-
-module Lite
-  module Uxid
-    class Nanoid < Base::Irreversible
-
-      def encode
-        uxid = +""
-
-        loop do
-          cached_bytes = bytes
-
-          (0...step).each do |idx|
-            byte = cached_bytes[idx] & mask
-            char = byte && coder_charset[byte]
-            next unless char
-
-            uxid << char
-            return uxid if uxid.size == coder_size
-          end
-        end
-
-        "#{coder_prefix}#{uxid}"
-      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

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