uuidtools 1.0.4 → 1.0.5

data/CHANGELOG

@@ -1,3 +1,9 @@
+== UUIDTools 1.0.5
+ * improved specs
+ * fixed minor bugs
+ * better JRuby compatibility
+ * uses securerandom library
+ * updated rake tasks
 == UUIDTools 1.0.4
  * calculates random node id with multicast bit if there is no MAC address
  * uses RSpec instead of Test::Unit

data/Rakefile

@@ -36,7 +36,12 @@ PKG_FILES = FileList[
     "[A-Z]*", "Rakefile"
 ].exclude(/database\.yml/).exclude(/[_\.]git$/)
 
-task :default => "spec:verify"
+RCOV_ENABLED = (RUBY_PLATFORM != "java" && RUBY_VERSION =~ /^1\.8/)
+if RCOV_ENABLED
+  task :default => "spec:verify"
+else
+  task :default => "spec"
+end
 
 WINDOWS = (RUBY_PLATFORM =~ /mswin|win32|mingw|bccwin|cygwin/) rescue false
 SUDO = WINDOWS ? '' : ('sudo' unless ENV['SUDOLESS'])

data/lib/compat/securerandom.rb

@@ -0,0 +1,197 @@
+# = Secure random number generator interface.
+#
+# This library is an interface for secure random number generator which is
+# suitable for generating session key in HTTP cookies, etc.
+#
+# It supports following secure random number generators.
+#
+# * openssl
+# * /dev/urandom
+# * Win32
+#
+# == Example
+#
+# # random hexadecimal string.
+# p SecureRandom.hex(10) #=> "52750b30ffbc7de3b362"
+# p SecureRandom.hex(10) #=> "92b15d6c8dc4beb5f559"
+# p SecureRandom.hex(11) #=> "6aca1b5c58e4863e6b81b8"
+# p SecureRandom.hex(12) #=> "94b2fff3e7fd9b9c391a2306"
+# p SecureRandom.hex(13) #=> "39b290146bea6ce975c37cfc23"
+# ...
+#
+# # random base64 string.
+# p SecureRandom.base64(10) #=> "EcmTPZwWRAozdA=="
+# p SecureRandom.base64(10) #=> "9b0nsevdwNuM/w=="
+# p SecureRandom.base64(10) #=> "KO1nIU+p9DKxGg=="
+# p SecureRandom.base64(11) #=> "l7XEiFja+8EKEtY="
+# p SecureRandom.base64(12) #=> "7kJSM/MzBJI+75j8"
+# p SecureRandom.base64(13) #=> "vKLJ0tXBHqQOuIcSIg=="
+# ...
+#
+# # random binary string.
+# p SecureRandom.random_bytes(10) #=> "\016\t{\370g\310pbr\301"
+# p SecureRandom.random_bytes(10) #=> "\323U\030TO\234\357\020\a\337"
+# ...
+
+begin
+  require 'openssl'
+rescue LoadError
+end
+
+module SecureRandom
+  # SecureRandom.random_bytes generates a random binary string.
+  #
+  # The argument n specifies the length of the result string.
+  #
+  # If n is not specified, 16 is assumed.
+  # It may be larger in future.
+  #
+  # If secure random number generator is not available,
+  # NotImplementedError is raised.
+  def self.random_bytes(n=nil)
+    n ||= 16
+
+    if defined? OpenSSL::Random
+      return OpenSSL::Random.random_bytes(n)
+    end
+
+    if !defined?(@has_urandom) || @has_urandom
+      flags = File::RDONLY
+      flags |= File::NONBLOCK if defined? File::NONBLOCK
+      flags |= File::NOCTTY if defined? File::NOCTTY
+      flags |= File::NOFOLLOW if defined? File::NOFOLLOW
+      begin
+        File.open("/dev/urandom", flags) {|f|
+          unless f.stat.chardev?
+            raise Errno::ENOENT
+          end
+          @has_urandom = true
+          ret = f.readpartial(n)
+          if ret.length != n
+            raise NotImplementedError,
+              "Unexpected partial read from random device"
+          end
+          return ret
+        }
+      rescue Errno::ENOENT
+        @has_urandom = false
+      end
+    end
+
+    if !defined?(@has_win32)
+      begin
+        require 'Win32API'
+
+        crypt_acquire_context = Win32API.new(
+          "advapi32", "CryptAcquireContext", 'PPPII', 'L'
+        )
+        @crypt_gen_random = Win32API.new(
+          "advapi32", "CryptGenRandom", 'LIP', 'L'
+        )
+
+        hProvStr = " " * 4
+        prov_rsa_full = 1
+        crypt_verifycontext = 0xF0000000
+
+        if crypt_acquire_context.call(
+            hProvStr, nil, nil, prov_rsa_full, crypt_verifycontext) == 0
+          raise SystemCallError,
+            "CryptAcquireContext failed: #{lastWin32ErrorMessage}"
+        end
+        @hProv, = hProvStr.unpack('L')
+
+        @has_win32 = true
+      rescue LoadError
+        @has_win32 = false
+      end
+    end
+    if @has_win32
+      bytes = " " * n
+      if @crypt_gen_random.call(@hProv, bytes.size, bytes) == 0
+        raise SystemCallError,
+          "CryptGenRandom failed: #{lastWin32ErrorMessage}"
+      end
+      return bytes
+    end
+
+    raise NotImplementedError, "No random device"
+  end
+
+  # SecureRandom.hex generates a random hex string.
+  #
+  # The argument n specifies the length of the random length.
+  # The length of the result string is twice of n.
+  #
+  # If n is not specified, 16 is assumed.
+  # It may be larger in future.
+  #
+  # If secure random number generator is not available,
+  # NotImplementedError is raised.
+  def self.hex(n=nil)
+    random_bytes(n).unpack("H*")[0]
+  end
+
+  # SecureRandom.base64 generates a random base64 string.
+  #
+  # The argument n specifies the length of the random length.
+  # The length of the result string is about 4/3 of n.
+  #
+  # If n is not specified, 16 is assumed.
+  # It may be larger in future.
+  #
+  # If secure random number generator is not available,
+  # NotImplementedError is raised.
+  def self.base64(n=nil)
+    [random_bytes(n)].pack("m*").delete("\n")
+  end
+
+  # SecureRandom.random_number generates a random number.
+  #
+  # If an positive integer is given as n,
+  # SecureRandom.random_number returns an integer:
+  # 0 <= SecureRandom.random_number(n) < n.
+  #
+  # If 0 is given or an argument is not given,
+  # SecureRandom.random_number returns an float:
+  # 0.0 <= SecureRandom.random_number() < 1.0.
+  def self.random_number(n=0)
+    if 0 < n
+      hex = n.to_s(16)
+      hex = '0' + hex if (hex.length & 1) == 1
+      bin = [hex].pack("H*")
+      mask = bin[0].ord
+      mask |= mask >> 1
+      mask |= mask >> 2
+      mask |= mask >> 4
+      begin
+        rnd = SecureRandom.random_bytes(bin.length)
+        rnd[0] = (rnd[0].ord & mask).chr
+      end until rnd < bin
+      rnd.unpack("H*")[0].hex
+    else
+      # assumption: Float::MANT_DIG <= 64
+      i64 = SecureRandom.random_bytes(8).unpack("Q")[0]
+      Math.ldexp(i64 >> (64-Float::MANT_DIG), -Float::MANT_DIG)
+    end
+  end
+
+  # Following code is based on David Garamond's GUID library for Ruby.
+  def self.lastWin32ErrorMessage # :nodoc:
+    get_last_error = Win32API.new(
+      "kernel32", "GetLastError", '', 'L'
+    )
+    format_message = Win32API.new(
+      "kernel32", "FormatMessageA", 'LPLLPLPPPPPPPP', 'L'
+    )
+    format_message_ignore_inserts = 0x00000200
+    format_message_from_system    = 0x00001000
+
+    code = get_last_error.call
+    msg = "\0" * 1024
+    len = format_message.call(
+      format_message_ignore_inserts + format_message_from_system,
+      0, code, 0, msg, 1024, nil, nil, nil, nil, nil, nil, nil, nil
+    )
+    msg[0, len].tr("\r", '').chomp
+  end
+end

data/lib/uuidtools.rb

@@ -31,6 +31,12 @@ require 'digest/md5'
 
 require 'uuidtools/version'
 
+begin
+  require 'securerandom'
+rescue LoadError
+  require File.join(File.dirname(__FILE__), 'compat', 'securerandom')
+end
+
 #= uuidtools.rb
 #
 # UUIDTools was designed to be a simple library for generating any
@@ -47,6 +53,8 @@ require 'uuidtools/version'
 #  UUID.random_create
 #  => #<UUID:0x19013a UUID:984265dc-4200-4f02-ae70-fe4f48964159>
 class UUID
+  include Comparable
+
   @@last_timestamp = nil
   @@last_node_id = nil
   @@last_clock_sequence = nil
@@ -78,9 +86,9 @@ class UUID
         "Expected unsigned 8-bit number for clock_seq_low, " +
         "got #{clock_seq_low}."
     end
-    unless nodes.respond_to? :size
-      raise ArgumentError,
-        "Expected nodes to respond to :size."
+    unless nodes.kind_of?(Enumerable)
+      raise TypeError,
+        "Expected Enumerable, got #{nodes.class.name}."
     end
     unless nodes.size == 6
       raise ArgumentError,
@@ -111,7 +119,7 @@ class UUID
   # Parses a UUID from a string.
   def self.parse(uuid_string)
     unless uuid_string.kind_of? String
-      raise ArgumentError,
+      raise TypeError,
         "Expected String, got #{uuid_string.class.name} instead."
     end
     uuid_components = uuid_string.downcase.scan(
@@ -134,7 +142,7 @@ class UUID
   # Parses a UUID from a raw byte string.
   def self.parse_raw(raw_string)
     unless raw_string.kind_of? String
-      raise ArgumentError,
+      raise TypeError,
         "Expected String, got #{raw_string.class.name} instead."
     end
     integer = self.convert_byte_string_to_int(raw_string)
@@ -154,7 +162,7 @@ class UUID
 
   # Creates a UUID from a random value.
   def self.random_create()
-    new_uuid = self.parse_raw(self.random_bits)
+    new_uuid = self.parse_raw(SecureRandom.random_bytes(16))
     new_uuid.time_hi_and_version &= 0x0FFF
     new_uuid.time_hi_and_version |= (4 << 12)
     new_uuid.clock_seq_hi_and_reserved &= 0x3F
@@ -183,14 +191,9 @@ class UUID
           octet.to_i(16)
         end
       else
-        nodes = self.random_bits(48).split("").map do |chr|
-          if chr.respond_to?(:ord)
-            # Ruby 1.9
-            chr.ord
-          else
-            # Ruby 1.8
-            chr.sum(8)
-          end
+        nodes = SecureRandom.random_bytes(6).split("").map do |chr|
+          # Ruby 1.9 / Ruby 1.8
+          chr.respond_to?(:ord) ? chr.ord : chr.sum(8)
         end
         nodes[0] |= 0b00000001
       end
@@ -199,11 +202,15 @@ class UUID
       end
       clock_sequence = @@last_clock_sequence
       if clock_sequence.nil?
-        clock_sequence = self.convert_byte_string_to_int(self.random_bits)
+        clock_sequence = self.convert_byte_string_to_int(
+          SecureRandom.random_bytes(16)
+        )
       end
       if @@last_node_id != nil && @@last_node_id != node_id
         # The node id has changed.  Change the clock id.
-        clock_sequence = self.convert_byte_string_to_int(self.random_bits)
+        clock_sequence = self.convert_byte_string_to_int(
+          SecureRandom.random_bytes(16)
+        )
       elsif @@last_timestamp != nil &&
           gmt_timestamp_100_nanoseconds <= @@last_timestamp
         clock_sequence = clock_sequence + 1
@@ -353,7 +360,7 @@ class UUID
 
   # Returns the hex digest of the UUID object.
   def hexdigest
-    return self.to_i.to_s(16)
+    return self.to_i.to_s(16).rjust(32, "0")
   end
 
   # Returns the raw bytes that represent this UUID.
@@ -394,7 +401,7 @@ class UUID
 
   # Returns true if this UUID is exactly equal to the other UUID.
   def eql?(other)
-    return (self <=> other) == 0
+    return self == other
   end
 
   # Returns the MAC address of the current computer's network card.
@@ -406,7 +413,7 @@ class UUID
       if os_platform =~ /win/ && !(os_platform =~ /darwin/)
         script_in_path = true
       else
-        script_in_path = !(`which ifconfig`.strip =~ /no .+ in/)
+        script_in_path = Kernel.system("which ifconfig 2>&1 > /dev/null")
       end
       if os_platform =~ /solaris/
         begin
@@ -526,7 +533,9 @@ class UUID
     @@mac_address = new_mac_address
   end
 
-protected
+  # The following methods are not part of the public API,
+  # and generally should not be called directly.
+
   # Creates a new UUID from a SHA1 or MD5 hash
   def self.create_from_hash(hash_class, namespace, name) #:nodoc:
     if hash_class == Digest::MD5
@@ -551,29 +560,6 @@ protected
     return new_uuid
   end
 
-  # N bits of unpredictable data.
-  def self.random_bits(size=128) #:nodoc:
-    if 128 % 16 != 0
-      raise ArgumentError, "Value must be divisible by 16."
-    end
-    if !defined?(@random_device) || @random_device == nil
-      begin
-        @random_device = nil
-        if File.exists? "/dev/urandom"
-          @random_device = File.open "/dev/urandom", "r"
-        elsif File.exists? "/dev/random"
-          @random_device = File.open "/dev/random", "r"
-        end
-      rescue Exception
-      end
-    end
-    begin
-      return @random_device.read(size / 8) if @random_device != nil
-    rescue Exception
-    end
-    return (1..(size / 16)).to_a.map { rand(0x10000) }.pack("n#{size / 16}")
-  end
-
   def self.convert_int_to_byte_string(integer, size) #:nodoc:
     byte_string = ""
     for i in 0..(size - 1)
@@ -586,13 +572,9 @@ protected
     integer = 0
     size = byte_string.size
     for i in 0..(size - 1)
-      if byte_string[i].respond_to?(:ord)
-        # Ruby 1.9
-        integer += (byte_string[i].ord << (((size - 1) - i) * 8))
-      else
-        # Ruby 1.8
-        integer += (byte_string[i] << (((size - 1) - i) * 8))
-      end
+      ordinal = (byte_string[i].respond_to?(:ord) ?
+        byte_string[i].ord : byte_string[i])
+      integer += (ordinal << (((size - 1) - i) * 8))
     end
     return integer
   end
@@ -602,3 +584,9 @@ UUID_DNS_NAMESPACE = UUID.parse("6ba7b810-9dad-11d1-80b4-00c04fd430c8")
 UUID_URL_NAMESPACE = UUID.parse("6ba7b811-9dad-11d1-80b4-00c04fd430c8")
 UUID_OID_NAMESPACE = UUID.parse("6ba7b812-9dad-11d1-80b4-00c04fd430c8")
 UUID_X500_NAMESPACE = UUID.parse("6ba7b814-9dad-11d1-80b4-00c04fd430c8")
+
+at_exit do
+  if UUID.instance_variable_get("@random_device") != nil
+    UUID.instance_variable_get("@random_device").close rescue nil
+  end
+end

data/lib/uuidtools/version.rb

@@ -21,12 +21,15 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 
-class UUID
-  module VERSION #:nodoc:
-    MAJOR = 1
-    MINOR = 0
-    TINY  = 4
+# Used to prevent the class/module from being loaded more than once
+unless defined? UUID::VERSION
+  class UUID
+    module VERSION #:nodoc:
+      MAJOR = 1
+      MINOR = 0
+      TINY  = 5
 
-    STRING = [MAJOR, MINOR, TINY].join('.')
+      STRING = [MAJOR, MINOR, TINY].join('.')
+    end
   end
 end

data/spec/uuidtools/utility_spec.rb

@@ -0,0 +1,17 @@
+require File.join(File.dirname(__FILE__), "../spec_helper.rb")
+
+describe UUID, "when using utility methods" do
+  it "should correctly obtain random bits" do
+    bits = []
+    1000.times 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
+  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
+  end
+end

data/spec/uuidtools/uuid_creation_spec.rb

@@ -14,6 +14,7 @@ describe UUID, "when generating" do
   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
     current_time = Time.now
     UUID.timestamp_create(current_time).to_s.should_not ==
@@ -22,16 +23,98 @@ describe UUID, "when generating" do
     1000.times do
       uuids << UUID.timestamp_create
     end
-    # Check to make sure that none of the 10,000 UUIDs were duplicates
+    # 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
+  end
+
   it "should correctly generate random number variant UUIDs" do
     uuids = []
     1000.times do
       uuids << UUID.random_create
     end
-    # Check to make sure that none of the 10,000 UUIDs were duplicates
+    # 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 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])
+    end).should raise_error(ArgumentError)
+    (lambda do
+      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])
+    end).should raise_error(ArgumentError)
+    (lambda do
+      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])
+    end).should raise_error(ArgumentError)
+    (lambda do
+      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])
+    end).should raise_error(ArgumentError)
+    (lambda do
+      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])
+    end).should raise_error(ArgumentError)
+    (lambda do
+      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)
+    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])
+    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])
+    end).should raise_error(ArgumentError)
+  end
+
+  it "should throw an exception if parsing anything but a String" do
+    (lambda do
+      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)
+    end).should raise_error(TypeError)
+  end
 end

