universalid 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ea53203a7628a0d38447dabfa1fd8a4511fd07b4a02764245c28ef3e5c8550f0
-  data.tar.gz: 3b72055e784386686c81302d348ad25875694e5943f9b812c19f56e09344883f
+  metadata.gz: da76bb6c2a7189ce9dfdd3c51e823bd4953d4e808d87f19bf3454071b6b12b38
+  data.tar.gz: 9e5e859338c65f59f6a2db08c7c518591b234ff2351a3e23ecfa34044d6443a3
 SHA512:
-  metadata.gz: 4203c29b99f7beb2cf31db1f3ca982ecd9295e25cf21ea55425dd23102eb579077513213bb44054ec628714ec17c24b13944a581f583c8e9086ce160e91fcd3b
-  data.tar.gz: e666af53d6431f8dc5399ad92831a9bf2d6db9cd352fd231e510328897a64fe3aa864610a7a35d438099bd9daf80ed15610e78eacb1fd8c03a2977ce8fc075bc
+  metadata.gz: eaa7ecb09b580b5aa197f3ae806027ea7a403b141617631f4036da0aaf1acd4d6af77a9a0776f45f5d8de192a81445a8d6ca358c6fd3b0bfce0edff31466754e
+  data.tar.gz: e43c45212acf57c0cadfea74b18eeeb2f241efd2b9eced81af3e0013aaa76f605d671122fd8c9b2969a513fde62c1a27427e6823c2aa6b6259c7c41ca540f617

data/README.md

@@ -2,7 +2,7 @@
   <h1 align="center">Universal ID</h1>
   <p align="center">
     <a href="http://blog.codinghorror.com/the-best-code-is-no-code-at-all/">
-      <img alt="Lines of Code" src="https://img.shields.io/badge/loc-692-47d299.svg" />
+      <img alt="Lines of Code" src="https://img.shields.io/badge/loc-750-47d299.svg" />
     </a>
     <a href="https://codeclimate.com/github/hopsoft/universalid/maintainability">
       <img src="https://api.codeclimate.com/v1/badges/567624cbe733fafc2330/maintainability" />
@@ -33,7 +33,7 @@
       <img alt="Twitter Follow" src="https://img.shields.io/twitter/url?label=%40hopsoft&style=social&url=https%3A%2F%2Ftwitter.com%2Fhopsoft">
     </a>
   </p>
-  <h2 align="center">URL-Safe Portability for Ruby Objects</h2>
+  <h2 align="center">URL-Safe Portability for any Ruby Object</h2>
 </p>
 
 **Universal ID introduces a paradigm shift in Ruby development with powerful recursive serialization.**
