uuidtools 2.2.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a5cf7d8f6def3ddb0c325cfe8d2dec0404b73996c69f559888d74dad4f6519f1
-  data.tar.gz: 4ba7a0931d37d6f14f664e230d38610995d281167ab1c0e0ed2ea6355c93a060
+  metadata.gz: 3a3a7b4cd84917d78bc44482023ea1e337b407b176dda81fc097f1617bfb1545
+  data.tar.gz: 9af85de9393ea8752ee5cba3feff96f2ba7994dd4092bea6dcae5bdb6229c12f
 SHA512:
-  metadata.gz: f9ac42163867349a27f20100c859be1103dec0b5c402f7630371d8debadb8a760b399f4f4369a941111987ca53ab68775947431f21ce29c7d267efb2a88fcc2c
-  data.tar.gz: 20b1d43a62100484f52844a919ba4683ca774da910e572acb865d599af5b6ad795180418746039b7a9b2f24942350a00414ca3309c6987dbf93085330017842c
+  metadata.gz: e31987aae1c0376ca5cece706c0532e900c4033cc8923c86aa97aa2cb974fd817dcc5749935be8a525050c6b070ab98d268ebe4b826f508bff041adfe125ee75
+  data.tar.gz: 37ee507b3aa1bef02ebabc4ddfbc496ee3339ef5664134f52ebeb31044e8065935aa39088bfe2b7594745a4ff8d3c0f14b53a098a59d98f9ff54a62148903b69

data/CHANGELOG

@@ -1,3 +1,9 @@
+== UUIDTools 3.0.0
+ * more strict validation, accept variants with most significant bits set to 1 and 0
+ * v6, v7, v8 UUIDs are now considered valid
+ * better MAC address behavior for container environments
+ * windows MAC address detection now uses a fallback location like other OSes
+ * frozen string literal fixes
 == UUIDTools 2.2.0
  * drop support for ruby < 2.3
  * use Integer vs Fixnum

data/lib/uuidtools/version.rb

@@ -20,8 +20,8 @@
 unless defined? UUIDTools::VERSION
   module UUIDTools
     module VERSION #:nodoc:
-      MAJOR = 2
-      MINOR = 2
+      MAJOR = 3
+      MINOR = 0
       TINY  = 0
 
       STRING = [MAJOR, MINOR, TINY].join('.')

data/lib/uuidtools.rb

@@ -416,12 +416,7 @@ module UUIDTools
     ##
     # Returns true if this UUID is valid.
     def valid?
-      if [0b000, 0b100, 0b110, 0b111].include?(self.variant) &&
-        (1..5).include?(self.version)
-        return true
-      else
-        return false
-      end
+      return self.variant == 0b100 && (1..8).cover?(self.version)
     end
 
     ##
@@ -585,36 +580,47 @@ module UUIDTools
     def self.os_class
       require 'rbconfig'
       os_platform = RbConfig::CONFIG['target_os']
-      os_class = nil
       if (os_platform =~ /win/i && !(os_platform =~ /darwin/i)) ||
           os_platform =~ /w32/i
-        os_class = :windows
+        :windows
       elsif os_platform =~ /solaris/i
-        os_class = :solaris
+        :solaris
       elsif os_platform =~ /netbsd/i
-        os_class = :netbsd
+        :netbsd
       elsif os_platform =~ /openbsd/i
-        os_class = :openbsd
+        :openbsd
       end
     end
 
     # making these class variables helps with testing
+    @ipconfig_command = "ipconfig"
+    @ipconfig_path_default = "c:\\windows\\system32\\ipconfig.exe"
     @ifconfig_command = "ifconfig"
     @ifconfig_path_default = "/sbin/ifconfig"
     @ip_command = "ip"
     @ip_path_default = "/sbin/ip"
 
     class << self
+      attr_accessor :ipconfig_command, :ipconfig_path_default
       attr_accessor :ifconfig_command, :ifconfig_path_default
       attr_accessor :ip_command, :ip_path_default
     end
 