data/spec/uuidtools/uuid_parsing_spec.rb

@@ -33,4 +33,74 @@ describe UUID, "when parsing" do
     UUID.timestamp_create.should be_random_node_id
     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
+  end
+
+  it "should correctly identify timestamp version UUIDs as valid" do
+    UUID.timestamp_create.should be_valid
+  end
+
+  it "should correctly identify random number version UUIDs as valid" do
+    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'
+    ).should be_valid
+  end
+
+  it "should correctly identify MD5 hash version UUIDs as valid" do
+    UUID.md5_create(
+      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
+  end
+
+  it "should allow for sorting of UUID arrays" do
+    uuids = []
+    1000.times do
+      uuids << UUID.timestamp_create
+    end
+    uuids.sort!
+    uuids.first.should < uuids.last
+    uuids.last.should > uuids.first
+  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])
+  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 ==
+      "00000000000000000000000000000000"
+    UUID.new(1, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).hexdigest.should ==
+      "00000001000000000000000000000000"
+    UUID.timestamp_create.hexdigest.size.should == 32
+  end
+
+  it "should produce a sane hash value for a UUID" do
+    UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).hash.should == 0
+  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 ==
+      "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])
+    )
+  end
 end

data/tasks/gem.rake

@@ -2,6 +2,11 @@ require "rake/gempackagetask"
 
 namespace :gem do
   GEM_SPEC = Gem::Specification.new do |s|
+    unless s.respond_to?(:add_development_dependency)
+      puts "The gem spec requires a newer version of RubyGems."
+      exit(1)
+    end
+
     s.name = PKG_NAME
     s.version = PKG_VERSION
     s.summary = PKG_SUMMARY
@@ -13,8 +18,9 @@ namespace :gem do
     s.extra_rdoc_files = %w( README )
     s.rdoc_options.concat ["--main",  "README"]
 
-    s.add_dependency("rake", ">= 0.7.3")
-    s.add_dependency("rspec", ">= 1.0.8")
+    s.add_development_dependency("rake", ">= 0.8.3")
+    s.add_development_dependency("rspec", ">= 1.1.11")
+    s.add_development_dependency("launchy", ">= 0.3.2")
 
     s.require_path = "lib"
 

data/tasks/rubyforge.rake

@@ -1,9 +1,8 @@
-require 'rubyforge'
-require 'rake/contrib/sshpublisher'
-
 namespace :gem do
   desc 'Package and upload to RubyForge'
   task :release => ["gem:package"] do |t|
+    require 'rubyforge'
+
     v = ENV['VERSION'] or abort 'Must supply VERSION=x.y.z'
     abort "Versions don't match #{v} vs #{PROJ.version}" if v != PKG_VERSION
     pkg = "pkg/#{GEM_SPEC.full_name}"
