uuidtools 2.1.1 → 2.2.0

data/spec/uuidtools/utility_spec.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), "../spec_helper.rb")
+require File.expand_path("../../spec_helper.rb", __FILE__)
 
 describe SecureRandom do
   it "should correctly obtain random bits" do
@@ -7,15 +7,15 @@ describe SecureRandom do
       bits << SecureRandom.random_bytes(16)
     end
     # Check to make sure that none of the 10,000 strings were duplicates
-    (bits.map {|x| x.to_s}).uniq.size.should == bits.size
+    expect((bits.map {|x| x.to_s}).uniq.size).to eql(bits.size)
   end
 
   it "should return the correct number of random bits" do
-    SecureRandom.random_bytes(16).size.should == 16
-    SecureRandom.random_bytes(6).size.should == 6
+    expect(SecureRandom.random_bytes(16).size).to eql(16)
+    expect(SecureRandom.random_bytes(6).size).to eql(6)
   end
 
   it "should return a sane random number" do
-    SecureRandom.random_number(5000).should < 5000
+    expect(SecureRandom.random_number(5000)).to be < 5000
   end
 end

data/spec/uuidtools/uuid_creation_spec.rb

@@ -1,37 +1,39 @@
-require File.join(File.dirname(__FILE__), "../spec_helper.rb")
+require File.expand_path("../../spec_helper.rb", __FILE__)
 
 describe UUIDTools::UUID, "when generating" do
   it "should correctly generate SHA1 variant UUIDs" do
-    UUIDTools::UUID.sha1_create(
+    expect(UUIDTools::UUID.sha1_create(
       UUIDTools::UUID_URL_NAMESPACE, 'http://sporkmonger.com'
-    ).to_s.should == "f2d04685-b787-55da-8644-9bd28a6f5a53"
+    ).to_s).to eql('f2d04685-b787-55da-8644-9bd28a6f5a53')
   end
 
   it "should correctly generate MD5 variant UUIDs" do
-    UUIDTools::UUID.md5_create(
+    expect(UUIDTools::UUID.md5_create(
       UUIDTools::UUID_URL_NAMESPACE, 'http://sporkmonger.com'
-    ).to_s.should == "15074785-9071-3fe3-89bd-876e4b9e919b"
+    ).to_s).to eql('15074785-9071-3fe3-89bd-876e4b9e919b')
   end
 
   it "should correctly generate timestamp variant UUIDs" do
-    UUIDTools::UUID.timestamp_create.should_not be_random_node_id
-    UUIDTools::UUID.timestamp_create.to_s.should_not ==
+    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
+    )
     current_time = Time.now
-    UUIDTools::UUID.timestamp_create(current_time).to_s.should_not ==
+    expect(UUIDTools::UUID.timestamp_create(current_time).to_s).not_to eql(
       UUIDTools::UUID.timestamp_create(current_time).to_s
+    )
     uuids = []
     1000.times do
       uuids << UUIDTools::UUID.timestamp_create
     end
     # Check to make sure that none of the 1,000 UUIDs were duplicates
-    (uuids.map {|x| x.to_s}).uniq.size.should == uuids.size
+    expect((uuids.map {|x| x.to_s}).uniq.size).to eql(uuids.size)
   end
 
   it "should correctly generate UUIDs without a MAC address" do
     mac_address = UUIDTools::UUID.mac_address
     UUIDTools::UUID.mac_address = nil
-    UUIDTools::UUID.timestamp_create.should be_random_node_id
+    expect(UUIDTools::UUID.timestamp_create).to be_random_node_id
     UUIDTools::UUID.mac_address = mac_address
   end
 
@@ -41,81 +43,88 @@ describe UUIDTools::UUID, "when generating" do
       uuids << UUIDTools::UUID.random_create
     end
     # Check to make sure that none of the 1,000 UUIDs were duplicates
-    (uuids.map {|x| x.to_s}).uniq.size.should == uuids.size
+    expect((uuids.map {|x| x.to_s}).uniq.size).to eql(uuids.size)
+  end
+
+  it "should not have internal state used in string representations" do
+    uuid = UUIDTools::UUID.random_create
+    uuid_string = uuid.to_s.dup
+    uuid.to_s.gsub!("-", "/")
+    expect(uuid.to_s).to eql(uuid_string)
   end
 
   it "should throw an exception if a segment has an invalid value" do
-    (lambda do
+    expect(lambda do
       UUIDTools::UUID.new(-1, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])
-    end).should raise_error(ArgumentError)
-    (lambda do
+    end).to raise_error(ArgumentError)
+    expect(lambda do
       UUIDTools::UUID.new(4294967296, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])
-    end).should raise_error(ArgumentError)
+    end).to raise_error(ArgumentError)
   end
 
   it "should throw an exception if a segment has an invalid value" do
-    (lambda do
+    expect(lambda do
       UUIDTools::UUID.new(0, -1, 0, 0, 0, [0, 0, 0, 0, 0, 0])
-    end).should raise_error(ArgumentError)
-    (lambda do
+    end).to raise_error(ArgumentError)
+    expect(lambda do
       UUIDTools::UUID.new(0, 65536, 0, 0, 0, [0, 0, 0, 0, 0, 0])
-    end).should raise_error(ArgumentError)
+    end).to raise_error(ArgumentError)
   end
 
   it "should throw an exception if a segment has an invalid value" do
-    (lambda do
+    expect(lambda do
       UUIDTools::UUID.new(0, 0, -1, 0, 0, [0, 0, 0, 0, 0, 0])
-    end).should raise_error(ArgumentError)
-    (lambda do
+    end).to raise_error(ArgumentError)
+    expect(lambda do
       UUIDTools::UUID.new(0, 0, 65536, 0, 0, [0, 0, 0, 0, 0, 0])
-    end).should raise_error(ArgumentError)
+    end).to raise_error(ArgumentError)
   end
 
   it "should throw an exception if a segment has an invalid value" do
-    (lambda do
+    expect(lambda do
       UUIDTools::UUID.new(0, 0, 0, -1, 0, [0, 0, 0, 0, 0, 0])
-    end).should raise_error(ArgumentError)
-    (lambda do
+    end).to raise_error(ArgumentError)
+    expect(lambda do
       UUIDTools::UUID.new(0, 0, 0, 256, 0, [0, 0, 0, 0, 0, 0])
-    end).should raise_error(ArgumentError)
+    end).to raise_error(ArgumentError)
   end
 
   it "should throw an exception if a segment has an invalid value" do
-    (lambda do
+    expect(lambda do
       UUIDTools::UUID.new(0, 0, 0, 0, -1, [0, 0, 0, 0, 0, 0])
-    end).should raise_error(ArgumentError)
-    (lambda do
+    end).to raise_error(ArgumentError)
+    expect(lambda do
       UUIDTools::UUID.new(0, 0, 0, 0, 256, [0, 0, 0, 0, 0, 0])
-    end).should raise_error(ArgumentError)
+    end).to raise_error(ArgumentError)
   end
 
   it "should throw an exception if nodes are not a collection" do
-    (lambda do
+    expect(lambda do
       UUIDTools::UUID.new(0, 0, 0, 0, 0, :bogus)
-    end).should raise_error(TypeError)
+    end).to raise_error(TypeError)
   end
 
   it "should throw an exception if nodes are the wrong size" do
-    (lambda do
+    expect(lambda do
       UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0])
-    end).should raise_error(ArgumentError)
+    end).to raise_error(ArgumentError)
   end
 
   it "should throw an exception if any nodes have invalid values" do
-    (lambda do
+    expect(lambda do
       UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 256])
-    end).should raise_error(ArgumentError)
+    end).to raise_error(ArgumentError)
   end
 
   it "should throw an exception if parsing anything but a String" do
-    (lambda do
+    expect(lambda do
       UUIDTools::UUID.parse(:bogus)
-    end).should raise_error(TypeError)
+    end).to raise_error(TypeError)
   end
 
   it "should throw an exception if raw parsing anything but a String" do
-    (lambda do
+    expect(lambda do
       UUIDTools::UUID.parse_raw(:bogus)
-    end).should raise_error(TypeError)
+    end).to raise_error(TypeError)
   end
 end

data/spec/uuidtools/uuid_parsing_spec.rb

@@ -1,66 +1,67 @@
-require File.join(File.dirname(__FILE__), "../spec_helper.rb")
+require File.expand_path("../../spec_helper.rb", __FILE__)
 
 describe UUIDTools::UUID, "when parsing" do
   it "should correctly parse the MAC address from a timestamp version UUID" do
-    UUIDTools::UUID.timestamp_create.mac_address.should ==
+    expect(UUIDTools::UUID.timestamp_create.mac_address).to eql(
       UUIDTools::UUID.mac_address
+    )
   end
 
   it "should correctly parse the variant from a timestamp version UUID" do
-    UUIDTools::UUID.timestamp_create.variant.should == 0b100
+    expect(UUIDTools::UUID.timestamp_create.variant).to eql(0b100)
   end
 
   it "should correctly parse the version from a timestamp version UUID" do
-    UUIDTools::UUID.timestamp_create.version.should == 1
+    expect(UUIDTools::UUID.timestamp_create.version).to eql(1)
   end
 
   it "should correctly parse the timestamp from a timestamp version UUID" do
-    UUIDTools::UUID.timestamp_create.timestamp.should < Time.now + 1
-    UUIDTools::UUID.timestamp_create.timestamp.should > Time.now - 1
+    expect(UUIDTools::UUID.timestamp_create.timestamp).to be < (Time.now + 1)
+    expect(UUIDTools::UUID.timestamp_create.timestamp).to be > (Time.now - 1)
   end
 
   it "should not treat a timestamp version UUID as a nil UUID" do
-    UUIDTools::UUID.timestamp_create.should_not be_nil_uuid
+    expect(UUIDTools::UUID.timestamp_create).not_to be_nil_uuid
   end
 
   it "should not treat a timestamp version UUID as a random node UUID" do