+    #
+    # Find the path of the ipconfig command if it is present
+    #
+    def self.ipconfig_path
+      path = `where #{UUID.ipconfig_command}`.strip
+      path = UUID.ipconfig_path_default if path == "" && File.exist?(UUID.ipconfig_path_default)
+      return (path === "" ? nil : path)
+    end
+
     #
     # Find the path of the ifconfig(8) command if it is present
     #
     def self.ifconfig_path
       path = `which #{UUID.ifconfig_command} 2>/dev/null`.strip
-      path = UUID.ifconfig_path_default if (path == "" && File.exist?(UUID.ifconfig_path_default))
+      path = UUID.ifconfig_path_default if path == "" && File.exist?(UUID.ifconfig_path_default)
       return (path === "" ? nil : path)
     end
 
@@ -623,30 +629,41 @@ module UUIDTools
     #
     def self.ip_path
       path = `which #{UUID.ip_command} 2>/dev/null`.strip
-      path = UUID.ip_path_default if (path == "" && File.exist?(UUID.ip_path_default))
+      path = UUID.ip_path_default if path == "" && File.exist?(UUID.ip_path_default)
       return (path === "" ? nil : path)
     end
 
+    #
+    # Call the ipconfig command that is found
+    #
+    def self.ipconfig(all = nil)
+      ipconfig_path = UUID.ipconfig_path
+      command =
+        if ipconfig_path
+          "#{ipconfig_path}#{all ? ' /all' : ''}"
+        end
+      `#{command}` if command
+    end
+
     #
     # Call the ifconfig or ip command that is found
     #
-    def self.ifconfig(all=nil)
-      # find the path of the ifconfig command
+    def self.ifconfig(all = nil)
       ifconfig_path = UUID.ifconfig_path
-
-      # if it does not exist, try the ip command
-      if ifconfig_path == nil
-        ifconfig_path = "#{UUID.ip_path} addr list"
-        # all makes no sense when using ip(1)
-        all = nil
-      end
-
-      all_switch = all == nil ? "" : "-a"
-      return `#{ifconfig_path} #{all_switch}` if not ifconfig_path == nil
+      ip_path = UUID.ip_path
+      command =
+        if ifconfig_path
+          "#{ifconfig_path}#{all ? ' -a' : ''}"
+        elsif ip_path
+          "#{ip_path} addr list"
+        end
+      `#{command}` if command
     end
 
     # Match and return the first Mac address found
     def self.first_mac(instring)
+      return nil if instring.nil?
+
       mac_regexps = [
         Regexp.new("address:? (#{(["[0-9a-fA-F]{2}"] * 6).join(":")})"),
         Regexp.new("addr:? (#{(["[0-9a-fA-F]{2}"] * 6).join(":")})"),
@@ -679,17 +696,23 @@ module UUIDTools
     # Returns nil if a MAC address could not be found.
     def self.mac_address
       if !defined?(@@mac_address)
+        @@mac_address = nil
         require 'rbconfig'
 
         os_class = UUID.os_class
 
         if os_class == :windows
           begin
-            @@mac_address = UUID.first_mac `ipconfig /all`
+            ipconfig_output = UUID.ipconfig(:all)
+            @@mac_address = UUID.first_mac ipconfig_output
           rescue
           end
-        else # linux, bsd, macos, solaris
-          @@mac_address = UUID.first_mac(UUID.ifconfig(:all))
+        else
+          ifconfig_output = UUID.ifconfig(:all)
+          if ifconfig_output
+            # linux, bsd, macos, solaris
+            @@mac_address = UUID.first_mac ifconfig_output
+          end
         end
 
         if @@mac_address != nil
@@ -753,7 +776,7 @@ module UUIDTools
     ##
     # @api private
     def self.convert_int_to_byte_string(integer, size)
-      byte_string = ""
+      byte_string = +""
       if byte_string.respond_to?(:force_encoding)
         byte_string.force_encoding(Encoding::ASCII_8BIT)
       end
@@ -788,8 +811,8 @@ module UUIDTools
 
   ##
   # Constant Regexp that matches a UUID and captures its components.
-  UUID_REGEXP = Regexp.new("^([0-9a-f]{8})-([0-9a-f]{4})-([0-9a-f]{4})-" +
-                          "([0-9a-f]{2})([0-9a-f]{2})-([0-9a-f]{12})$")
+  UUID_REGEXP = Regexp.new("\\A([0-9a-f]{8})-([0-9a-f]{4})-([0-9a-f]{4})-" +
+                          "([0-9a-f]{2})([0-9a-f]{2})-([0-9a-f]{12})\\z")
 
   ##
   # Constant that represents the DNS namespace.

data/spec/uuidtools/mac_address_spec.rb

@@ -213,7 +213,8 @@ samples = {
   :openbsd => openbsd_sample,
   :linux => linux_sample,
   :linux2 => linux_sample_2,
-  :linuxip => linux_ip_sample
+  :linuxip => linux_ip_sample,
+  :docker => nil
 }
 
 macs = {
@@ -260,49 +261,57 @@ describe UUIDTools::UUID, "before obtaining a MAC address" do
   end
 
   it "should parse windows MAC addresses" do
-    # mock ifconfig() to return the windows sample
-    allow(UUIDTools::UUID).to receive(:ifconfig) { samples[:windows] }
+    # mock os_class() so that we don't get different mock behavior on windows
+    allow(UUIDTools::UUID).to receive(:os_class) { :windows }
+    allow(UUIDTools::UUID).to receive(:ipconfig) { samples[:windows] }
     mac = UUIDTools::UUID.mac_address
     expect(mac).to eql(macs[:windows])
   end
 
   it "should parse solaris MAC addresses" do
+    allow(UUIDTools::UUID).to receive(:os_class) { :solaris }
     allow(UUIDTools::UUID).to receive(:ifconfig) { samples[:solaris] }
     mac = UUIDTools::UUID.mac_address
     expect(mac).to eql(macs[:solaris])
   end
 
   it "should parse freebsd MAC addresses" do
+    allow(UUIDTools::UUID).to receive(:os_class) { nil }
     allow(UUIDTools::UUID).to receive(:ifconfig) { samples[:freebsd] }
     mac = UUIDTools::UUID.mac_address
     expect(mac).to eql(macs[:freebsd])
   end
 
   it "should parse openbsd MAC addresses" do
+    allow(UUIDTools::UUID).to receive(:os_class) { :openbsd }
     allow(UUIDTools::UUID).to receive(:ifconfig) { samples[:openbsd] }
     mac = UUIDTools::UUID.mac_address
     expect(mac).to eql(macs[:openbsd])
   end
 
   it "should parse linux MAC addresses with ifconfig" do
+    allow(UUIDTools::UUID).to receive(:os_class) { nil }
     allow(UUIDTools::UUID).to receive(:ifconfig) { samples[:linux] }
     mac = UUIDTools::UUID.mac_address
     expect(mac).to eql(macs[:linux])
   end
 
   it "should parse a linux HWaddr address with ifconfig" do
+    allow(UUIDTools::UUID).to receive(:os_class) { nil }
     allow(UUIDTools::UUID).to receive(:ifconfig) { samples[:linux2] }
     mac = UUIDTools::UUID.mac_address
     expect(mac).to eql(macs[:linux2])
   end
 
   it "should parse macos MAC addresses with ifconfig" do
+    allow(UUIDTools::UUID).to receive(:os_class) { nil }
     allow(UUIDTools::UUID).to receive(:ifconfig) { samples[:macos] }
     mac = UUIDTools::UUID.mac_address
     expect(mac).to eql(macs[:macos])
   end
 
   it "should parse linux MAC addresses with ip" do
+    allow(UUIDTools::UUID).to receive(:os_class) { nil }
     allow(UUIDTools::UUID).to receive(:ifconfig) { samples[:linuxip] }
     mac = UUIDTools::UUID.mac_address
     expect(mac).to eql(macs[:linuxip])
@@ -451,4 +460,9 @@ describe UUIDTools::UUID, "before obtaining a MAC address" do
     mac = UUIDTools::UUID.first_mac samples[:linuxip]
     expect(mac).to eql(macs[:linuxip])
   end
+
+  it "should return nil when unable to identify the mac address" do
+    mac = UUIDTools::UUID.first_mac nil
+    expect(mac).to be_nil
+  end
 end

data/spec/uuidtools/uuid_creation_spec.rb

@@ -14,6 +14,7 @@ describe UUIDTools::UUID, "when generating" do
   end
 
   it "should correctly generate timestamp variant UUIDs" do
+    allow(UUIDTools::UUID).to receive(:mac_address) { "aa:bb:cc:dd:ee:ff" }
     expect(UUIDTools::UUID.timestamp_create).not_to be_random_node_id
     expect(UUIDTools::UUID.timestamp_create.to_s).not_to eql(
       UUIDTools::UUID.timestamp_create.to_s
@@ -54,77 +55,77 @@ describe UUIDTools::UUID, "when generating" do
   end
 
   it "should throw an exception if a segment has an invalid value" do
-    expect(lambda do
+    expect do
       UUIDTools::UUID.new(-1, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])
-    end).to raise_error(ArgumentError)
-    expect(lambda do
+    end.to raise_error(ArgumentError)
+    expect do
       UUIDTools::UUID.new(4294967296, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])
-    end).to raise_error(ArgumentError)
+    end.to raise_error(ArgumentError)
   end
 
   it "should throw an exception if a segment has an invalid value" do
-    expect(lambda do
+    expect do
       UUIDTools::UUID.new(0, -1, 0, 0, 0, [0, 0, 0, 0, 0, 0])
-    end).to raise_error(ArgumentError)
-    expect(lambda do
+    end.to raise_error(ArgumentError)
+    expect do
       UUIDTools::UUID.new(0, 65536, 0, 0, 0, [0, 0, 0, 0, 0, 0])
-    end).to raise_error(ArgumentError)
+    end.to raise_error(ArgumentError)
   end
 
   it "should throw an exception if a segment has an invalid value" do
-    expect(lambda do
+    expect do
       UUIDTools::UUID.new(0, 0, -1, 0, 0, [0, 0, 0, 0, 0, 0])
-    end).to raise_error(ArgumentError)
-    expect(lambda do
+    end.to raise_error(ArgumentError)
+    expect do
       UUIDTools::UUID.new(0, 0, 65536, 0, 0, [0, 0, 0, 0, 0, 0])
-    end).to raise_error(ArgumentError)
+    end.to raise_error(ArgumentError)
   end
 
   it "should throw an exception if a segment has an invalid value" do
-    expect(lambda do
+    expect do
       UUIDTools::UUID.new(0, 0, 0, -1, 0, [0, 0, 0, 0, 0, 0])
-    end).to raise_error(ArgumentError)
-    expect(lambda do
+    end.to raise_error(ArgumentError)
+    expect do
       UUIDTools::UUID.new(0, 0, 0, 256, 0, [0, 0, 0, 0, 0, 0])
-    end).to raise_error(ArgumentError)
+    end.to raise_error(ArgumentError)
   end
 
   it "should throw an exception if a segment has an invalid value" do
-    expect(lambda do
+    expect do
       UUIDTools::UUID.new(0, 0, 0, 0, -1, [0, 0, 0, 0, 0, 0])
-    end).to raise_error(ArgumentError)
-    expect(lambda do
+    end.to raise_error(ArgumentError)
+    expect do
       UUIDTools::UUID.new(0, 0, 0, 0, 256, [0, 0, 0, 0, 0, 0])
-    end).to raise_error(ArgumentError)
+    end.to raise_error(ArgumentError)
   end
 
   it "should throw an exception if nodes are not a collection" do
-    expect(lambda do
+    expect do
       UUIDTools::UUID.new(0, 0, 0, 0, 0, :bogus)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "should throw an exception if nodes are the wrong size" do
-    expect(lambda do
+    expect do
       UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0])
-    end).to raise_error(ArgumentError)
+    end.to raise_error(ArgumentError)
   end
 
   it "should throw an exception if any nodes have invalid values" do
-    expect(lambda do
+    expect do
       UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 256])
-    end).to raise_error(ArgumentError)
+    end.to raise_error(ArgumentError)
   end
 
   it "should throw an exception if parsing anything but a String" do
-    expect(lambda do
+    expect do
       UUIDTools::UUID.parse(:bogus)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "should throw an exception if raw parsing anything but a String" do
-    expect(lambda do
+    expect do
       UUIDTools::UUID.parse_raw(:bogus)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 end

data/spec/uuidtools/uuid_parsing_spec.rb

@@ -25,6 +25,7 @@ describe UUIDTools::UUID, "when parsing" do
   end
 
   it "should not treat a timestamp version UUID as a random node UUID" do
+    allow(UUIDTools::UUID).to receive(:mac_address) { "aa:bb:cc:dd:ee:ff" }
     expect(UUIDTools::UUID.timestamp_create).not_to be_random_node_id
   end
 
@@ -64,6 +65,22 @@ describe UUIDTools::UUID, "when parsing" do
     expect(UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])).not_to be_valid
   end
 
+  it "should not identify UUIDs prefixed by other strings as valid" do
+    expect do
+      UUIDTools::UUID.parse("bogus\n#{UUIDTools::UUID.random_create}")
+    end.to raise_error(ArgumentError)
+  end
+
+  it "should not identify UUIDs suffixed by other strings as valid" do
+    expect do
+      UUIDTools::UUID.parse("#{UUIDTools::UUID.random_create}\nbogus")
+    end.to raise_error(ArgumentError)
+  end
+
+  it "should parse v7 UUIDs as valid" do
+    expect(UUIDTools::UUID.parse("01957ca6-fc1a-7322-956e-e9e6c53cab55")).to be_valid
+  end
+
   it "should allow for sorting of UUID arrays" do
     uuids = []
     1000.times do