@@ -28,6 +27,9 @@ end
 namespace :doc do
   desc "Publish RDoc to RubyForge"
   task :release => ["doc:rdoc"] do
+    require "rake/contrib/sshpublisher"
+    require "yaml"
+
     config = YAML.load(
       File.read(File.expand_path('~/.rubyforge/user-config.yml'))
     )
@@ -41,6 +43,9 @@ end
 namespace :spec do
   desc "Publish specdoc to RubyForge"
   task :release => ["spec:specdoc"] do
+    require "rake/contrib/sshpublisher"
+    require "yaml"
+
     config = YAML.load(
       File.read(File.expand_path('~/.rubyforge/user-config.yml'))
     )
@@ -53,6 +58,9 @@ namespace :spec do
   namespace :rcov do
     desc "Publish coverage report to RubyForge"
     task :release => ["spec:rcov"] do
+      require "rake/contrib/sshpublisher"
+      require "yaml"
+
       config = YAML.load(
         File.read(File.expand_path('~/.rubyforge/user-config.yml'))
       )
@@ -67,6 +75,9 @@ end
 namespace :website do
   desc "Publish website to RubyForge"
   task :release => ["doc:release", "spec:release", "spec:rcov:release"] do
+    require "rake/contrib/sshpublisher"
+    require "yaml"
+
     config = YAML.load(
       File.read(File.expand_path('~/.rubyforge/user-config.yml'))
     )

data/tasks/spec.rake

@@ -4,20 +4,33 @@ namespace :spec do
   Spec::Rake::SpecTask.new(:rcov) do |t|
     t.spec_files = FileList['spec/**/*_spec.rb']
     t.spec_opts = ['--color', '--format', 'specdoc']
-    t.rcov = true
+    if RCOV_ENABLED
+      t.rcov = true
+    else
+      t.rcov = false
+    end
     t.rcov_opts = [
       '--exclude', 'spec',
       '--exclude', '1\\.8\\/gems',
-      '--exclude', '1\\.9\\/gems'
+      '--exclude', '1\\.9\\/gems',
+      '--exclude', 'addressable\\/idna\\.rb', # unicode tables too big
     ]
   end
 
-  RCov::VerifyTask.new(:verify) do |t|
-    t.threshold = 100.0
-    t.index_html = 'coverage/index.html'
+  Spec::Rake::SpecTask.new(:normal) do |t|
+    t.spec_files = FileList['spec/**/*_spec.rb']
+    t.spec_opts = ['--color', '--format', 'specdoc']
+    t.rcov = false
   end
 
