uuidtools 1.0.7 → 2.0.0

data/lib/uuidtools/version.rb

@@ -25,9 +25,9 @@
 unless defined? UUID::VERSION
   class UUID
     module VERSION #:nodoc:
-      MAJOR = 1
+      MAJOR = 2
       MINOR = 0
-      TINY  = 7
+      TINY  = 0
 
       STRING = [MAJOR, MINOR, TINY].join('.')
     end

data/spec/uuidtools/mac_address_spec.rb

@@ -1,8 +1,8 @@
 require File.join(File.dirname(__FILE__), "../spec_helper.rb")
 
-describe UUID, "when obtaining a MAC address" do
+describe UUIDTools::UUID, "when obtaining a MAC address" do
   before do
-    @mac_address = UUID.mac_address
+    @mac_address = UUIDTools::UUID.mac_address
   end
 
   it "should obtain a MAC address" do
@@ -10,6 +10,6 @@ describe UUID, "when obtaining a MAC address" do
   end
 
   it "should cache the MAC address" do
-    @mac_address.object_id.should == UUID.mac_address.object_id
+    @mac_address.object_id.should == UUIDTools::UUID.mac_address.object_id
   end
 end

data/spec/uuidtools/uuid_creation_spec.rb

@@ -1,43 +1,44 @@
 require File.join(File.dirname(__FILE__), "../spec_helper.rb")
 
-describe UUID, "when generating" do
+describe UUIDTools::UUID, "when generating" do
   it "should correctly generate SHA1 variant UUIDs" do