@@ -129,12 +146,13 @@ describe UUIDTools::UUID, "when parsing" do
   it "should correctly parse raw bytes" do
     # NOTE: Short Input
     expect(UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])).to eql(
-      UUIDTools::UUID.parse_raw(""))
+      UUIDTools::UUID.parse_raw(+"")
+    )
 
     # NOTE: Nil Input
-    expect(UUIDTools::UUID.parse_raw(
-      "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
-    )).to be_nil_uuid
+    expect(
+      UUIDTools::UUID.parse_raw(+"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0")
+    ).to be_nil_uuid
 
     # NOTE: Realistic Input
     uuid = UUIDTools::UUID.timestamp_create

data/uuidtools.gemspec

@@ -1,42 +1,28 @@
 # -*- encoding: utf-8 -*-
-# stub: uuidtools 2.2.0 ruby lib
+# stub: uuidtools 3.0.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "uuidtools".freeze
-  s.version = "2.2.0"
+  s.version = "3.0.0".freeze
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib".freeze]
   s.authors = ["Bob Aman".freeze]
-  s.date = "2020-07-09"
+  s.date = "2025-03-09"
   s.description = "A simple universally unique ID generation library.\n".freeze
   s.email = "bob@sporkmonger.com".freeze
   s.extra_rdoc_files = ["README.md".freeze]