-  task :verify => :rcov
+  if RCOV_ENABLED
+    RCov::VerifyTask.new(:verify) do |t|
+      t.threshold = 100.0
+      t.index_html = 'coverage/index.html'
+    end
+
+    task :verify => :rcov
+  end
 
   desc "Generate HTML Specdocs for all specs"
   Spec::Rake::SpecTask.new(:specdoc) do |t|
@@ -34,56 +47,18 @@ namespace :spec do
   namespace :rcov do
     desc "Browse the code coverage report."
     task :browse => "spec:rcov" do
-      Rake.browse("coverage/index.html")
+      require "launchy"
+      Launchy::Browser.run("coverage/index.html")
     end
   end
 end
 
-desc "Alias to spec:verify"
-task "spec" => "spec:verify"
+if RCOV_ENABLED
+  desc "Alias to spec:verify"
+  task "spec" => "spec:verify"
+else
+  desc "Alias to spec:normal"
+  task "spec" => "spec:normal"
+end
 
 task "clobber" => ["spec:clobber_rcov"]
-
-module Rake
-  def self.browse(filepath)
-    if RUBY_PLATFORM =~ /mswin/
-      system(filepath)
-    else
-      try_browsers = lambda do
-        result = true
-        if !(`which firefox 2>&1` =~ /no firefox/)
-          system("firefox #{filepath}")
-        elsif !(`which mozilla 2>&1` =~ /no mozilla/)
-          system("mozilla #{filepath}")
-        elsif !(`which netscape 2>&1` =~ /no netscape/)
-          system("netscape #{filepath}")
-        elsif !(`which links 2>&1` =~ /no links/)
-          system("links #{filepath}")
-        elsif !(`which lynx 2>&1` =~ /no lynx/)
-          system("lynx #{filepath}")
-        else
-          result = false
-        end
-        result
-      end
-      opened = false
-      if RUBY_PLATFORM =~ /darwin/
-        opened = true
-        system("open #{filepath}")
-      elsif !(`which gnome-open 2>&1` =~ /no gnome-open/)
-        success =
-          !(`gnome-open #{filepath} 2>&1` =~ /There is no default action/)
-        if !success
-          opened = try_browsers.call()
-        else
-          opened = true
-        end
-      else
-        opened = try_browsers.call()
-      end
-      if !opened
-        puts "Don't know how to browse to location."
-      end
-    end
-  end
-end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: uuidtools
 version: !ruby/object:Gem::Version 
-  version: 1.0.4
+  version: 1.0.5
 platform: ruby
 authors: 
 - Bob Aman
@@ -9,28 +9,38 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-09-29 00:00:00 -04:00
+date: 2008-12-01 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rake
-  type: :runtime
+  type: :development
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.7.3
+        version: 0.8.3
     version: 
 - !ruby/object:Gem::Dependency 
   name: rspec
-  type: :runtime
+  type: :development
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.0.8
+        version: 1.1.11
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: launchy
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.3.2
     version: 
 description: A simple universally unique ID generation library.
 email: bob@sporkmonger.com
@@ -41,6 +51,8 @@ extensions: []
 extra_rdoc_files: 
 - README
 files: 
+- lib/compat
+- lib/compat/securerandom.rb
 - lib/uuidtools
 - lib/uuidtools/version.rb
 - lib/uuidtools.rb
@@ -48,6 +60,7 @@ files:
 - spec/spec_helper.rb
 - spec/uuidtools
 - spec/uuidtools/mac_address_spec.rb
+- spec/uuidtools/utility_spec.rb
 - spec/uuidtools/uuid_creation_spec.rb
 - spec/uuidtools/uuid_parsing_spec.rb
 - tasks/benchmark.rake
@@ -86,7 +99,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: uuidtools
-rubygems_version: 1.2.0
+rubygems_version: 1.3.1
 signing_key: 
 specification_version: 2
 summary: UUID generator