-    UUID.sha1_create(
-      UUID_URL_NAMESPACE, 'http://sporkmonger.com'
+    UUIDTools::UUID.sha1_create(
+      UUIDTools::UUID_URL_NAMESPACE, 'http://sporkmonger.com'
     ).to_s.should == "f2d04685-b787-55da-8644-9bd28a6f5a53"
   end
 
   it "should correctly generate MD5 variant UUIDs" do
-    UUID.md5_create(
-      UUID_URL_NAMESPACE, 'http://sporkmonger.com'
+    UUIDTools::UUID.md5_create(
+      UUIDTools::UUID_URL_NAMESPACE, 'http://sporkmonger.com'
     ).to_s.should == "15074785-9071-3fe3-89bd-876e4b9e919b"
   end
 
   it "should correctly generate timestamp variant UUIDs" do
-    UUID.timestamp_create.should_not be_random_node_id
-    UUID.timestamp_create.to_s.should_not == UUID.timestamp_create.to_s
+    UUIDTools::UUID.timestamp_create.should_not be_random_node_id
+    UUIDTools::UUID.timestamp_create.to_s.should_not ==
+      UUIDTools::UUID.timestamp_create.to_s
     current_time = Time.now
-    UUID.timestamp_create(current_time).to_s.should_not ==
-      UUID.timestamp_create(current_time).to_s
+    UUIDTools::UUID.timestamp_create(current_time).to_s.should_not ==
+      UUIDTools::UUID.timestamp_create(current_time).to_s
     uuids = []
     1000.times do
-      uuids << UUID.timestamp_create
+      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
   end
 
   it "should correctly generate UUIDs without a MAC address" do
-    mac_address = UUID.mac_address
-    UUID.mac_address = nil
-    UUID.timestamp_create.should be_random_node_id
-    UUID.mac_address = mac_address
+    mac_address = UUIDTools::UUID.mac_address
+    UUIDTools::UUID.mac_address = nil
+    UUIDTools::UUID.timestamp_create.should be_random_node_id
+    UUIDTools::UUID.mac_address = mac_address
   end
 
   it "should correctly generate random number variant UUIDs" do
     uuids = []
     1000.times do
-      uuids << UUID.random_create
+      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
@@ -45,76 +46,76 @@ describe UUID, "when generating" do
 
   it "should throw an exception if a segment has an invalid value" do
     (lambda do
-      UUID.new(-1, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])
+      UUIDTools::UUID.new(-1, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])
     end).should raise_error(ArgumentError)
     (lambda do
-      UUID.new(4294967296, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])
+      UUIDTools::UUID.new(4294967296, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])
     end).should raise_error(ArgumentError)
   end
 
   it "should throw an exception if a segment has an invalid value" do
     (lambda do
-      UUID.new(0, -1, 0, 0, 0, [0, 0, 0, 0, 0, 0])
+      UUIDTools::UUID.new(0, -1, 0, 0, 0, [0, 0, 0, 0, 0, 0])
     end).should raise_error(ArgumentError)
     (lambda do
-      UUID.new(0, 65536, 0, 0, 0, [0, 0, 0, 0, 0, 0])
+      UUIDTools::UUID.new(0, 65536, 0, 0, 0, [0, 0, 0, 0, 0, 0])
     end).should raise_error(ArgumentError)
   end
 
   it "should throw an exception if a segment has an invalid value" do
     (lambda do
-      UUID.new(0, 0, -1, 0, 0, [0, 0, 0, 0, 0, 0])
+      UUIDTools::UUID.new(0, 0, -1, 0, 0, [0, 0, 0, 0, 0, 0])
     end).should raise_error(ArgumentError)
     (lambda do
-      UUID.new(0, 0, 65536, 0, 0, [0, 0, 0, 0, 0, 0])
+      UUIDTools::UUID.new(0, 0, 65536, 0, 0, [0, 0, 0, 0, 0, 0])
     end).should raise_error(ArgumentError)
   end
 
   it "should throw an exception if a segment has an invalid value" do
     (lambda do
-      UUID.new(0, 0, 0, -1, 0, [0, 0, 0, 0, 0, 0])
+      UUIDTools::UUID.new(0, 0, 0, -1, 0, [0, 0, 0, 0, 0, 0])
     end).should raise_error(ArgumentError)
     (lambda do
-      UUID.new(0, 0, 0, 256, 0, [0, 0, 0, 0, 0, 0])
+      UUIDTools::UUID.new(0, 0, 0, 256, 0, [0, 0, 0, 0, 0, 0])
     end).should raise_error(ArgumentError)
   end
 
   it "should throw an exception if a segment has an invalid value" do
     (lambda do
-      UUID.new(0, 0, 0, 0, -1, [0, 0, 0, 0, 0, 0])
+      UUIDTools::UUID.new(0, 0, 0, 0, -1, [0, 0, 0, 0, 0, 0])
     end).should raise_error(ArgumentError)
     (lambda do
-      UUID.new(0, 0, 0, 0, 256, [0, 0, 0, 0, 0, 0])
+      UUIDTools::UUID.new(0, 0, 0, 0, 256, [0, 0, 0, 0, 0, 0])
     end).should raise_error(ArgumentError)
   end
 
   it "should throw an exception if nodes are not a collection" do
     (lambda do
-      UUID.new(0, 0, 0, 0, 0, :bogus)
+      UUIDTools::UUID.new(0, 0, 0, 0, 0, :bogus)
     end).should raise_error(TypeError)
   end
 
   it "should throw an exception if nodes are the wrong size" do
     (lambda do
-      UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0])
+      UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0])
     end).should raise_error(ArgumentError)
   end
 
   it "should throw an exception if any nodes have invalid values" do
     (lambda do
-      UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 256])
+      UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 256])
     end).should raise_error(ArgumentError)
   end
 
   it "should throw an exception if parsing anything but a String" do
     (lambda do
-      UUID.parse(:bogus)
+      UUIDTools::UUID.parse(:bogus)
     end).should raise_error(TypeError)
   end
 
   it "should throw an exception if raw parsing anything but a String" do
     (lambda do
-      UUID.parse_raw(:bogus)
+      UUIDTools::UUID.parse_raw(:bogus)
     end).should raise_error(TypeError)
   end
 end

data/spec/uuidtools/uuid_parsing_spec.rb

@@ -1,71 +1,72 @@
 require File.join(File.dirname(__FILE__), "../spec_helper.rb")
 
-describe UUID, "when parsing" do
+describe UUIDTools::UUID, "when parsing" do
   it "should correctly parse the MAC address from a timestamp version UUID" do
-    UUID.timestamp_create.mac_address.should == UUID.mac_address
+    UUIDTools::UUID.timestamp_create.mac_address.should ==
+      UUIDTools::UUID.mac_address
   end
 
   it "should correctly parse the variant from a timestamp version UUID" do
-    UUID.timestamp_create.variant.should == 0b100
+    UUIDTools::UUID.timestamp_create.variant.should == 0b100
   end
 
   it "should correctly parse the version from a timestamp version UUID" do
