uuid-v9 0.0.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 30c3ab5576199b652feaba4dd0b27d093b0f0ca2f360235928db75cbed640f0c
-  data.tar.gz: c3dbea2d7e23028bc48bb5a8615f92daa8d191cf5711cdba5b0e46d244174690
+  metadata.gz: e91cef6ff913feedd5498b37b4caa47d35289c22f1524bee3318e0e9e178eea3
+  data.tar.gz: 8628af9c15b93665e006711d747755d16b893cd6743fe8287214e6b194f4336e
 SHA512:
-  metadata.gz: a8d7628ee54094f1627f42723e2953c1805ca1629e8701f485882a96e9e3c4b98106a0abc34d80b4c3c4df71a1431405ff5aec6eb5e01f96981e85388b02952c
-  data.tar.gz: 26eaa520c36ffe03a75f25edbd301989353f14e3e504b480e392a56d5e0af380e66be8ff315a93ac01480442cb6dcec2021014d724840a062a7728d399177a22
+  metadata.gz: 7057703635d13911723d7ce085975bcb524f1e4c03a3013eee2d3c1ea93f2ba23b5c451444d85eff5f3a7f67ca63f0a15861354b83bc4acccb45e10bbee0de13
+  data.tar.gz: a6bb594d12d619499eb4e61388a6294582a1062584b3b27bccb0b466a068c3301948c23e100d2a2f3231245e55ac7d3406cb1bdd3edf3f3ed110aeecdb96ad07

data/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 JHunt
+Copyright (c) 2023-2026 JHunt
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -2,7 +2,7 @@
 
 ## Fast, lightweight, zero-dependency Ruby implementation of UUID version 9
 
-The v9 UUID supports both sequential (time-based) and non-sequential (random) UUIDs with an optional prefix of up to four bytes, an optional checksum, and sufficient randomness to avoid collisions. It uses the UNIX timestamp for sequential UUIDs and CRC-8 for checksums. A version digit can be added if desired, but is omitted by default.
+The v9 UUID supports both sequential (time-based) and non-sequential (random) UUIDs with an optional prefix of up to four bytes, an optional checksum, and sufficient randomness to avoid collisions. It uses the UNIX timestamp for sequential UUIDs and CRC-8 for checksums. The version can be added if desired, but is omitted by default.
 
 To learn more about UUID v9, please visit the website: https://uuidv9.jhunt.dev
 
@@ -11,13 +11,13 @@ To learn more about UUID v9, please visit the website: https://uuidv9.jhunt.dev
 Install UUID v9 from Rubygems
 
 ```bash
-gem install uuid_v9
+gem install uuid-v9
 ```
 
 ## Usage
 
 ```ruby
-require 'uuid_v9'
+require 'uuid-v9'
 
 ordered_id = UUIDv9::UUIDv9.generate
 prefixed_ordered_id = UUIDv9::UUIDv9.generate(prefix: 'a1b2c3d4')
@@ -44,4 +44,6 @@ _*Legacy mode adds version and variant digits to immitate v1 or v4 UUIDs dependi
 
 ## License
 
-This project is licensed under the [MIT License](LICENSE).
+This project is licensed under the [MIT License](LICENSE).
+
+<><

data/lib/uuid-v9.rb

@@ -31,8 +31,7 @@ class UUIDv9
   def self.check_version(uuid, version = nil)
     version_digit = uuid[14]
     variant_digit = uuid[19]
-    (!version || version_digit == version) &&
-      (version_digit == '9' || (['1', '4'].include?(version_digit) && "89abAB".include?(variant_digit)))
+    (!version || (version_digit == version.to_s && "89abAB".include?(variant_digit)))
   end
 
   def self.is_uuid?(uuid)
@@ -42,7 +41,7 @@ class UUIDv9
   def self.is_valid_uuidv9?(uuid, options)
     is_uuid?(uuid) &&
       (!options.key?(:checksum) || !options[:checksum] || verify_checksum(uuid)) &&
-      (!options.key?(:version) || !options[:version] || check_version(uuid))
+      (!options.key?(:version) || !options[:version] || check_version(uuid, options[:version]))
   end
 
   def self.random_bytes(count)
@@ -58,27 +57,39 @@ class UUIDv9
   end
 
   def self.validate_prefix(prefix)
-    raise ArgumentError, 'Prefix must be a string' if prefix.nil?
+    raise ArgumentError, 'Prefix must be a string' unless prefix.is_a?(String) # isinstance?(prefix, str)
     raise ArgumentError, 'Prefix must be no more than 8 characters' if prefix.length > 8
     raise ArgumentError, 'Prefix must be only hexadecimal characters' unless is_base16?(prefix)
   end
 
+  def self.validate_suffix(suffix)
+    raise ArgumentError, 'Suffix must be a string' unless suffix.is_a?(String) # isinstance?(suffix, str)
+    raise ArgumentError, 'Suffix must be no more than 4 characters' if suffix.length > 4
+    raise ArgumentError, 'Suffix must be only hexadecimal characters' unless is_base16?(suffix)
+  end
+
   def self.add_dashes(str)
     "#{str[0, 8]}-#{str[8, 4]}-#{str[12, 4]}-#{str[16, 4]}-#{str[20..]}"
   end
 
   def self.generate(options = {})
-    prefix = options.fetch(:prefix, nil).to_s
+    prefix = options.fetch(:prefix, nil) # .to_s
     timestamp = options.fetch(:timestamp, true)
     checksum = options.fetch(:checksum, false)
     version = options.fetch(:version, false)
     legacy = options.fetch(:legacy, false)
+    suffix = options.fetch(:suffix, nil) # .to_s
 
     if prefix && !prefix.empty?
       validate_prefix(prefix)
       prefix = prefix.downcase
     end
 
+    if suffix && !suffix.empty?
+      validate_suffix(suffix)
+      suffix = suffix.downcase
+    end
+
     center = case timestamp
             when true
               Time.now.to_i.to_s(16)
@@ -90,15 +101,15 @@ class UUIDv9
               ''
             end
 
-    suffix_length = 32 - prefix.length - center.length - (checksum ? 2 : 0) - (legacy ? 2 : (version ? 1 : 0))
-    suffix = random_bytes(suffix_length)
+    random_length = 32 - (prefix ? prefix.length : 0) - (suffix ? suffix.length : 0) - center.length - (checksum ? 2 : 0) - ((legacy || version) ? 2 : 0) # (legacy ? 2 : (version ? 1 : 0))
+    random = random_bytes(random_length)
 
-    joined = "#{prefix}#{center}#{suffix}"
+    joined = "#{prefix}#{center}#{random}#{suffix}"
 
     if legacy
       joined = "#{joined[0, 12]}#{center.length > 0 ? '1' : '4'}#{joined[12, 3]}#{random_char('89ab')}#{joined[15..]}"
     elsif version
-      joined = "#{joined[0, 12]}9#{joined[12..]}"
+      joined = "#{joined[0, 12]}9#{joined[12, 3]}#{random_char('89ab')}#{joined[15..]}" # {joined[12..]}
     end
 
     joined += calc_checksum(joined) if checksum

data/spec/uuid-v9_spec.rb

@@ -4,7 +4,7 @@ require_relative '../lib/uuid-v9'
 UUID_REGEX = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/
 UUID_V1_REGEX = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-1[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$/
 UUID_V4_REGEX = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-4[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$/
-UUID_V9_REGEX = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-9[0-9a-fA-F]{3}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/
+UUID_V9_REGEX = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-9[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$/
 
 describe 'UUIDv9' do
   it 'should validate as a UUID' do
@@ -109,9 +109,9 @@ describe 'UUIDv9' do
     id2 = UUIDv9.generate({ timestamp: false, checksum: true })
     id3 = UUIDv9.generate({ prefix: 'a1b2c3d4', checksum: true })
     id4 = UUIDv9.generate({ prefix: 'a1b2c3d4', timestamp: false, checksum: true })
-    id5 = UUIDv9.generate({ checksum: true, version: true })
-    id6 = UUIDv9.generate({ checksum: true, legacy: true })
-    id7 = UUIDv9.generate({ timestamp: false, checksum: true, legacy: true })
+    id5 = UUIDv9.generate({ checksum: true, legacy: true })
+    id6 = UUIDv9.generate({ timestamp: false, checksum: true, legacy: true })
+    id7 = UUIDv9.generate({ checksum: true, version: true })
 
     expect(UUIDv9.is_uuid?(id1)).to be true
     expect(UUIDv9.is_uuid?('not-a-real-uuid')).to be false
@@ -119,9 +119,9 @@ describe 'UUIDv9' do
     expect(UUIDv9.is_valid_uuidv9?(id2, { checksum: true })).to be true
     expect(UUIDv9.is_valid_uuidv9?(id3, { checksum: true })).to be true
     expect(UUIDv9.is_valid_uuidv9?(id4, { checksum: true })).to be true
-    expect(UUIDv9.is_valid_uuidv9?(id5, { checksum: true, version: true })).to be true
-    expect(UUIDv9.is_valid_uuidv9?(id6, { checksum: true, version: true })).to be true
-    expect(UUIDv9.is_valid_uuidv9?(id7, { checksum: true, version: true })).to be true
+    expect(UUIDv9.is_valid_uuidv9?(id5, { checksum: true, version: 1 })).to be true
+    expect(UUIDv9.is_valid_uuidv9?(id6, { checksum: true, version: 4 })).to be true
+    expect(UUIDv9.is_valid_uuidv9?(id7, { checksum: true, version: 9 })).to be true
     expect(UUIDv9.verify_checksum(id1)).to be true
     expect(UUIDv9.verify_checksum(id2)).to be true
     expect(UUIDv9.verify_checksum(id3)).to be true

metadata

@@ -1,22 +1,22 @@
 --- !ruby/object:Gem::Specification
 name: uuid-v9
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.0
 platform: ruby
 authors:
 - JHunt
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-17 00:00:00.000000000 Z
+date: 2026-05-17 00:00:00.000000000 Z
 dependencies: []
 description: '"The v9 UUID supports both sequential (time-based) and non-sequential
   (random) UUIDs with an optional prefix of up to four bytes, an optional checksum,
   and sufficient randomness to avoid collisions. It uses the UNIX timestamp for sequential
-  UUIDs and CRC-8 for checksums. A version digit can be added if desired, but is omitted
+  UUIDs and CRC-8 for checksums. The version can be added if desired, but is omitted
   by default."'
 email:
-- hello@jhunt.dev
+- mail+uuidv9@jhunt.dev
 executables: []
 extensions: []
 extra_rdoc_files: []