fast-uuid 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0a8b04df8089715f0156dc86feb6b73dd3abebea996b08c213e9b43844bfc9ce
+  data.tar.gz: a6e2cae4c744b1b238af21188dab84a6e2830e2108760db5e71c465a789205dd
+SHA512:
+  metadata.gz: a629ab2256ed2043b278d6953b67a96a057888c60a01bed3cd740f9690047be5dcfcec16d0e3f92ec47e91eef051cd24a48f9d3d4d2ee6758fa9c6efe0a05cf4
+  data.tar.gz: 4037526e2102bbcf3cfff76b8a2a700ebcfe29ceb85c0793e9fb3b7aac35600ae898c312fa7130c1f6e594e4920e033fef8e2744d18fef79a3c3c5b0d2a932ba

data/CHANGELOG.md

@@ -0,0 +1,18 @@
+# Changelog
+
+## 0.1.0
+
+- Initial release: `Fast::UUID`, one immutable, frozen value class. Generate
+  v4 (122 random bits from `SecureRandom`) and v7 (48-bit `unix_ts_ms` plus
+  74 fully random bits, no counter and no shared state, thread-safe), with
+  `generate` defaulting to v7. Parse and validate every RFC 9562 version and
+  variant — validity is the RFC 4 grammar and nothing more, case-insensitive,
+  Nil and Max included — with `parse`, `parse?` and `valid?`. `Fast::UUID.new`
+  builds from a 16-byte binary String.
+- Timestamps: v1 and v6 read their 60-bit 100-ns Gregorian timestamp, v7 its
+  `unix_ts_ms`; every other version reports nil. Comparison is opaque
+  unsigned 128-bit byte order, so v6 and v7 sort chronologically; v1 does
+  not, its `time_low` sits first, and the README carries the caveat.
+- `to_s`, `to_str`, `bytes`, `hex`, `urn`, `nil_uuid?`, `max_uuid?`,
+  `version`, `variant`, and `==`/`eql?`/`hash` over the 128-bit value alone.
+  Verified in-suite against all six RFC 9562 Appendix A test vectors.

data/README.md

@@ -0,0 +1,116 @@
+# fast-uuid
+
+> **Status:** _Alpha, pre-1.0_ The API surface may still move between v0.x and v1.0.
+
+A UUID library for Ruby that is fast, complete, and RFC 9562-compliant.
+
+Fast::UUID provides drop-in, api-compatible replacements for `SecureRandom`'s `.uuid_v4` and `.uuid_v7` that are as fast (within 2%) or faster while allocating half as many objects or fewer while using the same source of entropy.
+
+```ruby
+# before
+SecureRandom.uuid_v4   # => "cdbb6d1f-…"
+SecureRandom.uuid_v7   # => "01a12861-…"
+
+# after — the same calls, the same entropy, frozen, half the objects or fewer
+Fast::UUID.uuid_v4     # => "e74ce176-…"
+Fast::UUID.uuid_v7     # => "01a12861-…"
+```
+
+Fast::UUID can also return immutable `Fast::UUID` objects that are directly `Comparable`. These also allocate fewer objects than `SecureRandom`'s `.uuid_v4` and `.uuid_v7`.
+
+```ruby
+a = Fast::UUID.v7(time: Time.utc(2026, 10, 10))
+b = Fast::UUID.v7(time: Time.utc(2026, 10, 11))
+a < b                          # => true — v7 byte order is time order
+[a, b].max.timestamp           # => 2026-10-11 00:00:00 UTC
+Fast::UUID.parse(a.to_s) == a  # => true — identity is the 128-bit value alone
+```
+
+Fast::UUID's goal is to cover every UUID use-case a project could have in a way that is correct and of course, fast.
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "fast-uuid"
+```
+and `require "fast/uuid"`.
+
+Fast::UUID has no dependencies and is implemented in pure Ruby.
+
+## Quickstart
+
+```ruby
+require "fast/uuid"
+
+uuid = Fast::UUID.generate            # v7, the RFC's recommended default
+Fast::UUID.uuid_v4                    # => "b4c7b0f1-…", or uuid_v1 - uuid_v7. Returns a String just like SecureRandom
+Fast::UUID.parse(uuid.to_s) == uuid   # => true, from any conforming String, any case
+Fast::UUID.v4.version                 # => 4
+Fast::UUID.v7.timestamp               # => a UTC Time, the 48-bit unix_ts_ms
+Fast::UUID.v5(Fast::UUID::NAMESPACE_DNS, "www.example.com").to_s
+                                      # => "2ed6657d-e927-568b-95e1-2665a8aea6a2", same input, same UUID
+
+sorted = [Fast::UUID.v7, Fast::UUID.v7].sort  # v7 sorts chronologically, RFC 6.11
+```
+
+`Fast::UUID.parse` raises `Fast::UUID::ParseError` for anything the RFC
+4 grammar rejects and `TypeError` for an object with no `to_s`; `parse?`
+and `valid?` are the non-raising forms. Every version and variant
+parses, Nil and Max included.
+
+One caveat the RFC does not decide for you: opaque byte order makes v6 and
+v7 sort chronologically, but **v1 does not**. The
+[tutorial](docs/tutorials/generate-parse-and-sort-uuids.md) walks through the whole
+story: generate, parse, introspect, sort, and a request-ID module at the end
+of it.
+
+## Performance
+
+Measured on the six operations the gem and its references share — generation
+against `securerandom`, parsing against `uuidtools` (Ruby 4.0.7; conditions,
+the allocation columns and how to reproduce on the
+[benchmarks page](docs/explanation/benchmarks.md)):
+
+- Generation is **ahead of the stdlib String for v4, within 10% for v7** —
+  0.65M vs 0.64M i/s for v4, 0.58M vs 0.65M for v7, at half or fewer of the
+  objects — and the String forms win outright: `uuid_v4` 0.72M vs 0.64M with a
+  quarter of the objects, `uuid_v7` 0.64M vs 0.65M — parity — with two fifths.
+- Parsing is **2.7x faster than uuidtools with 4.5x fewer objects** — 1.14M vs
+  0.42M i/s, 6 objects per call against 27 — because it is a grammar check and
+  one `pack`, not a decoded field graph.
+
+## Documentation
+
+### Tutorials
+
+- [Tutorial: generate, parse and sort UUIDs](docs/tutorials/generate-parse-and-sort-uuids.md) — generate, parse, introspect and sort, ending in a sortable request ID.
+
+### How-to guides
+
+- [How to choose a UUID version](docs/how-to/choose-a-uuid-version.md) — v7 by default, v6 for a v1 fleet, v5 for name-derived determinism, v4 for randomness, v1 for legacy systems.
+- [How to generate deterministic UUIDs](docs/how-to/generate-deterministic-uuids.md) — pin a v7 to an exact millisecond with `v7(time:)`, pin a v1 or v6 to the 100-ns tick, or derive a stable v5 from a namespace and name.
+- [How to validate untrusted input](docs/how-to/validate-untrusted-input.md) — what `parse?` and `valid?` return, and what `parse` raises.
+- [How to sort UUIDs](docs/how-to/sort-uuids.md) — `<=>` byte order, and the v1 caveat.
+- [How to store a UUID as 16 bytes](docs/how-to/store-a-uuid-as-16-bytes.md) — `bytes` out, `new(bytes)` back.
+
+### Reference
+
+- [Reference: Fast::UUID](docs/reference/uuid.md) — every class method, instance method, constant and error.
+
+### Explanation
+
+- [What a UUID is, and what its versions are](docs/explanation/uuid-versions.md) — embedded time, natural sorting, name-derived determinism, and randomness as one option among five.
+- [Why validity is the grammar and nothing more](docs/explanation/validity.md) — why no version or variant gate: the RFC defines none, and Nil and Max sit outside the 10xx variant by design.
+- [In what order UUIDs sort](docs/explanation/comparison-order.md) — opaque bytes per RFC §6.11, v6/v7 chronological, v1 anti-chronological.
+- [Benchmarks](docs/explanation/benchmarks.md) — generation against securerandom, parsing against uuidtools, and how to reproduce them.
+
+## Development
+
+```bash
+bundle exec sus
+bundle exec rubocop
+bundle exec ruby benchmark/uuid.rb                 # full run, about a minute
+BENCH_QUICK=1 bundle exec ruby benchmark/uuid.rb   # quick run, seconds
+```

data/lib/fast/uuid/errors.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Fast
+  class UUID
+    class Error < StandardError; end
+
+    # A String that is not a UUID in the RFC 9562 canonical form.
+    class ParseError < Error; end
+  end
+end

data/lib/fast/uuid/uuid.rb

@@ -0,0 +1,375 @@
+# frozen_string_literal: true
+
+require "digest"
+require "securerandom"
+
+module Fast
+  # An immutable, frozen RFC 9562 UUID value: generate v4/v7, time-based
+  # v1/v6 and name-based v3/v5, parse and validate every version and
+  # variant, compare as an opaque 128-bit value.
+  class UUID
+    include Comparable
+
+    # The canonical form, 4hexOctet-2hexOctet-2hexOctet-2hexOctet-6hexOctet,
+    # case-insensitive. Validity is this grammar and nothing more: the RFC
+    # defines no version or variant gate, and Nil and Max sit outside the
+    # 10xx variant by design.
+    CANONICAL = /\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i
+
+    # 100-ns ticks between the Gregorian (1582-10-15) and Unix epoch baselines.
+    GREGORIAN_OFFSET = 122_192_928_000_000_000
+
+    # 128 random bits from the CSPRNG, version and variant stamped into
+    # place: 122 stay random, version 4 fills one nibble and the 10xx
+    # variant the top two bits.
+    def self.v4
+      new(v4_bytes)
+    end
+
+    # The same 128 random bits as .v4, rendered straight to the canonical
+    # form — drop-in for SecureRandom.uuid_v4, the value object skipped.
+    def self.uuid_v4
+      canonical(v4_bytes)
+    end
+
+    # The time is truncated to whole milliseconds for the 48-bit unix_ts_ms;
+    # rand_a and rand_b stay fully random, no counter and no shared state.
+    def self.v7(time: Time.now)
+      new(v7_bytes(time: time))
+    end
+
+    # The same 48-bit unix_ts_ms and random tail as .v7, rendered straight
+    # to the canonical form — drop-in for SecureRandom.uuid_v7.
+    def self.uuid_v7(time: Time.now)
+      canonical(v7_bytes(time: time))
+    end
+
+    # The 60-bit 100-ns Gregorian timestamp both time-based versions
+    # encode, masked to the field the way v7 masks unix_ts_ms.
+    def self.gregorian_ticks(time)
+      ((time.to_i * 10_000_000) + (time.nsec / 100) + GREGORIAN_OFFSET) & 0xFFFFFFFFFFFFFFF
+    end
+
+    # The node: nil draws a fresh CSPRNG value with the multicast bit set
+    # (RFC §6.10), an Integer-like input masks to 48 bits, a string-like
+    # input unpacks from its 6 binary bytes — the size is the requirement,
+    # not the class — and a Symbol goes by its #name, the frozen String it
+    # already carries. The 48 bits travel as hex — a Q> would land past the
+    # immediate Integers three times in four and cost an object when it
+    # does.
+    def self.node_id(node)
+      case node
+      when nil
+        SecureRandom.bytes(6).unpack1("H12").to_i(16) | (1 << 40)
+      when Integer
+        node & 0xFFFFFFFFFFFF
+      when String
+        raise TypeError, "a 6-byte node String is required (got #{node.bytesize} bytes)" unless node.bytesize == 6
+
+        node.b.unpack1("H12").to_i(16)
+      when Symbol
+        node_id(node.name)
+      else
+        return node.to_int & 0xFFFFFFFFFFFF if defined?(node.to_int)
+        return node_id(node.to_s) if defined?(node.to_s)
+
+        got = defined?(node.class) ? node.class : "a classless object"
+        raise TypeError, "an Integer-like or 6-byte string-like node is required (got #{got})"
+      end
+    end
+
+    # The low word v1 and v6 share: the 14-bit clock_seq over the 48-bit
+    # node, the variant's top two bits stamped in place after the pack. A
+    # nil clock_sequence draws a fresh CSPRNG value, as v4 draws its bits;
+    # an Integer-like one masks to 14 bits.
+    def self.sequence_low(node, clock_sequence)
+      clock_sequence = case clock_sequence
+                       when Integer then clock_sequence
+                       when nil then SecureRandom.bytes(2).unpack1("n") & 0x3FFF
+                       else
+                         unless defined?(clock_sequence.to_int)
+                           got = defined?(clock_sequence.class) ? clock_sequence.class : "a classless object"
+                           raise TypeError, "an Integer-like clock_sequence is required (got #{got})"
+                         end
+
+                         clock_sequence.to_int
+                       end
+
+      ((clock_sequence & 0x3FFF) << 48) | node_id(node)
+    end
+
+    # The 60-bit Gregorian timestamp split least-significant-first:
+    # time_low, then time_mid, then time_hi under the version nibble 1.
+    # Where possible, prefer v7 (RFC §5.7): v1's least significant field
+    # sits first, so it does not sort chronologically.
+    def self.v1(time: Time.now, node: nil, clock_sequence: nil)
+      new(v1_bytes(time: time, node: node, clock_sequence: clock_sequence))
+    end
+
+    # The same 60-bit timestamp as .v1, rendered straight to the canonical
+    # form with the same node and clock sequence handling.
+    def self.uuid_v1(time: Time.now, node: nil, clock_sequence: nil)
+      canonical(v1_bytes(time: time, node: node, clock_sequence: clock_sequence))
+    end
+
+    # v1's timestamp reordered most-significant-first (RFC §5.6, the v1
+    # migration version): time_high, then time_mid, then time_low under the
+    # version nibble 6. Same node, clock sequence and variant as v1, and it
+    # sorts chronologically where v1 does not.
+    def self.v6(time: Time.now, node: nil, clock_sequence: nil)
+      new(v6_bytes(time: time, node: node, clock_sequence: clock_sequence))
+    end
+
+    # The same reordered timestamp as .v6, rendered straight to the
+    # canonical form.
+    def self.uuid_v6(time: Time.now, node: nil, clock_sequence: nil)
+      canonical(v6_bytes(time: time, node: node, clock_sequence: clock_sequence))
+    end
+
+    # MD5 over the namespace's 16 bytes followed by the name's, version and
+    # variant stamped into the whole 128-bit digest. Where possible, prefer
+    # v5.
+    def self.v3(namespace, name)
+      new(v3_bytes(namespace, name))
+    end
+
+    # The same digest as .v3, rendered straight to the canonical form.
+    def self.uuid_v3(namespace, name)
+      canonical(v3_bytes(namespace, name))
+    end
+
+    # SHA-1 over the same input as v3, the leftmost 128 bits of its 160-bit
+    # digest (the rightmost 32 discarded), version and variant stamped in
+    # place.
+    def self.v5(namespace, name)
+      new(v5_bytes(namespace, name))
+    end
+
+    # The same digest as .v5, rendered straight to the canonical form.
+    def self.uuid_v5(namespace, name)
+      canonical(v5_bytes(namespace, name))
+    end
+
+    # The RFC's recommended default: v7.
+    def self.generate
+      v7
+    end
+
+    # The RFC's recommended default as a String: the v7 canonical form.
+    def self.uuid
+      uuid_v7
+    end
+
+    # The input of both name-based versions: the namespace's 16 bytes
+    # followed by the name's. A UUID namespace is itself and anything else
+    # string-like parses as one; the name is the String form it carries —
+    # a name has no grammar, every String is one.
+    def self.digest_input(namespace, name)
+      name = implicit_string(name)
+      namespace = case namespace
+                  when UUID then namespace
+                  else parse(namespace)
+                  end
+      namespace.bytes + name.b
+    end
+
+    private_class_method :digest_input
+
+    # The 16 raw bytes each version builds, version and variant nibbles
+    # stamped in place, shared by the object constructors and their uuid_*
+    # String twins.
+    def self.v4_bytes
+      stamp(SecureRandom.bytes(16), 4)
+    end
+
+    def self.v7_bytes(time:)
+      bytes = SecureRandom.bytes(16)
+      milliseconds = (time.to_i * 1000) + (time.nsec / 1_000_000)
+      milliseconds &= 0xFFFFFFFFFFFF
+      # The masked unix_ts_ms rides in the middle six bytes of an 8-byte
+      # word, leaving bytes 6-7 to the random rand_a they already hold.
+      bytes.bytesplice(0, 6, [milliseconds].pack("Q>"), 2, 6)
+      stamp(bytes, 7)
+    end
+
+    def self.v1_bytes(time:, node:, clock_sequence:)
+      ticks = gregorian_ticks(time)
+      bytes = [((ticks & 0xFFFFFFFF) << 32) | (((ticks >> 32) & 0xFFFF) << 16) | (ticks >> 48),
+               sequence_low(node, clock_sequence)].pack("Q> Q>")
+      stamp(bytes, 1)
+    end
+
+    def self.v6_bytes(time:, node:, clock_sequence:)
+      ticks = gregorian_ticks(time)
+      bytes = [((ticks >> 28) << 32) | (((ticks >> 12) & 0xFFFF) << 16) | (ticks & 0xFFF),
+               sequence_low(node, clock_sequence)].pack("Q> Q>")
+      stamp(bytes, 6)
+    end
+
+    def self.v3_bytes(namespace, name)
+      stamp(Digest::MD5.digest(digest_input(namespace, name)), 3)
+    end
+
+    def self.v5_bytes(namespace, name)
+      stamp(Digest::SHA1.digest(digest_input(namespace, name)).byteslice(0, 16), 5)
+    end
+
+    # The version nibble and the 10xx variant, masked into the finished 16
+    # bytes in place — setbyte arithmetic, zero objects.
+    def self.stamp(bytes, version)
+      bytes.setbyte(6, (bytes.getbyte(6) & 0x0F) | (version << 4))
+      bytes.setbyte(8, (bytes.getbyte(8) & 0x3F) | 0x80)
+      bytes
+    end
+
+    # The canonical dashed form of 16 stamped bytes: hexencode's lowercase
+    # hex, the hyphens inserted in place, frozen like #to_s.
+    def self.canonical(bytes)
+      Digest.hexencode(bytes).insert(8, "-").insert(13, "-").insert(18, "-").insert(23, "-").freeze
+    end
+
+    private_class_method :v4_bytes, :v7_bytes, :v1_bytes, :v6_bytes, :v3_bytes, :v5_bytes,
+                         :stamp, :canonical
+
+    # The String a parse or valid? input carries: a String is itself, a
+    # Symbol's frozen #name is already the String it carries — no #to_s
+    # copy — anything else responding to #to_s converts, anything else has
+    # no string form. A BasicObject descendant has no #is_a?, #class or
+    # #respond_to? either, so the probe is defined? — and the TypeError
+    # cannot name the class.
+    def self.implicit_string(str)
+      raise TypeError, "no implicit conversion into Fast::UUID" unless defined?(str.to_s)
+
+      str = str.name if str.is_a?(Symbol)
+      str = str.to_s unless str.is_a?(String)
+      str
+    end
+
+    private_class_method :implicit_string
+
+    def self.parse(str)
+      str = implicit_string(str)
+      raise ParseError, "not a valid UUID: #{str}" unless CANONICAL.match?(str)
+
+      new([str.delete("-")].pack("H*"))
+    end
+
+    def self.parse?(str)
+      parse(str)
+    rescue TypeError, ParseError
+      nil
+    end
+
+    def self.valid?(str)
+      CANONICAL.match?(implicit_string(str))
+    rescue TypeError
+      false
+    end
+
+    # From a 16-byte binary String, or anything carrying one via #to_str,
+    # the implicit String protocol; an encoding tag on the input is
+    # normalized to binary, every other ill shape raises ArgumentError.
+    # The probe is defined?, as implicit_string's — a BasicObject
+    # descendant has no #is_a? and must ArgumentError, not NoMethodError.
+    def initialize(bytes)
+      bytes = bytes.to_str if defined?(bytes.to_str) && !bytes.is_a?(String)
+
+      case bytes
+      when String
+        unless bytes.bytesize == 16
+          raise ArgumentError, "a 16-byte binary String is required (got #{bytes.bytesize} bytes)"
+        end
+      else
+        got = defined?(bytes.class) ? bytes.class : "a classless object"
+        raise ArgumentError, "a 16-byte binary String is required (got #{got})"
+      end
+
+      @bytes = bytes.b.freeze
+      @string = Digest.hexencode(@bytes).insert(8, "-").insert(13, "-").insert(18, "-").insert(23, "-").freeze
+      freeze
+    end
+
+    def version
+      @bytes.getbyte(6) >> 4
+    end
+
+    def variant
+      case @bytes.getbyte(8) >> 5
+      when 0b100, 0b101 then :rfc9562
+      when 0b110 then :microsoft
+      when 0b111 then :future
+      else :ncs
+      end
+    end
+
+    def timestamp
+      case version
+      when 1
+        # time_low, time_mid, then time_hi_and_version on the wire.
+        gregorian(((@bytes[6, 2].unpack1("n") & 0x0FFF) << 48) | (@bytes[4, 2].unpack1("n") << 32) |
+                  @bytes[0, 4].unpack1("N"))
+      when 6
+        # time_high, time_mid, time_low in descending order of significance.
+        gregorian((@bytes[0, 4].unpack1("N") << 28) | (@bytes[4, 2].unpack1("n") << 12) |
+                  (@bytes[6, 2].unpack1("n") & 0x0FFF))
+      when 7
+        milliseconds = @bytes[0, 8].unpack1("Q>") >> 16
+        Time.at(milliseconds / 1000, (milliseconds % 1000) * 1_000_000, :nanosecond).utc
+      end
+    end
+
+    attr_reader :bytes
+
+    def to_s
+      @string
+    end
+
+    alias to_str to_s
+
+    def hex
+      Digest.hexencode(@bytes)
+    end
+
+    def urn
+      "urn:uuid:#{@string}"
+    end
+
+    def nil_uuid?
+      self == NIL
+    end
+
+    def max_uuid?
+      self == MAX
+    end
+
+    def ==(other)
+      other.is_a?(UUID) && other.bytes == bytes
+    end
+
+    alias eql? ==
+
+    def hash
+      bytes.hash
+    end
+
+    # Opaque unsigned 128-bit byte order: v6 and v7 sort chronologically as
+    # raw bytes; v1 does not, its time_low sits first.
+    def <=>(other)
+      bytes <=> other.bytes if other.is_a?(UUID)
+    end
+
+    private
+
+    def gregorian(ticks)
+      unix_ticks = ticks - GREGORIAN_OFFSET
+      Time.at(unix_ticks / 10_000_000, (unix_ticks % 10_000_000) * 100, :nanosecond).utc
+    end
+  end
+end
+
+Fast::UUID::NIL = Fast::UUID.new(("\0" * 16).b)
+Fast::UUID::MAX = Fast::UUID.new(("\xFF" * 16).b)
+Fast::UUID::NAMESPACE_DNS = Fast::UUID.parse("6ba7b810-9dad-11d1-80b4-00c04fd430c8")
+Fast::UUID::NAMESPACE_URL = Fast::UUID.parse("6ba7b811-9dad-11d1-80b4-00c04fd430c8")
+Fast::UUID::NAMESPACE_OID = Fast::UUID.parse("6ba7b812-9dad-11d1-80b4-00c04fd430c8")
+Fast::UUID::NAMESPACE_X500 = Fast::UUID.parse("6ba7b814-9dad-11d1-80b4-00c04fd430c8")

data/lib/fast/uuid/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Fast
+  class UUID
+    VERSION = "0.1.0"
+  end
+end

data/lib/fast/uuid.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "uuid/version"
+require_relative "uuid/errors"
+require_relative "uuid/uuid"

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: fast-uuid
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Eric Jacobs
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- README.md
+- lib/fast/uuid.rb
+- lib/fast/uuid/errors.rb
+- lib/fast/uuid/uuid.rb
+- lib/fast/uuid/version.rb
+homepage: https://github.com/jetpks/fast-uuid
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/jetpks/fast-uuid
+  source_code_uri: https://github.com/jetpks/fast-uuid
+  changelog_uri: https://github.com/jetpks/fast-uuid/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.20
+specification_version: 4
+summary: 'RFC 9562 UUIDs for Ruby: generate v4/v7, parse every version, compare, no
+  dependencies.'
+test_files: []