-    UUID.timestamp_create.version.should == 1
+    UUIDTools::UUID.timestamp_create.version.should == 1
   end
 
   it "should correctly parse the timestamp from a timestamp version UUID" do
-    UUID.timestamp_create.timestamp.should < Time.now + 1
-    UUID.timestamp_create.timestamp.should > Time.now - 1
+    UUIDTools::UUID.timestamp_create.timestamp.should < Time.now + 1
+    UUIDTools::UUID.timestamp_create.timestamp.should > Time.now - 1
   end
 
   it "should not treat a timestamp version UUID as a nil UUID" do
-    UUID.timestamp_create.should_not be_nil_uuid
+    UUIDTools::UUID.timestamp_create.should_not be_nil_uuid
   end
 
   it "should not treat a timestamp version UUID as a random node UUID" do
-    UUID.timestamp_create.should_not be_random_node_id
+    UUIDTools::UUID.timestamp_create.should_not 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 = UUID.mac_address
-    UUID.mac_address = nil
-    UUID.timestamp_create.should be_random_node_id
-    UUID.mac_address = old_mac_address
+    old_mac_address = UUIDTools::UUID.mac_address
+    UUIDTools::UUID.mac_address = nil
+    UUIDTools::UUID.timestamp_create.should be_random_node_id
+    UUIDTools::UUID.mac_address = old_mac_address
   end
 
   it "should correctly identify the nil UUID" do
-    UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).should be_nil_uuid
+    UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).should be_nil_uuid
   end
 
   it "should correctly identify timestamp version UUIDs as valid" do
-    UUID.timestamp_create.should be_valid
+    UUIDTools::UUID.timestamp_create.should be_valid
   end
 
   it "should correctly identify random number version UUIDs as valid" do
-    UUID.random_create.should be_valid
+    UUIDTools::UUID.random_create.should be_valid
   end
 
   it "should correctly identify SHA1 hash version UUIDs as valid" do
-    UUID.sha1_create(
-      UUID_URL_NAMESPACE, 'http://sporkmonger.com'
+    UUIDTools::UUID.sha1_create(
+      UUIDTools::UUID_URL_NAMESPACE, 'http://sporkmonger.com'
     ).should be_valid
   end
 
   it "should correctly identify MD5 hash version UUIDs as valid" do
-    UUID.md5_create(
-      UUID_URL_NAMESPACE, 'http://sporkmonger.com'
+    UUIDTools::UUID.md5_create(
+      UUIDTools::UUID_URL_NAMESPACE, 'http://sporkmonger.com'
     ).should be_valid
   end
 
   it "should not identify the nil UUID as valid" do
-    UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).should_not be_valid
+    UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).should_not be_valid
   end
 
   it "should allow for sorting of UUID arrays" do
     uuids = []
     1000.times do
-      uuids << UUID.timestamp_create
+      uuids << UUIDTools::UUID.timestamp_create
     end
     uuids.sort!
     uuids.first.should < uuids.last
@@ -73,36 +74,36 @@ describe UUID, "when parsing" do
   end
 
   it "should allow for comparison of UUIDs" do
-    UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).should <
-      UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 1])
-    UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 1]).should >
-      UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])
-    UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).should ==
-      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 <
+      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 ==
+      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
-    UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).hexdigest.should ==
+    UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).hexdigest.should ==
       "00000000000000000000000000000000"
-    UUID.new(1, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).hexdigest.should ==
+    UUIDTools::UUID.new(1, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).hexdigest.should ==
       "00000001000000000000000000000000"
-    UUID.timestamp_create.hexdigest.size.should == 32
+    UUIDTools::UUID.timestamp_create.hexdigest.size.should == 32
   end
 
   it "should produce a sane hash value for a UUID" do
-    uuid = UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])
+    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)
   end
 
   it "should produce the correct URI for a UUID" do
-    UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).to_uri.should ==
+    UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).to_uri.should ==
       "urn:uuid:00000000-0000-0000-0000-000000000000"
   end
 
   it "should correctly test UUID equality" do
-    UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).should be_eql(
-      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 be_eql(
+      UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])
     )
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: uuidtools
 version: !ruby/object:Gem::Version 
-  version: 1.0.7
+  version: 2.0.0
 platform: ruby
 authors: 
 - Bob Aman
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-12-04 00:00:00 -05:00
+date: 2009-06-02 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency