uuidtools 2.1.5 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: ebf635496c48e173f29b09b4719846a83ab15d19
-  data.tar.gz: cdf833d1f98797978853ee0d700277704ec9ad86
+SHA256:
+  metadata.gz: 3a3a7b4cd84917d78bc44482023ea1e337b407b176dda81fc097f1617bfb1545
+  data.tar.gz: 9af85de9393ea8752ee5cba3feff96f2ba7994dd4092bea6dcae5bdb6229c12f
 SHA512:
-  metadata.gz: 33c70bffe56bd16152da53299f283067ec0087070a3b4a94347a01d30bceada03b879e3cf2df697e168deff94789c5c69933641f77707764d187debf52bad7e7
-  data.tar.gz: dd36f05b2ec9f696c6c1a1c413df01f0372e504be3c09d4db77340c7db3bd68253e326b835913ef2cf9f35fd534ccb777ea00d043b47a272da46a461607bc3fe
+  metadata.gz: e31987aae1c0376ca5cece706c0532e900c4033cc8923c86aa97aa2cb974fd817dcc5749935be8a525050c6b070ab98d268ebe4b826f508bff041adfe125ee75
+  data.tar.gz: 37ee507b3aa1bef02ebabc4ddfbc496ee3339ef5664134f52ebeb31044e8065935aa39088bfe2b7594745a4ff8d3c0f14b53a098a59d98f9ff54a62148903b69

data/CHANGELOG

@@ -1,3 +1,13 @@
+== 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
+ * performance improvements
 == UUIDTools 2.1.5
  * fixed issue with ip command vs ifconfig
  * dumped RubyForge related cruft

data/README.md