-  s.files = ["CHANGELOG".freeze, "LICENSE.txt".freeze, "README.md".freeze, "Rakefile".freeze, "doc".freeze, "documentation".freeze, "lib".freeze, "lib/compat".freeze, "lib/compat/securerandom.rb".freeze, "lib/uuidtools".freeze, "lib/uuidtools.rb".freeze, "lib/uuidtools/version.rb".freeze, "pkg".freeze, "spec".freeze, "spec/spec.opts".freeze, "spec/spec_helper.rb".freeze, "spec/uuidtools".freeze, "spec/uuidtools/mac_address_spec.rb".freeze, "spec/uuidtools/utility_spec.rb".freeze, "spec/uuidtools/uuid_creation_spec.rb".freeze, "spec/uuidtools/uuid_parsing_spec.rb".freeze, "tasks".freeze, "tasks/benchmark.rake".freeze, "tasks/gem.rake".freeze, "tasks/git.rake".freeze, "tasks/metrics.rake".freeze, "tasks/rspec.rake".freeze, "tasks/yard.rake".freeze, "uuidtools.gemspec".freeze, "website".freeze, "website/index.html".freeze]
+  s.files = ["CHANGELOG".freeze, "LICENSE.txt".freeze, "README.md".freeze, "Rakefile".freeze, "lib".freeze, "lib/compat".freeze, "lib/compat/securerandom.rb".freeze, "lib/uuidtools".freeze, "lib/uuidtools.rb".freeze, "lib/uuidtools/version.rb".freeze, "spec".freeze, "spec/spec.opts".freeze, "spec/spec_helper.rb".freeze, "spec/uuidtools".freeze, "spec/uuidtools/mac_address_spec.rb".freeze, "spec/uuidtools/utility_spec.rb".freeze, "spec/uuidtools/uuid_creation_spec.rb".freeze, "spec/uuidtools/uuid_parsing_spec.rb".freeze, "tasks".freeze, "tasks/benchmark.rake".freeze, "tasks/gem.rake".freeze, "tasks/git.rake".freeze, "tasks/metrics.rake".freeze, "tasks/rspec.rake".freeze, "tasks/yard.rake".freeze, "uuidtools.gemspec".freeze, "website".freeze, "website/index.html".freeze]
   s.homepage = "https://github.com/sporkmonger/uuidtools".freeze
   s.licenses = ["Apache-2.0".freeze]
   s.rdoc_options = ["--main".freeze, "README.md".freeze]
-  s.rubygems_version = "3.0.8".freeze
+  s.rubygems_version = "3.6.3".freeze
   s.summary = "UUID generator".freeze
 
-  if s.respond_to? :specification_version then
-    s.specification_version = 4
+  s.specification_version = 4
 
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<rake>.freeze, [">= 0.7.3"])
-      s.add_development_dependency(%q<rspec>.freeze, [">= 2.9.0"])
-      s.add_development_dependency(%q<yard>.freeze, [">= 0.8.2"])
-      s.add_development_dependency(%q<launchy>.freeze, [">= 2.0.0"])
-    else
-      s.add_dependency(%q<rake>.freeze, [">= 0.7.3"])
-      s.add_dependency(%q<rspec>.freeze, [">= 2.9.0"])
-      s.add_dependency(%q<yard>.freeze, [">= 0.8.2"])
-      s.add_dependency(%q<launchy>.freeze, [">= 2.0.0"])
-    end
-  else
-    s.add_dependency(%q<rake>.freeze, [">= 0.7.3"])
-    s.add_dependency(%q<rspec>.freeze, [">= 2.9.0"])
-    s.add_dependency(%q<yard>.freeze, [">= 0.8.2"])
-    s.add_dependency(%q<launchy>.freeze, [">= 2.0.0"])
-  end
+  s.add_development_dependency(%q<rake>.freeze, [">= 0.7.3".freeze])
+  s.add_development_dependency(%q<rspec>.freeze, [">= 2.9.0".freeze])
+  s.add_development_dependency(%q<yard>.freeze, [">= 0.8.2".freeze])
+  s.add_development_dependency(%q<launchy>.freeze, [">= 2.0.0".freeze])
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: uuidtools
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Bob Aman
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-07-09 00:00:00.000000000 Z
+date: 2025-03-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -100,7 +99,6 @@ homepage: https://github.com/sporkmonger/uuidtools
 licenses:
 - Apache-2.0
 metadata: {}
-post_install_message: 
 rdoc_options:
 - "--main"
 - README.md
@@ -117,8 +115,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.8
-signing_key: 
+rubygems_version: 3.6.3
 specification_version: 4
 summary: UUID generator
 test_files: []