@@ -42,43 +42,151 @@ This innovative library transforms any Ruby object into a URL-safe string, enabl
 It leverages both [MessagePack](https://msgpack.org/) and [Brotli](https://github.com/google/brotli) _(a combo built for speed and best-in-class data compression)_.
 MessagePack + Brotli is up to 30% faster and within 2-5% compression rates compared to Protobuf. <a title="Source" href="https://g.co/bard/share/e5bdb17aee91">↗</a>
 
-## Example Use Cases
-
-- **State Preservation in Web Apps**: Maintain the state of a user's session in web applications without storing data server-side
-- **API Data Transfer**: Serialize complex data structures into a URI format for easy and efficient transfer via RESTful APIs
-- **Bookmarkable Configurations**: Allow users to bookmark configurations of a web application by embedding the state in the URL
-- **Deep Linking in Web Apps**: Create deep links that carry complex state information, allowing users to return to a specific state within an application
-- **Debugging Tools**: Serialize objects and their state for logging purposes, aiding in debugging and error tracking
-- **Shareable Reports and Views**: Encode the state of reports or customized views in web applications, making them shareable
-- **Inter-Service Communication**: Facilitate communication between different services by passing complex objects in a standardized, URL-safe format
-- **Client-Side Storage Optimization**: Reduce the need for client-side storage by keeping serialized state in URLs or Cookies
-- **Versioning Serialized Objects**: Enable versioning of serialized objects in URLs, allowing users to access different states or versions of data
-- **Data Export/Import**: Simplify the export and import process of complex objects between different environments or systems by using URI-encoded data
-
-This is just a fraction of what's possible with Universal ID. It's an invaluable tool for a range of development needs. API design, data management, user experience, and more. **Endless possibilities!**
-
 <!-- Tocer[start]: Auto-generated, don't remove. -->
 
 ## Table of Contents
 
+  - [Example Use Cases](#example-use-cases)
   - [Supported Data Types](#supported-data-types)
     - [Scalars](#scalars)
     - [Composites](#composites)
-    - [ActiveRecord](#activerecord)
-      - [Why Universal ID with ActiveRecord?](#why-universal-id-with-activerecord)
-    - [Custom Datatypes](#custom-datatypes)
+    - [Custom Types](#custom-types)
+    - [Contributed Types](#contributed-types)
   - [Settings and Prepack Options](#settings-and-prepack-options)
   - [Advanced ActiveRecord](#advanced-activerecord)
   - [ActiveRecord::Relation Support](#activerecordrelation-support)
   - [SignedGlobalID](#signedglobalid)
+  - [Fingerprinting (Implicit Versioning)](#fingerprinting-implicit-versioning)
   - [Performance and Benchmarks](#performance-and-benchmarks)
   - [Sponsors](#sponsors)
   - [License](#license)
 
 <!-- Tocer[finish]: Auto-generated, don't remove. -->
 
-> :rocket: **Ready to Dive In?**: All the code examples below can be tested on your local machine. Simply clone the repo and run `bin/console` to begin exploring. Don't forget to execute `bundle` first to ensure all dependencies are up to date. Happy coding!
+## Example Use Cases
+
+Universal ID's powerful serialization capabilities unlock a myriad of possibilities across various domains.
+Here are a few possibilities.
+
+- **State Management for Web Applications**:
+  Facilitate seamless user experiences in web applications by preserving and transferring UI states, even across different sessions.
+
+- **Data Serialization for Distributed Systems**:
+  Enable efficient communication in distributed systems by serializing complex data structures for network transmission.
+
+- **Configuration Settings for Software Applications**:
+  Store and manage configuration settings for software applications, allowing easy transfer and versioning of settings across installations.
+
+- **Session Continuity in Cloud Services**:
+  Ensure continuity of user sessions in cloud-based applications, enabling users to pick up their work exactly where they left off, regardless of the device or location.
+
+- **Audit Logging for Complex Transactions**:
+  Record detailed states of complex transactions in audit logs, providing a comprehensive and reversible record of actions for compliance and analysis.
+
+- **Machine-to-Machine Communication**:
+  Standardize data formats for machine-to-machine communication, facilitating interoperability and data exchange in IoT and other automated systems.
+
+These use cases demonstrate the versatility and power of Universal ID in various application and business scenarios, offering solutions that enhance efficiency, user experience, and system reliability.
+
+<details>
+  <summary><b>See More Use Cases</b>... ▾</summary>
+  <p></p>
+
+  Harnessing the capabilities of this advanced low-level tool in your libraries and applications might initially seem daunting.
+  To assist you in unlocking its full potential, here are some additional suggestions to help you get started.
+
+  - **API Response Caching**
+    Cache complex API responses as serialized strings, allowing for efficient storage and quick retrieval.
+
+  - **Asset Management in Enterprises**
+    Serialize asset information, including status and location, for efficient tracking and management.
+
+  - **Audit Logging for Financial Transactions**
+    Serialize transaction states for audit trails in financial applications, providing detailed and reversible records for compliance.
+
+  - **Automated Testing of Web Applications**
+    Serialize application states to reproduce and test various scenarios automatically.
+
+  - **Backup and Restore of Application States**
+    Create snapshots of application states that can be backed up and later restored.
+
+  - **Configuration Management in DevOps**
+    Serialize configuration settings for software deployments, enabling easy versioning and rollback.
+
+  - **Content Management Systems (CMS)**
+    Serialize page or post states in CMS, enabling advanced versioning and preview functionalities.
+
+  - **Customer Support Tools**
+    Serialize user issues and their context, helping support teams to quickly understand and resolve customer problems.
+
+  - **Data Migration Between Databases**
+    Serialize entire database records for easy transfer between different database systems or formats.
+
+  - **Educational Platforms**
+    Serialize user progress and states in educational platforms, allowing students to pause and resume their learning activities.
+
+  - **E-commerce Cart Persistence**
+    Serialize shopping cart contents, enabling users to return to a filled cart even after their session expires.
+
+  - **Energy Management Systems**
+    Serialize energy usage data from various sensors for analysis and monitoring.
+
+  - **Environmental Monitoring Systems**
+    Serialize sensor data from environmental monitoring systems for analysis and historical record keeping.
+
+  - **Event Sourcing in Applications**
+    Use serialized states for event sourcing, maintaining an immutable log of state changes over time.
+
+  - **Gaming State Preservation**
+    Store game states as serialized strings, allowing players to resume games exactly where they left off.
+
+  - **Healthcare Data Exchange**
+    Securely transfer patient data between different healthcare systems while maintaining the integrity of complex data structures.
+
+  - **IoT Device State Management**
+    Serialize the state of IoT devices for efficient transmission over networks, aiding in remote monitoring and control.
+
+  - **Legal Document Management**
+    Serialize versions of legal documents, maintaining a trail of edits and changes for auditing.
+
+  - **Machine Learning Data Preparation**
+    Serialize complex data structures used in machine learning pipelines for efficient processing.
+
+  - **Microservice Communication**
+    Serialize complex objects for inter-service communication, ensuring efficient data transfer and reducing the need for complex parsing logic.
+
+  - **Real Estate Portfolio Management**
+    Serialize complex property data for portfolio management and analysis.
+
+  - **Real-time Collaboration Tools**
+    Serialize document or application states for real-time collaboration tools, ensuring consistency across different user sessions.
+
+  - **Research Data Management**
+    Serialize research data and experimental setups for ease of sharing and replication of experiments.
+
+  - **Retail Inventory Management**
+    Serialize inventory data, including details of products, for efficient management and tracking.
+
+  - **Session Continuity Across Devices**
+    Store user session data as a serialized string, enabling users to resume their session on a different device without loss of context.
+
+  - **State Management for Single Page Applications (SPAs)**
+    Serialize UI states into URL-safe strings, enabling bookmarking or sharing of specific application states.
 
+  - **Supply Chain Logistics**
+    Serialize complex logistics and shipment data, aiding in efficient tracking and management.
+
+  - **Telecommunication Network Management**
+    Serialize configurations and states of network devices for efficient management and troubleshooting.
+
+  - **Travel Itinerary Planning**
+    Serialize travel plans and itineraries, allowing users to save and share their travel details easily.
+
+  - **Version Control of Design Files**
+    Serialize design artifacts for version control in graphic design and CAD applications.
+</details>
+
+> :rocket: **Ready to Dive In?**: All the code examples below can be tested on your local machine. Simply clone the repo and run `bin/console` to begin exploring. Don't forget to execute `bundle` first to ensure all dependencies are up to date. Happy coding!
 
 ## Supported Data Types
 
@@ -93,7 +201,6 @@ Universal ID supports most Ruby primitives.
 - `FalseClass`
 - `Float`
 - `Integer`
-- `NilClass`
 - `Range`
 - `Rational`
 - `Regexp`
@@ -216,56 +323,7 @@ Composite support is where things start to get interesting. All of the composite
   ```
 </details>
 
-### ActiveRecord
-
-> :information_source: **Broad Compatibility**: Universal ID has built-in support for ActiveRecord, yet it maintains independence from Rails-specific dependencies. This versatile design enables integration into **any Ruby project**.
-
-#### Why Universal ID with ActiveRecord?
-
-While ActiveRecord already supports GlobalID, a robust library for serializing individual ActiveRecord models, Universal ID extends this functionality to cover a wider range of use cases. Here are a few reasons you may want to consider Universal ID.
-
-- **Support for New Records**: Unlike GlobalID, Universal ID can serialize models that haven't been saved to the database yet
-- **Capturing Unsaved Changes**: It can serialize ActiveRecord models with unsaved changes, ensuring that even transient states are captured
-- **Association Handling**: Universal ID goes beyond single models. It can serialize associated records, including those with unsaved changes, creating a comprehensive snapshot of complex object states
-- **Cloning Existing Records**: Need to make a copy of a record, including its associations? Universal ID handles this effortlessly, making it ideal for duplicating complex datasets
-- **Granular Data Control**: With Universal ID, you gain explicit control over the serialization process. You can precisely choose which columns to include or exclude, allowing for tailored, optimized payloads that fit your specific needs
-- **Efficient Query Serialization**: Universal ID extends its capabilities to ActiveRecord relations, enabling the serialization of complex queries and scopes. This feature allows for seamless sharing of query logic between processes, ensuring consistency and reducing redundancy in data handling tasks.
-
-In summary, while GlobalID excels in its specific use case, Universal ID offers extended capabilities, particularly useful in scenarios involving unsaved records, complex associations, and data cloning.
-
-<details>
-  <summary><b>How to Convert Records to UIDs</b>... ▾</summary>
-  <p></p>
-
-  ```ruby
-  ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
-
-  ActiveRecord::Schema.define do
-    create_table :campaigns do |t|
-      t.column :name, :string
-      t.timestamps
-    end
-  end
-
-  class Campaign < ApplicationRecord
-  end
-
-  # ---
-
-  campaign = Campaign.create(name: "Marketing Campaign")
-
-  uri = URI::UID.build(campaign).to_s
-  #=> "uid://universal-id/CwiAxw4EqENhbXBhaWdugaJpZAMD"
-
-  uid = URI::UID.parse(uri)
-  #=> #<URI::UID uid://universal-id/CwiAxw4EqENhbXBhaWdugaJpZAMD>
-
-  URI::UID.parse(uri).decode
-  ##<Campaign:0x000000011cc67da8 id: 1, name: "Marketing Campaign", ...>
-  ```
-</details>
-
-### Custom Datatypes
+### Custom Types
 
 Universal ID is **extensible** so you can register your own datatypes with specialized serialization rules.
 It couldn't be simpler. Just convert the required data to a Ruby scalar or composite value.
@@ -316,6 +374,104 @@ It couldn't be simpler. Just convert the required data to a Ruby scalar or compo
   ```
 </details>
 
+### Contributed Types
+
+Universal ID is designed to be highly extensible, allowing for third-party contributions to enhance its capabilities.
+These contributions can introduce support for additional data types, further broadening the scope of Universal ID’s utility.
+The following are some notable contrib extensions:
+
+- **ActiveRecord::Base**:
+  Integrates Universal ID with ActiveRecord base models, enabling intelligent serialization of database records.
+
+- **ActiveRecord::Relation**:
+  Supports the serialization of ActiveRecord relations, making it possible to encode complex query structures.
+
+- **ActiveSupport::TimeWithZone**:
+  Adds the ability to serialize ActiveSupport's TimeWithZone objects.
+
+- **GlobalID**:
+  Extends support to include GlobalIDs.
+
+- **SignedGlobalID**:
+  Extends support to include SignedGlobalIDs.
+
+**Requiring Contributed Types**
+
+To utilize the contributed types, you must explicitly require them in your application.
+This ensures the extensions are loaded and available for use.
+Here is an example illustrating how to include contributed types:
+
+```ruby
+# load contrib types
+require "universal_id/contrib/active_record"
+require "universal_id/contrib/active_support"
+require "universal_id/contrib/global_id"
+require "universal_id/contrib/signed_global_id"
+
+# or simply
+require "universal_id/contrib/rails"
+```
+
+> :bulb: **Implicit Contribs**: Whenever the `Rails` constant is defined, the related contribs are auto-loaded.
+
+> :bulb: **Broad Compatibility**: Universal ID has built-in support for ActiveRecord, yet it maintains independence from Rails-specific dependencies. This versatile design enables integration into **any Ruby project**.
+
+**Why Universal ID with ActiveRecord?**
+
+While ActiveRecord already supports GlobalID, a robust library for serializing individual ActiveRecord models, Universal ID extends this functionality to cover a wider range of use cases. Here are a few reasons you may want to consider Universal ID.
+
+- **Support for New Records**:
+  Unlike GlobalID, Universal ID can serialize models that haven't been saved to the database yet.
+
+- **Capturing Unsaved Changes**:
+  It can serialize ActiveRecord models with unsaved changes, ensuring that even transient states are captured.
+
+- **Association Handling**:
+  Universal ID goes beyond single models. It can serialize associated records, including those with unsaved changes, creating a comprehensive snapshot of complex object states.
+
+- **Cloning Existing Records**:
+  Need to make a copy of a record, including its associations? Universal ID handles this effortlessly, making it ideal for duplicating complex datasets.
+
+- **Granular Data Control**:
+  With Universal ID, you gain explicit control over the serialization process. You can precisely choose which columns to include or exclude, allowing for tailored, optimized payloads that fit your specific needs.
+
+- **Efficient Query Serialization**:
+  Universal ID extends its capabilities to ActiveRecord relations, enabling the serialization of complex queries and scopes. This feature allows for seamless sharing of query logic between processes, ensuring consistency and reducing redundancy in data handling tasks.
+
+In summary, while GlobalID excels in its specific use case, Universal ID offers extended capabilities, particularly useful in scenarios involving unsaved records, complex associations, and data cloning.
+
+<details>
+  <summary><b>How to Convert Records to UIDs</b>... ▾</summary>
+  <p></p>
+
+  ```ruby
+  ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
+
+  ActiveRecord::Schema.define do
+    create_table :campaigns do |t|
+      t.column :name, :string
+      t.timestamps
+    end
+  end
+
+  class Campaign < ApplicationRecord
+  end
+
+  # ---
+
+  campaign = Campaign.create(name: "Marketing Campaign")
+
+  uri = URI::UID.build(campaign).to_s
+  #=> "uid://universal-id/CwiAxw4EqENhbXBhaWdugaJpZAMD"
+
+  uid = URI::UID.parse(uri)
+  #=> #<URI::UID uid://universal-id/CwiAxw4EqENhbXBhaWdugaJpZAMD>
+
+  URI::UID.parse(uri).decode
+  ##<Campaign:0x000000011cc67da8 id: 1, name: "Marketing Campaign", ...>
+  ```
+</details>
+
 ## Settings and Prepack Options
 
 Universal ID supports a small but powerful set of configuration options for transforming objects before being
@@ -446,7 +602,7 @@ It's also possible to register frequently used options as reusable settings to f
   ```
 
   ```ruby
-  UniversalID::Settings.register :unsaved, YAML.safe_load("app/config/unsaved.yml")
+  UniversalID::Settings.register :unsaved, File.expand_path("app/config/unsaved.yml", __dir__)
   URI::UID.build @record, UniversalID::Settings[:small_record]
   ```
 </details>
@@ -828,6 +984,74 @@ simply convert your UniversalID to a SignedGlobalID to add these features to any
   ```
 </details>
 
+## Fingerprinting (Implicit Versioning)
+
+Fingerprinting adds an extra layer of intelligence to the serialization process.
+UIDs automatically include a "fingerprint" for each serialized object based on the target object's class and
+its modification time _(mtime)_.
+
+Fingerprints are comprised of the following components:
+
+1. `Class (Class)`  - The encoded object's class
+2. `Timestamp (Time)` - The mtime (UTC) of the file that defined the object's class
+
+> :bulb: **Modification Timestamp**: The `mtime` is detected and captured the moment a UID is created.
+
+Fingerprints allow developers to manage different versions of serialized data effectively...**without the need for custom versioning**.
+Whenever the class definition changes, the mtime updates, resulting in a different fingerprint.
+This is especially useful in scenarios where the data format evolves over time, such as in long-lived applications.
+
+<details>
+  <summary><b>How to Use Fingerprinting</b>... ▾</summary>
+  <p></p>
+
+  1. Build a UID using a custom handler _(optional Ruby block)_. This allows you to take control of the encoding process.
+
+  ```ruby
+  # NOTE: The campaign model instance was setup earlier in the "Model Instances" section above
+  campaign.save!
+
+  #           the uid build target (campaign in this case)
+  #                                    |
+  #                                    |  encoding options (whatever was passed to URI::UID.build or {})
+  #                                    |        |
+  uid = URI::UID.build(campaign) do |record, options|
+    data = { id: record.id, demo: true }
+    URI::UID.encode data, options.merge(include: %w[id demo]) # block returns the encoded payload
+  end
+  ```
+
+  2. Decode the UID using a custom handler _(optional Ruby block)_. This allows you to take control of the decoding process.
+
+  ```ruby
+  #                                              fingerprint components
+  #                                                     ____|______
+  #                     the decoded payload from above  |         |
+  #                                              |      |         |
+  decoded = URI::UID.parse(uid.to_s).decode do |data, klass, timestamp|
+    record = klass.find_by(id: data[:id])
+    record.instance_variable_set(:@demo, data[:demo])
+
+    case Time.parse(timestamp)
+    when 3.months.ago..Time.now
+      # current data format
+      # return the record as-is
+      record
+    when 1.year.ago..3.months.ago
+      # outdated data format
+      # apply an ETL process to bring the outdated data current
+      # then return the modified record
+      record
+    end
+  end
+  ```
+</details>
+
+Fingerprinting allows for seamless handling of different data versions and formats,
+so you can maintain consistency and reliability in applications dealing with serialized data over time.
+
+> :bulb: **Optional Usage**: While fingerpint creation is automatic and implicit, using it is optional... ready whenever you want more control.
+
 ## Performance and Benchmarks
 
 <details>

data/{contrib → lib/universal_id/contrib}/active_record/base_unpacker.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 class UniversalID::Contrib::ActiveRecordBaseUnpacker
-  using UniversalID::Refinements::KernelRefinement
-
   class << self
     def unpack_with(unpacker)
       class_name = unpacker.read
@@ -13,7 +11,7 @@ class UniversalID::Contrib::ActiveRecordBaseUnpacker
     private
 
     def create_instance(class_name, attributes)
-      klass = const_find(class_name)
+      klass = Object.const_get(class_name) if Object.const_defined?(class_name)
       return nil unless klass
 
       record = if attributes[klass.primary_key]

data/lib/universal_id/contrib/active_record.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "active_record/base_message_pack_type"
+require_relative "active_record/relation_message_pack_type"

data/lib/universal_id/contrib/active_support.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "active_support/time_with_zone_message_pack_type"

data/{contrib → lib/universal_id/contrib}/global_id/global_id_model.rb

@@ -15,7 +15,7 @@ class UniversalID::Contrib::GlobalIDModel
     when String
       case universal_id
       when /\A#{URI::UID::SCHEME}/o then URI::UID.parse(universal_id)
-      else URI::UID.parse(URI::UID.build_string(universal_id))
+      else URI::UID.parse(URI::UID.build_string(universal_id, self))
       end
     end
 

data/lib/universal_id/contrib/global_id.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "global_id/message_pack_type"

data/lib/universal_id/contrib/rails.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative "active_record" if defined? ActiveRecord
+require_relative "active_support" if defined? ActiveSupport
+require_relative "global_id" if defined? GlobalID
+require_relative "signed_global_id" if defined? SignedGlobalID

data/lib/universal_id/contrib/signed_global_id.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "signed_global_id/message_pack_type"

data/lib/universal_id/message_pack_factory.rb

@@ -11,16 +11,30 @@ UniversalID::MessagePackFactory = MessagePack::Factory.new.tap do |factory|
       @msgpack_pool = UniversalID::MessagePackFactory.pool([Etc.nprocessors.to_i, 1].max)
     end
 
-    def register(type:, type_id: nil, recreate_pool: true, **options)
-      id = type_id || next_type_id
+    def register_scalar(type:, recreate_pool: true, **options)
+      register id: next_type_id(order: :asc), type: type, **options
+    end
+
+    def register(type:, id: nil, recreate_pool: true, **options)
       options[:recursive] = true unless options.key?(:recursive)
-      register_type(id, type, options)
+      register_type(id || next_type_id(order: :desc), type, options)
       create_msgpack_pool if recreate_pool
     end
 
-    def next_type_id
-      max_type_id = registered_types.map { |type| type[:type].to_i }.max
-      max_type_id.nil? ? 0 : max_type_id + 1
+    def next_type_id(order:)
+      range = 0..127
+
+      case order
+      when :asc
+        id = range.first
+        id += 1 while type_registered?(id)
+      when :desc
+        id = range.last
+        id -= 1 while type_registered?(id)
+      end
+
+      id = nil unless range.cover?(id)
+      id
     end
   end
 end

data/lib/universal_id/message_pack_types/ruby/composites/module.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+UniversalID::MessagePackFactory.register(
+  type: Module,
+  recreate_pool: false,
+  packer: ->(obj, packer) { packer.write obj.name },
+  unpacker: ->(unpacker) do
+    name = unpacker.read
+    Object.const_defined?(name) ? Object.const_get(name) : nil
+  end
+)

data/lib/universal_id/message_pack_types/ruby/composites/struct.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-using UniversalID::Refinements::KernelRefinement
-
 UniversalID::MessagePackFactory.register(
   type: Struct,
   recreate_pool: false,
@@ -13,11 +11,13 @@ UniversalID::MessagePackFactory.register(
   unpacker: ->(unpacker) do
     class_name = unpacker.read
     hash = unpacker.read
-    klass = const_find(class_name)
+    klass = Object.const_get(class_name) if Object.const_defined?(class_name)
 
-    # shenanigans to support ::Ruby 3.0.X and 3.1.X
-    RUBY_VERSION.start_with?("3.0", "3.1") ?
-      klass.new.tap { |struct| hash.each { |key, val| struct[key] = hash[key] } } :
-      klass.new(**hash)
+    if klass
+      # shenanigans to support ::Ruby 3.0.X and 3.1.X
+      RUBY_VERSION.start_with?("3.0", "3.1") ?
+        klass.new.tap { |struct| hash.each { |key, val| struct[key] = hash[key] } } :
+        klass.new(**hash)
+    end
   end
 )

data/lib/universal_id/message_pack_types/ruby/scalars/complex.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-UniversalID::MessagePackFactory.register(
+UniversalID::MessagePackFactory.register_scalar(
   type: Complex,
   recreate_pool: false,
   packer: ->(obj, packer) { packer.write obj.to_s },

data/lib/universal_id/message_pack_types/ruby/scalars/date.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-UniversalID::MessagePackFactory.register(
+UniversalID::MessagePackFactory.register_scalar(
   type: Date,
   recreate_pool: false,
   packer: ->(obj, packer) { packer.write obj.iso8601 },

data/lib/universal_id/message_pack_types/ruby/scalars/date_time.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-UniversalID::MessagePackFactory.register(
+UniversalID::MessagePackFactory.register_scalar(
   type: DateTime,
   recreate_pool: false,
   packer: ->(obj, packer) { packer.write obj.iso8601(9) },

data/lib/universal_id/message_pack_types/ruby/scalars/range.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-UniversalID::MessagePackFactory.register(
+UniversalID::MessagePackFactory.register_scalar(
   type: Range,
   recreate_pool: false,
   packer: ->(obj, packer) do

data/lib/universal_id/message_pack_types/ruby/scalars/rational.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-UniversalID::MessagePackFactory.register(
+UniversalID::MessagePackFactory.register_scalar(
   type: Rational,
   recreate_pool: false,
   packer: ->(obj, packer) { packer.write obj.to_s },

data/lib/universal_id/message_pack_types/ruby/scalars/regexp.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-UniversalID::MessagePackFactory.register(
+UniversalID::MessagePackFactory.register_scalar(
   type: Regexp,
   recreate_pool: false,
   packer: ->(obj, packer) do

data/lib/universal_id/message_pack_types.rb

@@ -1,26 +1,25 @@
 # frozen_string_literal: true
 
-# A list of all MessagePack types in the preferred registration order
-#
-# IMPORTANT: More specific types should be registered before more general types
-#            because MessagePack will use the first registered type that matches
-#            MessagePack scans registered type in linear order and first match wins
+# NOTE: MessagePack scans registered type in linear order and first match wins
 
-require_relative "contrib"
+# scalars
+require_relative "message_pack_types/ruby/scalars/complex"
+require_relative "message_pack_types/ruby/scalars/rational"
+require_relative "message_pack_types/ruby/scalars/date_time"
+require_relative "message_pack_types/ruby/scalars/date"
+require_relative "message_pack_types/ruby/scalars/range"
+require_relative "message_pack_types/ruby/scalars/regexp"
 
-paths = %w[
-  message_pack_types/uri/uid/type.rb
-  message_pack_types/ruby/composites/set.rb
-  message_pack_types/ruby/composites/open_struct.rb
-  message_pack_types/ruby/composites/struct.rb
-  message_pack_types/ruby/scalars/complex.rb
-  message_pack_types/ruby/scalars/rational.rb
-  message_pack_types/ruby/scalars/date_time.rb
-  message_pack_types/ruby/scalars/date.rb
-  message_pack_types/ruby/scalars/range.rb
-  message_pack_types/ruby/scalars/regexp.rb
-]
+# composites
+require_relative "message_pack_types/ruby/composites/module"
+require_relative "message_pack_types/ruby/composites/open_struct"
+require_relative "message_pack_types/ruby/composites/struct"
+require_relative "message_pack_types/ruby/composites/set"
 
-paths.each { |path| require_relative path }
+# uid
+require_relative "message_pack_types/uri/uid/type"
+
+# contribs
+require_relative "contrib/rails" if defined? Rails
 
 UniversalID::MessagePackFactory.create_msgpack_pool

data/lib/universal_id/prepacker.rb

@@ -1,9 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "refinements"
-
 class UniversalID::Prepacker
-  using UniversalID::Refinements::KernelRefinement
   using UniversalID::Refinements::ArrayRefinement
   using UniversalID::Refinements::HashRefinement
   using UniversalID::Refinements::SetRefinement

data/lib/universal_id/refinements.rb

@@ -2,7 +2,6 @@
 
 module UniversalID::Refinements; end
 
-require_relative "refinements/kernel_refinement"
 require_relative "refinements/array_refinement"
 require_relative "refinements/hash_refinement"
 require_relative "refinements/set_refinement"

data/lib/universal_id/version.rb

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

data/lib/universal_id.rb

@@ -6,6 +6,7 @@ require "ostruct"
 require "uri"
 
 require_relative "universal_id/version"
+require_relative "universal_id/refinements"
 require_relative "universal_id/settings"
 require_relative "universal_id/encoder"
 require_relative "uri/uid"
@@ -16,6 +17,8 @@ require_relative "universal_id/message_pack_factory"
 UniversalID::Settings.instance # initialize settings
 
 module UniversalID
+  module Contrib; end
+
   class << self
     attr_writer :logger
 

data/lib/uri/uid.rb

@@ -4,24 +4,40 @@ unless defined?(::URI::UID) || ::URI.scheme_list.include?("UID")
 
   module URI
     class UID < ::URI::Generic
-      extend Forwardable
-
+      VERSION = UniversalID::VERSION
       SCHEME = "uid"
       HOST = "universal-id"
 
       class << self
+        def encoder
+          UniversalID::Encoder
+        end
+
+        def fingerprint(object)
+          encode fingerprint_components(object)
+        end
+
         def parse(value)
           components = ::URI.split(value.to_s)
           new(*components)
         end
 
-        def build_string(payload)
-          "#{SCHEME}://#{HOST}/#{payload}"
+        def build_string(payload, object = nil)
+          "#{SCHEME}://#{HOST}/#{payload}##{fingerprint(object)}"
         end
 
-        def build(object, options = {})
-          path = "/#{UniversalID::Encoder.encode(object, options)}"
-          parse "#{SCHEME}://#{HOST}#{path}"
+        def build(object, options = {}, &block)
+          path = "/#{encode(object, options, &block)}"
+          parse "#{SCHEME}://#{HOST}#{path}##{fingerprint(object)}"
+        end
+
+        def encode(object, options = {})
+          return yield(object, options) if block_given?
+          encoder.encode object, options
+        end
+
+        def decode(...)
+          encoder.decode(...)
         end
 
         # Creates a new URI::UID with the given URI components.
@@ -53,15 +69,33 @@ unless defined?(::URI::UID) || ::URI.scheme_list.include?("UID")
             end
           end
         end
+
+        private
+
+        def fingerprint_components(object)
+          klass = object.is_a?(Class) ? object : object.class
+          tokens = [klass]
+
+          begin
+            path = const_source_location(klass.name).first.to_s
+            tokens << ::File.mtime(path).utc if ::File.exist?(path)
+          rescue => e
+            UniversalID.logger&.warn "URI::UID#fingerprint: Unable to determine the source location for #{klass.name}!\n#{e.message}}"
+          end
+
+          tokens
+        end
       end
 
+      alias_method :fingerprint, :fragment
+
       def payload(truncate: false)
         (truncate && path.length > 80) ? "#{path[1..77]}..." : path[1..]
       end
 
       def valid?
         case self
-        in scheme: SCHEME, host: HOST, path: p if p.size >= 8 then return true
+        in scheme: SCHEME, host: HOST, path: p, fragment: _ if p.size >= 8 then return true
         else false
         end
       end
@@ -71,16 +105,29 @@ unless defined?(::URI::UID) || ::URI.scheme_list.include?("UID")
       end
 
       def decode
-        UniversalID::Encoder.decode(payload) if valid?
+        return nil unless valid?
+        return yield(decode_payload, *decode_fingerprint) if block_given?
+
+        decode_payload
       end
 
       def deconstruct_keys(_keys)
-        {scheme: scheme, host: host, path: path}
+        {scheme: scheme, host: host, path: path, fragment: fragment}
       end
 
       def inspect
         "#<URI::UID scheme=#{scheme}, host=#{host}, payload=#{payload truncate: true}>"
       end
+
+      private
+
+      def decode_payload
+        self.class.decode payload
+      end
+
+      def decode_fingerprint
+        self.class.decode fingerprint
+      end
     end
 
     # Register the URI scheme

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: universalid
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Nate Hopkins (hopsoft)
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-13 00:00:00.000000000 Z
+date: 2023-11-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: brotli
@@ -263,25 +263,25 @@ files:
 - Rakefile
 - config/default.yml
 - config/example.yml
-- contrib/active_record.rb
-- contrib/active_record/base_message_pack_type.rb
-- contrib/active_record/base_packer.rb
-- contrib/active_record/base_unpacker.rb
-- contrib/active_record/relation_message_pack_type.rb
-- contrib/active_support.rb
-- contrib/active_support/time_with_zone_message_pack_type.rb
-- contrib/global_id.rb
-- contrib/global_id/global_id_model.rb
-- contrib/global_id/global_id_uid_extension.rb
-- contrib/global_id/message_pack_type.rb
-- contrib/signed_global_id.rb
-- contrib/signed_global_id/message_pack_type.rb
-- contrib/tags
 - lib/universal_id.rb
-- lib/universal_id/contrib.rb
+- lib/universal_id/contrib/active_record.rb
+- lib/universal_id/contrib/active_record/base_message_pack_type.rb
+- lib/universal_id/contrib/active_record/base_packer.rb
+- lib/universal_id/contrib/active_record/base_unpacker.rb
+- lib/universal_id/contrib/active_record/relation_message_pack_type.rb
+- lib/universal_id/contrib/active_support.rb
+- lib/universal_id/contrib/active_support/time_with_zone_message_pack_type.rb
+- lib/universal_id/contrib/global_id.rb
+- lib/universal_id/contrib/global_id/global_id_model.rb
+- lib/universal_id/contrib/global_id/global_id_uid_extension.rb
+- lib/universal_id/contrib/global_id/message_pack_type.rb
+- lib/universal_id/contrib/rails.rb
+- lib/universal_id/contrib/signed_global_id.rb
+- lib/universal_id/contrib/signed_global_id/message_pack_type.rb
 - lib/universal_id/encoder.rb
 - lib/universal_id/message_pack_factory.rb
 - lib/universal_id/message_pack_types.rb
+- lib/universal_id/message_pack_types/ruby/composites/module.rb
 - lib/universal_id/message_pack_types/ruby/composites/open_struct.rb
 - lib/universal_id/message_pack_types/ruby/composites/set.rb
 - lib/universal_id/message_pack_types/ruby/composites/struct.rb
@@ -298,7 +298,6 @@ files:
 - lib/universal_id/refinements.rb
 - lib/universal_id/refinements/array_refinement.rb
 - lib/universal_id/refinements/hash_refinement.rb
-- lib/universal_id/refinements/kernel_refinement.rb
 - lib/universal_id/refinements/open_struct_refinement.rb
 - lib/universal_id/refinements/set_refinement.rb
 - lib/universal_id/settings.rb
@@ -327,7 +326,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.32
+rubygems_version: 3.4.15
 signing_key:
 specification_version: 4
 summary: URL-Safe String Serialization for any Ruby Object

data/contrib/active_record.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-if defined?(ActiveRecord) && defined?(ActiveRecord::Base) && defined?(ActiveRecord::Relation)
-
-  require_relative "active_record/base_message_pack_type"
-  require_relative "active_record/relation_message_pack_type"
-
-end

data/contrib/active_support.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-if defined?(ActiveSupport) && defined?(ActiveSupport::TimeWithZone)
-
-  require_relative "active_support/time_with_zone_message_pack_type"
-
-end

data/contrib/global_id.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-if defined?(GlobalID) && defined?(GlobalID::Identification)
-
-  require_relative "global_id/message_pack_type"
-
-end

data/contrib/signed_global_id.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-if defined? SignedGlobalID
-
-  require_relative "signed_global_id/message_pack_type"
-
-end

data/contrib/tags

@@ -1,75 +0,0 @@
-!_TAG_EXTRA_DESCRIPTION	anonymous	/Include tags for non-named objects like lambda/
-!_TAG_EXTRA_DESCRIPTION	fileScope	/Include tags of file scope/
-!_TAG_EXTRA_DESCRIPTION	pseudo	/Include pseudo tags/
-!_TAG_EXTRA_DESCRIPTION	subparser	/Include tags generated by subparsers/
-!_TAG_FIELD_DESCRIPTION	epoch	/the last modified time of the input file (only for F\/file kind tag)/
-!_TAG_FIELD_DESCRIPTION	file	/File-restricted scoping/
-!_TAG_FIELD_DESCRIPTION	input	/input file/
-!_TAG_FIELD_DESCRIPTION	name	/tag name/
-!_TAG_FIELD_DESCRIPTION	pattern	/pattern/
-!_TAG_FIELD_DESCRIPTION	typeref	/Type and name of a variable or typedef/
-!_TAG_FIELD_DESCRIPTION!Ruby	mixin	/how the class or module is mixed in (mixin:HOW:MODULE)/
-!_TAG_FILE_FORMAT	2	/extended format; --format=1 will not append ;" to lines/
-!_TAG_FILE_SORTED	1	/0=unsorted, 1=sorted, 2=foldcase/
-!_TAG_KIND_DESCRIPTION!Ruby	A,accessor	/accessors/
-!_TAG_KIND_DESCRIPTION!Ruby	C,constant	/constants/
-!_TAG_KIND_DESCRIPTION!Ruby	L,library	/libraries/
-!_TAG_KIND_DESCRIPTION!Ruby	S,singletonMethod	/singleton methods/
-!_TAG_KIND_DESCRIPTION!Ruby	a,alias	/aliases/
-!_TAG_KIND_DESCRIPTION!Ruby	c,class	/classes/
-!_TAG_KIND_DESCRIPTION!Ruby	f,method	/methods/
-!_TAG_KIND_DESCRIPTION!Ruby	m,module	/modules/
-!_TAG_OUTPUT_EXCMD	mixed	/number, pattern, mixed, or combineV2/
-!_TAG_OUTPUT_FILESEP	slash	/slash or backslash/
-!_TAG_OUTPUT_MODE	u-ctags	/u-ctags or e-ctags/
-!_TAG_OUTPUT_VERSION	0.0	/current.age/
-!_TAG_PARSER_VERSION!Ruby	0.0	/current.age/
-!_TAG_PATTERN_LENGTH_LIMIT	96	/0 for no limit/
-!_TAG_PROC_CWD	/Users/nathan/work/hopsoft/universalid/contrib/	//
-!_TAG_PROGRAM_AUTHOR	Universal Ctags Team	//
-!_TAG_PROGRAM_NAME	Universal Ctags	/Derived from Exuberant Ctags/
-!_TAG_PROGRAM_URL	https://ctags.io/	/official site/
-!_TAG_PROGRAM_VERSION	6.0.0	//
-!_TAG_ROLE_DESCRIPTION!Ruby!library	loaded	/loaded by "load" method/
-!_TAG_ROLE_DESCRIPTION!Ruby!library	required	/loaded by "require" method/
-!_TAG_ROLE_DESCRIPTION!Ruby!library	requiredRel	/loaded by "require_relative" method/
-ActiveRecordPacker	active_record/active_record_packer.rb	/^class UniversalID::Contrib::ActiveRecordPacker$/;"	c	module:UniversalID.Contrib
-ActiveRecordUnpacker	active_record/active_record_unpacker.rb	/^class UniversalID::Contrib::ActiveRecordUnpacker$/;"	c	module:UniversalID.Contrib
-ClassMethods	global_id/global_id_uid_extension.rb	/^  module ClassMethods$/;"	m	module:GlobalIDUIDExtension
-DESCENDANTS_KEY	active_record/active_record_packer.rb	/^  DESCENDANTS_KEY = "uid:descendants"$/;"	C	class:ActiveRecordPacker
-GlobalID	global_id/message_pack_type.rb	/^module UniversalID::Contrib::GlobalID; end$/;"	m	module:UniversalID.Contrib
-GlobalIDModel	global_id/global_id_model.rb	/^class UniversalID::Contrib::GlobalIDModel$/;"	c	module:UniversalID.Contrib	mixin:include:GlobalID.Identification
-GlobalIDUIDExtension	global_id/global_id_uid_extension.rb	/^module UniversalID::Contrib::GlobalIDUIDExtension$/;"	m	module:UniversalID.Contrib	mixin:extend:Forwardable
-HAS_MANY_ASSOCIATIONS	active_record/active_record_packer.rb	/^  HAS_MANY_ASSOCIATIONS = [$/;"	C	class:ActiveRecordPacker
-add_descendants!	active_record/active_record_packer.rb	/^  def add_descendants!(hash)$/;"	f	class:ActiveRecordPacker
-assign_attributes	active_record/active_record_unpacker.rb	/^    def assign_attributes(record, attributes)$/;"	S	class:ActiveRecordUnpacker
-assign_descendants	active_record/active_record_unpacker.rb	/^    def assign_descendants(record, attributes)$/;"	S	class:ActiveRecordUnpacker
-associations	active_record/active_record_packer.rb	/^  def associations$/;"	f	class:ActiveRecordPacker
-create_instance	active_record/active_record_unpacker.rb	/^    def create_instance(class_name, attributes)$/;"	S	class:ActiveRecordUnpacker
-find	global_id/global_id_model.rb	/^  def self.find(value)$/;"	S	class:GlobalIDModel
-foreign_key_column_names	active_record/active_record_packer.rb	/^  def foreign_key_column_names$/;"	f	class:ActiveRecordPacker
-from_gid	global_id/global_id_uid_extension.rb	/^    alias_method :from_gid, :from_global_id$/;"	a	module:GlobalIDUIDExtension.ClassMethods
-from_global_id	global_id/global_id_uid_extension.rb	/^    def from_global_id(gid, options = {})$/;"	f	module:GlobalIDUIDExtension.ClassMethods
-from_global_id_record	global_id/global_id_uid_extension.rb	/^    def from_global_id_record(gid_record)$/;"	f	module:GlobalIDUIDExtension.ClassMethods
-from_sgid	global_id/global_id_uid_extension.rb	/^    alias_method :from_sgid, :from_signed_global_id$/;"	a	module:GlobalIDUIDExtension.ClassMethods
-from_signed_global_id	global_id/global_id_uid_extension.rb	/^    def from_signed_global_id(sgid, options = {})$/;"	f	module:GlobalIDUIDExtension.ClassMethods
-has_many_associations	active_record/active_record_packer.rb	/^  def has_many_associations$/;"	f	class:ActiveRecordPacker
-id	global_id/global_id_model.rb	/^  attr_reader :id, :uid$/;"	A	class:GlobalIDModel
-id_only?	active_record/active_record_packer.rb	/^  def id_only?(prepack_database_options)$/;"	f	class:ActiveRecordPacker
-include_descendants?	active_record/active_record_packer.rb	/^  def include_descendants?$/;"	f	class:ActiveRecordPacker
-included	global_id/global_id_uid_extension.rb	/^  def self.included(mixer)$/;"	S	module:GlobalIDUIDExtension
-initialize	active_record/active_record_packer.rb	/^  def initialize(record)$/;"	f	class:ActiveRecordPacker
-initialize	global_id/global_id_model.rb	/^  def initialize(universal_id)$/;"	f	class:GlobalIDModel
-loaded_has_many_relations_by_name	active_record/active_record_packer.rb	/^  def loaded_has_many_relations_by_name$/;"	f	class:ActiveRecordPacker
-pack_with	active_record/active_record_packer.rb	/^  def pack_with(packer)$/;"	f	class:ActiveRecordPacker
-packable_attributes	active_record/active_record_packer.rb	/^  def packable_attributes$/;"	f	class:ActiveRecordPacker
-prepack_database_options	active_record/active_record_packer.rb	/^  def prepack_database_options$/;"	f	class:ActiveRecordPacker
-prepack_options	active_record/active_record_packer.rb	/^  def prepack_options$/;"	f	class:ActiveRecordPacker
-record	active_record/active_record_packer.rb	/^  attr_reader :record$/;"	A	class:ActiveRecordPacker
-reject_keys!	active_record/active_record_packer.rb	/^  def reject_keys!(hash)$/;"	f	class:ActiveRecordPacker
-reject_timestamps!	active_record/active_record_packer.rb	/^  def reject_timestamps!(hash)$/;"	f	class:ActiveRecordPacker
-reject_unsaved_changes!	active_record/active_record_packer.rb	/^  def reject_unsaved_changes!(hash)$/;"	f	class:ActiveRecordPacker
-timestamp_column_names	active_record/active_record_packer.rb	/^  def timestamp_column_names$/;"	f	class:ActiveRecordPacker
-to_global_id_model	global_id/global_id_uid_extension.rb	/^  def to_global_id_model$/;"	f	module:GlobalIDUIDExtension
-uid	global_id/global_id_model.rb	/^  attr_reader :id, :uid$/;"	A	class:GlobalIDModel
-unpack_with	active_record/active_record_unpacker.rb	/^    def unpack_with(unpacker)$/;"	S	class:ActiveRecordUnpacker

data/lib/universal_id/contrib.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module UniversalID::Contrib; end
-
-# A list of all MessagePack types in the preferred registration order
-#
-# IMPORTANT: More specific types should be registered before more general types
-#            because MessagePack will use the first registered type that matches
-#            MessagePack scans registered type in linear order and first match wins
-
-require_relative "../../contrib/signed_global_id"
-require_relative "../../contrib/global_id"
-require_relative "../../contrib/active_support"
-require_relative "../../contrib/active_record"

data/lib/universal_id/refinements/kernel_refinement.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module UniversalID::Refinements::KernelRefinement
-  refine Kernel do
-    # Finds a constant by name, starting at the root namespace (i.e. ::Object)
-    def const_find(name)
-      return nil unless name.is_a?(String)
-      names = name.split("::")
-      constant = Object
-
-      while names.any?
-        value = names.shift
-        constant = constant.const_get(value) if constant.const_defined?(value)
-      end
-
-      (constant.name == name) ? constant : nil
-    end
-  end
-end