@@ -1,3 +1,5 @@
+[![Build Status](https://secure.travis-ci.org/sporkmonger/uuidtools.svg)](http://travis-ci.org/sporkmonger/uuidtools)
+
 # UUIDTools
 
 <dl>
@@ -7,10 +9,6 @@
   <dt>License</dt><dd>Apache 2.0</dd>
 </dl>
 
-[![Build Status](https://secure.travis-ci.org/sporkmonger/uuidtools.png)](http://travis-ci.org/sporkmonger/uuidtools)
-[![Dependency Status](https://gemnasium.com/sporkmonger/uuidtools.png)](https://gemnasium.com/sporkmonger/uuidtools)
-[![Gittip Donate](http://img.shields.io/gittip/sporkmonger.png)](https://www.gittip.com/sporkmonger/ "Support Open Source Development w/ Gittip")
-
 # Description
 
 UUIDTools was designed to be a simple library for generating any

data/lib/uuidtools/version.rb

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

data/lib/uuidtools.rb

@@ -164,7 +164,7 @@ module UUIDTools
       clock_seq_hi_and_reserved = uuid_components[3].to_i(16)
       clock_seq_low = uuid_components[4].to_i(16)
       nodes = []
-      for i in 0..5
+      6.times do |i|
         nodes << uuid_components[5][(i * 2)..(i * 2) + 1].to_i(16)
       end
       return self.new(time_low, time_mid, time_hi_and_version,
@@ -178,19 +178,52 @@ module UUIDTools
         raise TypeError,
           "Expected String, got #{raw_string.class.name} instead."
       end
-      integer = self.convert_byte_string_to_int(raw_string)
 
-      time_low = (integer >> 96) & 0xFFFFFFFF
-      time_mid = (integer >> 80) & 0xFFFF
-      time_hi_and_version = (integer >> 64) & 0xFFFF
-      clock_seq_hi_and_reserved = (integer >> 56) & 0xFF
-      clock_seq_low = (integer >> 48) & 0xFF
+      if raw_string.respond_to?(:force_encoding)
+        raw_string.force_encoding(Encoding::ASCII_8BIT)
+      end
+
+      raw_length = raw_string.length
+      if raw_length < 16
+        # Option A: Enforce raw_string be 16 characters (More strict)
+        #raise ArgumentError,
+        #  "Expected 16 bytes, got #{raw_string.length} instead."
+
+        # Option B: Pad raw_string to 16 characters (Compatible with existing behavior)
+        raw_string = raw_string.rjust(16, "\0")
+      elsif raw_length > 16
+        # NOTE: As per "Option B" above, existing behavior would use the lower
+        # 128-bits of an overly long raw_string instead of using the upper 128-bits.
+        start_index = raw_length - 16
+        raw_string = raw_string[start_index...raw_length]
+      end
+
+      raw_bytes = []
+      if raw_string[0].respond_to? :ord
+        for i in 0...raw_string.size
+          raw_bytes << raw_string[i].ord
+        end
+      else
+        raw_bytes = raw_string
+      end
+
+      time_low = ((raw_bytes[0] << 24) +
+                  (raw_bytes[1] << 16)  +
+                  (raw_bytes[2] << 8)  +
+                   raw_bytes[3])
+      time_mid = ((raw_bytes[4] << 8) +
+                   raw_bytes[5])
+      time_hi_and_version = ((raw_bytes[6] << 8) +
+                              raw_bytes[7])
+      clock_seq_hi_and_reserved = raw_bytes[8]
+      clock_seq_low = raw_bytes[9]
       nodes = []
-      for i in 0..5
-        nodes << ((integer >> (40 - (i * 8))) & 0xFF)
+      for i in 10...16
+        nodes << raw_bytes[i]
       end
+
       return self.new(time_low, time_mid, time_hi_and_version,
-        clock_seq_hi_and_reserved, clock_seq_low, nodes)
+                      clock_seq_hi_and_reserved, clock_seq_low, nodes)
     end
 
     ##
@@ -200,17 +233,42 @@ module UUIDTools
         raise ArgumentError,
           "Expected Integer, got #{uuid_int.class.name} instead."
       end
-      return self.parse_raw(self.convert_int_to_byte_string(uuid_int, 16))
+
+      time_low = (uuid_int >> 96) & 0xFFFFFFFF
+      time_mid = (uuid_int >> 80) & 0xFFFF
+      time_hi_and_version = (uuid_int >> 64) & 0xFFFF
+      clock_seq_hi_and_reserved = (uuid_int >> 56) & 0xFF
+      clock_seq_low = (uuid_int >> 48) & 0xFF
+      nodes = []
+      for i in 0..5
+        nodes << ((uuid_int >> (40 - (i * 8))) & 0xFF)
+      end
+
+      return self.new(time_low, time_mid, time_hi_and_version,
+                      clock_seq_hi_and_reserved, clock_seq_low, nodes)
     end
 
     ##
     # Parse a UUID from a hexdigest String.
-    def self.parse_hexdigest(uuid_hexdigest)
-      unless uuid_hexdigest.kind_of?(String)
+    def self.parse_hexdigest(uuid_hex)
+      unless uuid_hex.kind_of?(String)
         raise ArgumentError,
-          "Expected String, got #{uuid_hexdigest.class.name} instead."
+          "Expected String, got #{uuid_hex.class.name} instead."
+      end
+
+      time_low = uuid_hex[0...8].to_i(16)
+      time_mid = uuid_hex[8...12].to_i(16)
+      time_hi_and_version = uuid_hex[12...16].to_i(16)
+      clock_seq_hi_and_reserved = uuid_hex[16...18].to_i(16)
+      clock_seq_low = uuid_hex[18...20].to_i(16)
+      nodes_string = uuid_hex[20...32]
+      nodes = []
+      for i in 0..5
+        nodes << nodes_string[(i * 2)..(i * 2) + 1].to_i(16)
       end
-      return self.parse_int(uuid_hexdigest.to_i(16))
+
+      return self.new(time_low, time_mid, time_hi_and_version,
+                      clock_seq_hi_and_reserved, clock_seq_low, nodes)
     end
 
     ##
@@ -249,7 +307,7 @@ module UUIDTools
           nodes = SecureRandom.random_bytes(6).unpack("C*")
           nodes[0] |= 0b00000001
         end
-        for i in 0..5
+        6.times do |i|
           node_id += (nodes[i] << (40 - (i * 8)))
         end
         clock_sequence = @@last_clock_sequence
@@ -358,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
 
     ##
@@ -405,7 +458,7 @@ module UUIDTools
       return check if check != 0
       check = self.clock_seq_low <=> other_uuid.clock_seq_low
       return check if check != 0
-      for i in 0..5
+      6.times do |i|
         if (self.nodes[i] < other_uuid.nodes[i])
           return -1
         end
@@ -486,7 +539,7 @@ module UUIDTools
         bytes = (time_low << 96) + (time_mid << 80) +
           (time_hi_and_version << 64) + (clock_seq_hi_and_reserved << 56) +
           (clock_seq_low << 48)
-        for i in 0..5
+        6.times do |i|
           bytes += (nodes[i] << (40 - (i * 8)))
         end
         bytes
@@ -500,7 +553,7 @@ module UUIDTools
     def generate_s
       result = sprintf("%8.8x-%4.4x-%4.4x-%2.2x%2.2x-", @time_low, @time_mid,
         @time_hi_and_version, @clock_seq_hi_and_reserved, @clock_seq_low);
-      for i in 0..5
+      6.times do |i|
         result << sprintf("%2.2x", @nodes[i])
       end
       return result.downcase
@@ -527,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
 
@@ -565,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(":")})"),
@@ -621,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
@@ -695,11 +776,11 @@ 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
-      for i in 0..(size - 1)
+      size.times do |i|
         byte_string << ((integer >> (((size - 1) - i) * 8)) & 0xFF)
       end
       return byte_string
@@ -711,21 +792,27 @@ module UUIDTools
       if byte_string.respond_to?(:force_encoding)
         byte_string.force_encoding(Encoding::ASCII_8BIT)
       end
+
       integer = 0
       size = byte_string.size
-      for i in 0..(size - 1)
-        ordinal = (byte_string[i].respond_to?(:ord) ?
-          byte_string[i].ord : byte_string[i])
-        integer += (ordinal << (((size - 1) - i) * 8))
+      if byte_string[0].respond_to? :ord
+        for i in 0...size
+          integer += (byte_string[i].ord << (((size - 1) - i) * 8))
+        end
+      else
+        for i in 0...size
+          integer += (byte_string[i] << (((size - 1) - i) * 8))
+        end
       end
+      
       return integer
     end
   end
 
   ##
   # 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
@@ -94,7 +111,7 @@ describe UUIDTools::UUID, "when parsing" do
   it "should produce a sane hash value for a UUID" do
     uuid = UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])
     expect(uuid.to_i).to eql(0)
-    expect(uuid.hash).to be_kind_of(Fixnum)
+    expect(uuid.hash).to be_kind_of(Integer)
   end
 
   it "should produce the correct URI for a UUID" do
@@ -125,4 +142,24 @@ describe UUIDTools::UUID, "when parsing" do
     uuid = UUIDTools::UUID.timestamp_create
     expect(UUIDTools::UUID.parse_hexdigest(uuid.hexdigest)).to eql(uuid)
   end
+
+  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(+"")
+    )
+
+    # 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
+
+    # NOTE: Realistic Input
+    uuid = UUIDTools::UUID.timestamp_create
+    expect(UUIDTools::UUID.parse_raw(uuid.raw)).to eql(uuid)
+
+    # NOTE: Long input
+    raw192bit = "\1\2\3\4\5\6\7\8" + uuid.raw
+    expect(UUIDTools::UUID.parse_raw(raw192bit)).to eql(uuid)
+  end
 end

data/tasks/benchmark.rake

@@ -1,38 +1,57 @@
 task :benchmark do
-  require 'lib/uuidtools'
   require 'benchmark'
 
-  # Version 1
-  result = Benchmark.measure do
-    10000.times do
-      UUID.timestamp_create.to_s
-    end
-  end
-  puts "#{(10000.0 / result.real)} version 1 per second."
+  $LOAD_PATH.unshift File.expand_path('../..', __FILE__)
+  require 'lib/uuidtools'
 
-  # Version 3
-  result = Benchmark.measure do
-    10000.times do
-      UUID.md5_create(UUID_URL_NAMESPACE,
-        "http://www.ietf.org/rfc/rfc4122.txt").to_s
-    end
+  def format_float(float)
+    ("%.2f" % float).rjust(9, ' ')
   end
-  puts "#{(10000.0 / result.real)} version 3 per second."
 
-  # Version 4
-  result = Benchmark.measure do
-    10000.times do
-      UUID.random_create.to_s
-    end
+  def format_result(result, action, iterations)
+    $stdout.puts "#{format_float(iterations / result.real)} | #{action}"
   end
-  puts "#{(10000.0 / result.real)} version 4 per second."
 
-  # Version 5
-  result = Benchmark.measure do
-    10000.times do
-      UUID.sha1_create(UUID_URL_NAMESPACE,
-        "http://www.ietf.org/rfc/rfc4122.txt").to_s
+  def benchmark(name, n = 10000)
+    result = Benchmark.measure do
+      n.times { yield }
     end
+
+    format_result(result, name, n)
   end
-  puts "#{(10000.0 / result.real)} version 5 per second."
+
+  $stdout.puts ' x/second | Benchmark'
+  $stdout.puts '---------- -----------'
+
+  ##
+  # Benchmark UUID creation
+  namespace = UUIDTools::UUID_URL_NAMESPACE
+  url = "http://www.ietf.org/rfc/rfc4122.txt"
+
+  benchmark('Version 1') { UUIDTools::UUID.timestamp_create.to_s }
+  benchmark('Version 3') { UUIDTools::UUID.md5_create(namespace, url).to_s }
+  benchmark('Version 4') { UUIDTools::UUID.random_create.to_s }
+  benchmark('Version 5') { UUIDTools::UUID.sha1_create(namespace, url).to_s }
+
+  ## 
+  # Benchmark UUID parsing
+  uuid_s = UUIDTools::UUID.random_create.to_s
+  benchmark('UUID::parse', 40000) { UUIDTools::UUID.parse(uuid_s) }
+
+  uuid_raw = UUIDTools::UUID.random_create.raw
+  benchmark('UUID::parse_raw', 40000) { UUIDTools::UUID.parse_raw(uuid_raw) }
+
+  uuid_i = UUIDTools::UUID.random_create.to_i
+  benchmark('UUID::parse_int', 40000) { UUIDTools::UUID.parse_int(uuid_i) }
+
+  uuid_hex = UUIDTools::UUID.random_create.hexdigest
+  benchmark('UUID::parse_hexdigest', 40000) { UUIDTools::UUID.parse_hexdigest(uuid_hex) }
+
+  ##
+  # Benchmark UUID private api
+  byte_string = UUIDTools::UUID.timestamp_create.raw
+  benchmark('UUID::convert_byte_string_to_int') { UUIDTools::UUID.convert_byte_string_to_int(byte_string) }
+
+  bigint = UUIDTools::UUID.timestamp_create.to_i
+  benchmark('UUID::convert_int_to_byte_string') { UUIDTools::UUID.convert_int_to_byte_string(bigint, 16) }
 end

data/tasks/gem.rake

@@ -10,6 +10,7 @@ namespace :gem do
     s.version = PKG_VERSION
     s.summary = PKG_SUMMARY
     s.description = PKG_DESCRIPTION
+    s.licenses = ["Apache-2.0"]
 
     s.files = PKG_FILES.to_a
 
@@ -43,14 +44,8 @@ namespace :gem do
   task :gemspec do
     spec_string = GEM_SPEC.to_ruby
 
-    begin
-      Thread.new { eval("$SAFE = 3\n#{spec_string}", binding) }.join
-    rescue
-      abort "unsafe gemspec: #{$!}"
-    else
-      File.open("#{GEM_SPEC.name}.gemspec", 'w') do |file|
-        file.write spec_string
-      end
+    File.open("#{GEM_SPEC.name}.gemspec", "w") do |file|
+      file.write spec_string
     end
   end
 

data/uuidtools.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+# stub: uuidtools 3.0.0 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "uuidtools".freeze
+  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 = "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, "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.6.3".freeze
+  s.summary = "UUID generator".freeze
+
+  s.specification_version = 4
+
+  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.1.5
+  version: 3.0.0
 platform: ruby
 authors:
 - Bob Aman
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-12 00:00:00.000000000 Z
+date: 2025-03-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -66,8 +65,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.0.0
-description: |
-  A simple universally unique ID generation library.
+description: 'A simple universally unique ID generation library.
+
+  '
 email: bob@sporkmonger.com
 executables: []
 extensions: []
@@ -93,11 +93,12 @@ files:
 - tasks/metrics.rake
 - tasks/rspec.rake
 - tasks/yard.rake
+- uuidtools.gemspec
 - website/index.html
 homepage: https://github.com/sporkmonger/uuidtools
-licenses: []
+licenses:
+- Apache-2.0
 metadata: {}
-post_install_message: 
 rdoc_options:
 - "--main"
 - README.md
@@ -114,9 +115,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.2
-signing_key: 
+rubygems_version: 3.6.3
 specification_version: 4
 summary: UUID generator
 test_files: []