-    UUIDTools::UUID.timestamp_create.should_not be_random_node_id
+    expect(UUIDTools::UUID.timestamp_create).not_to be_random_node_id
   end
 
   it "should treat a timestamp version UUID as a random node UUID " +
       "if there is no MAC address" do
     old_mac_address = UUIDTools::UUID.mac_address
     UUIDTools::UUID.mac_address = nil
-    UUIDTools::UUID.timestamp_create.should be_random_node_id
+    expect(UUIDTools::UUID.timestamp_create).to be_random_node_id
     UUIDTools::UUID.mac_address = old_mac_address
   end
 
   it "should correctly identify the nil UUID" do
-    UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).should be_nil_uuid
+    expect(UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])).to be_nil_uuid
   end
 
   it "should correctly identify timestamp version UUIDs as valid" do
-    UUIDTools::UUID.timestamp_create.should be_valid
+    expect(UUIDTools::UUID.timestamp_create).to be_valid
   end
 
   it "should correctly identify random number version UUIDs as valid" do
-    UUIDTools::UUID.random_create.should be_valid
+    expect(UUIDTools::UUID.random_create).to be_valid
   end
 
   it "should correctly identify SHA1 hash version UUIDs as valid" do
-    UUIDTools::UUID.sha1_create(
+    expect(UUIDTools::UUID.sha1_create(
       UUIDTools::UUID_URL_NAMESPACE, 'http://sporkmonger.com'
-    ).should be_valid
+    )).to be_valid
   end
 
   it "should correctly identify MD5 hash version UUIDs as valid" do
-    UUIDTools::UUID.md5_create(
+    expect(UUIDTools::UUID.md5_create(
       UUIDTools::UUID_URL_NAMESPACE, 'http://sporkmonger.com'
-    ).should be_valid
+    )).to be_valid
   end
 
   it "should not identify the nil UUID as valid" do
-    UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).should_not be_valid
+    expect(UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])).not_to be_valid
   end
 
   it "should allow for sorting of UUID arrays" do
@@ -69,59 +70,78 @@ describe UUIDTools::UUID, "when parsing" do
       uuids << UUIDTools::UUID.timestamp_create
     end
     uuids.sort!
-    uuids.first.should < uuids.last
-    uuids.last.should > uuids.first
+    expect(uuids.first).to be < uuids.last
+    expect(uuids.last).to be > uuids.first
   end
 
   it "should allow for comparison of UUIDs" do
-    UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).should <
+    expect(UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])).to be <
       UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 1])
-    UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 1]).should >
-      UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])
-    UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).should ==
+    expect(UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 1])).to be >
       UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])
+    expect(UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])).to eql(
+      UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]))
   end
 
   it "should produce the correct hexdigest for a UUID" do
-    UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).hexdigest.should ==
-      "00000000000000000000000000000000"
-    UUIDTools::UUID.new(1, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).hexdigest.should ==
-      "00000001000000000000000000000000"
-    UUIDTools::UUID.timestamp_create.hexdigest.size.should == 32
+    expect(UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).hexdigest).to eql(
+      '00000000000000000000000000000000')
+    expect(UUIDTools::UUID.new(1, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).hexdigest).to eql(
+      '00000001000000000000000000000000')
+    expect(UUIDTools::UUID.timestamp_create.hexdigest.size).to eql(32)
   end
 
   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])
-    uuid.to_i.should == 0
-    uuid.hash.should be_kind_of(Fixnum)
+    expect(uuid.to_i).to eql(0)
+    expect(uuid.hash).to be_kind_of(Integer)
   end
 
   it "should produce the correct URI for a UUID" do
-    UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).to_uri.should ==
-      "urn:uuid:00000000-0000-0000-0000-000000000000"
+    expect(UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).to_uri).to eql(
+      'urn:uuid:00000000-0000-0000-0000-000000000000')
   end
 
   it "should correctly test UUID equality" do
-    UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).should be_eql(
+    expect(UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])).to eql(
       UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])
     )
   end
 
   it "should correctly parse integers" do
-    UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).should ==
-      UUIDTools::UUID.parse_int(0)
-    UUIDTools::UUID.parse_int(0).should be_nil_uuid
+    expect(UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])).to eql(
+      UUIDTools::UUID.parse_int(0))
+    expect(UUIDTools::UUID.parse_int(0)).to be_nil_uuid
     uuid = UUIDTools::UUID.timestamp_create
-    UUIDTools::UUID.parse_int(uuid.to_i).should == uuid
+    expect(UUIDTools::UUID.parse_int(uuid.to_i)).to eql(uuid)
   end
 
   it "should correctly parse hexdigests" do
-    UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).should ==
-      UUIDTools::UUID.parse_hexdigest("00000000000000000000000000000000")
-    UUIDTools::UUID.parse_hexdigest(
-      "00000000000000000000000000000000"
-    ).should be_nil_uuid
+    expect(UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])).to eql(
+      UUIDTools::UUID.parse_hexdigest('00000000000000000000000000000000'))
+    expect(UUIDTools::UUID.parse_hexdigest(
+      '00000000000000000000000000000000'
+    )).to be_nil_uuid
+    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
-    UUIDTools::UUID.parse_hexdigest(uuid.hexdigest).should == uuid
+    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