uuidtools 1.0.0 → 1.0.1

data/CHANGELOG

@@ -1,9 +1,16 @@
+== UUIDTools 1.0.1
+ * improved code for obtaining a MAC address for Solaris and NetBSD
+ * MAC addresses can now be set manually
+ * replaced random number generator, less effective on Windows, but faster
+ * fixed inheritance issues
+ * changed UUID#to_uri method to return a string instead of a URI object
+ * removed UUID#to_uri_string
 == UUIDTools 1.0.0
  * slight improvements to the random number generator
  * fixed issue with failing to obtain mac address in certain environments
 == UUIDTools 0.1.4
  * improved speed when generating timestamp-based uuids
- * fixed bug with rapid generation of timestamp uuids leading to dupicates
+ * fixed bug with rapid generation of timestamp uuids leading to duplicates
  * improved code for detection of mac address
 == UUIDTools 0.1.3
  * fixed issue with UUID#raw attempting to call protected class methods

data/lib/uuidtools.rb

@@ -21,7 +21,7 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 
-UUID_TOOLS_VERSION = "1.0.0"
+UUID_TOOLS_VERSION = "1.0.1"
 
 $:.unshift(File.dirname(__FILE__))
 
@@ -166,7 +166,7 @@ class UUID
   attr_accessor :nodes
   
   # Parses a UUID from a string.
-  def UUID.parse(uuid_string)
+  def self.parse(uuid_string)
     unless uuid_string.kind_of? String
       raise ArgumentError,
         "Expected String, got #{uuid_string.class.name} instead."
@@ -184,17 +184,17 @@ class UUID
     for i in 0..5
       nodes << uuid_components[5][(i * 2)..(i * 2) + 1].to_i(16)
     end
-    return UUID.new(time_low, time_mid, time_hi_and_version,
+    return self.new(time_low, time_mid, time_hi_and_version,
       clock_seq_hi_and_reserved, clock_seq_low, nodes)
   end
 
   # Parses a UUID from a raw byte string.
-  def UUID.parse_raw(raw_string)
+  def self.parse_raw(raw_string)
     unless raw_string.kind_of? String
       raise ArgumentError,
         "Expected String, got #{raw_string.class.name} instead."
     end
-    integer = UUID.convert_byte_string_to_int(raw_string)
+    integer = self.convert_byte_string_to_int(raw_string)
 
     time_low = (integer >> 96) & 0xFFFFFFFF
     time_mid = (integer >> 80) & 0xFFFF
@@ -205,13 +205,13 @@ class UUID
     for i in 0..5
       nodes << ((integer >> (40 - (i * 8))) & 0xFF)
     end
-    return UUID.new(time_low, time_mid, time_hi_and_version,
+    return self.new(time_low, time_mid, time_hi_and_version,
       clock_seq_hi_and_reserved, clock_seq_low, nodes)
   end
 
   # Creates a UUID from a random value.
-  def UUID.random_create()
-    new_uuid = UUID.parse_raw(UUID.true_random)
+  def self.random_create()
+    new_uuid = self.parse_raw(self.random_128)
     new_uuid.time_hi_and_version &= 0x0FFF
     new_uuid.time_hi_and_version |= (4 << 12)
     new_uuid.clock_seq_hi_and_reserved &= 0x3F
@@ -220,7 +220,7 @@ class UUID
   end
 
   # Creates a UUID from a timestamp.
-  def UUID.timestamp_create(timestamp=nil)
+  def self.timestamp_create(timestamp=nil)
     # We need a lock here to prevent two threads from ever
     # getting the same timestamp.
     @@mutex.synchronize do
@@ -233,7 +233,7 @@ class UUID
       # Convert to 100 nanosecond blocks
       gmt_timestamp_100_nanoseconds = (gmt_timestamp.tv_sec * 10000000) +
         (gmt_timestamp.tv_usec * 10) + 0x01B21DD213814000
-      nodes = UUID.get_mac_address.split(":").collect do |octet|
+      nodes = self.get_mac_address.split(":").collect do |octet|
         octet.to_i(16)
       end
       node_id = 0
@@ -242,11 +242,11 @@ class UUID
       end
       clock_sequence = @@last_clock_sequence
       if clock_sequence.nil?
-        clock_sequence = UUID.convert_byte_string_to_int(UUID.true_random)
+        clock_sequence = self.convert_byte_string_to_int(self.random_128)
       end
       if @@last_node_id != nil && @@last_node_id != node_id
         # The node id has changed.  Change the clock id.
-        clock_sequence = UUID.convert_byte_string_to_int(UUID.true_random)
+        clock_sequence = self.convert_byte_string_to_int(self.random_128)
       elsif @@last_timestamp != nil &&
           gmt_timestamp_100_nanoseconds <= @@last_timestamp
         clock_sequence = clock_sequence + 1
@@ -263,19 +263,19 @@ class UUID
       clock_seq_hi_and_reserved = (clock_sequence & 0x3F00) >> 8
       clock_seq_hi_and_reserved |= 0x80
       
-      return UUID.new(time_low, time_mid, time_hi_and_version,
+      return self.new(time_low, time_mid, time_hi_and_version,
         clock_seq_hi_and_reserved, clock_seq_low, nodes)
     end
   end
 
   # Creates a UUID using the MD5 hash.  (Version 3)
-  def UUID.md5_create(namespace, name)
-    return UUID.create_from_hash(Digest::MD5, namespace, name)
+  def self.md5_create(namespace, name)
+    return self.create_from_hash(Digest::MD5, namespace, name)
   end
   
   # Creates a UUID using the SHA1 hash.  (Version 5)
-  def UUID.sha1_create(namespace, name)
-    return UUID.create_from_hash(Digest::SHA1, namespace, name)
+  def self.sha1_create(namespace, name)
+    return self.create_from_hash(Digest::SHA1, namespace, name)
   end
   
   # This method applies only to version 1 UUIDs.
@@ -401,7 +401,7 @@ class UUID
   
   # Returns the raw bytes that represent this UUID.
   def raw
-    return UUID.convert_int_to_byte_string(self.to_i, 16)
+    return self.class.convert_int_to_byte_string(self.to_i, 16)
   end
   
   # Returns a string representation for this UUID.
@@ -424,18 +424,13 @@ class UUID
     end
     return bytes
   end
-    
-  # Returns a URI for this UUID.
-  def to_uri
-    return URI.parse(self.to_uri_string)
-  end
 
   # Returns a URI string for this UUID.
-  def to_uri_string
+  def to_uri
     return "urn:uuid:#{self.to_s}"
   end
   
-  def UUID.create_from_hash(hash_class, namespace, name) #:nodoc:
+  def self.create_from_hash(hash_class, namespace, name) #:nodoc:
     if hash_class == Digest::MD5
       version = 3
     elsif hash_class == Digest::SHA1
@@ -448,7 +443,7 @@ class UUID
     hash.update(namespace.raw)
     hash.update(name)
     hash_string = hash.to_s[0..31]
-    new_uuid = UUID.parse("#{hash_string[0..7]}-#{hash_string[8..11]}-" +
+    new_uuid = self.parse("#{hash_string[0..7]}-#{hash_string[8..11]}-" +
       "#{hash_string[12..15]}-#{hash_string[16..19]}-#{hash_string[20..31]}")
     
     new_uuid.time_hi_and_version &= 0x0FFF
@@ -460,9 +455,18 @@ class UUID
 
   # Returns the MAC address of the current computer's network card.
   # Returns nil if a MAC address could not be found.
-  def UUID.get_mac_address #:nodoc:
+  def self.get_mac_address #:nodoc:
     if @@mac_address.nil?
-      if RUBY_PLATFORM =~ /win/ && !(RUBY_PLATFORM =~ /darwin/)
+      if RUBY_PLATFORM =~ /solaris/
+        begin
+        	ifconfig_output = `/sbin/ifconfig -a`
+        	ip_addresses = ifconfig_output.scan(
+        	  /inet\s?(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})/)
+        	ip = ip_addresses.find {|addr| addr[0] != '127.0.0.1'}[0]
+        	@@mac_address = `/usr/sbin/arp #{ip}`.split(' ')[3]
+        rescue Exception
+        end
+      elsif RUBY_PLATFORM =~ /win/ && !(RUBY_PLATFORM =~ /darwin/)
         begin
           ifconfig_output = `ipconfig /all`
           mac_addresses = ifconfig_output.scan(
@@ -475,11 +479,19 @@ class UUID
       else
         begin
           mac_addresses = []
-          if File.exists?('/sbin/ifconfig')
-            ifconfig_output =
-              `/sbin/ifconfig 2>&1`
+          if RUBY_PLATFORM =~ /netbsd/
+            ifconfig_output = `/sbin/ifconfig -a 2>&1`
+            mac_addresses = ifconfig_output.scan(
+              Regexp.new("address\: (#{(["[0-9a-fA-F]{2}"] * 6).join(":")})"))
+          elsif File.exists?('/sbin/ifconfig')
+            ifconfig_output = `/sbin/ifconfig 2>&1`
             mac_addresses = ifconfig_output.scan(
               Regexp.new("ether (#{(["[0-9a-fA-F]{2}"] * 6).join(":")})"))
+            if mac_addresses.size == 0
+              ifconfig_output = `/sbin/ifconfig -a 2>&1`
+              mac_addresses = ifconfig_output.scan(
+                Regexp.new("ether (#{(["[0-9a-fA-F]{2}"] * 6).join(":")})"))
+            end
             if mac_addresses.size == 0
               ifconfig_output =
                 `/sbin/ifconfig | grep HWaddr | cut -c39- 2>&1`
@@ -491,6 +503,12 @@ class UUID
               `ifconfig 2>&1`
             mac_addresses = ifconfig_output.scan(
               Regexp.new("ether (#{(["[0-9a-fA-F]{2}"] * 6).join(":")})"))
+            if mac_addresses.size == 0
+              ifconfig_output =
+                `ifconfig -a 2>&1`
+              mac_addresses = ifconfig_output.scan(
+                Regexp.new("ether (#{(["[0-9a-fA-F]{2}"] * 6).join(":")})"))
+            end
             if mac_addresses.size == 0
               ifconfig_output =
                 `ifconfig | grep HWaddr | cut -c39- 2>&1`
@@ -504,51 +522,48 @@ class UUID
         rescue
         end
       end
+      @@mac_address.downcase! if @@mac_address.respond_to?(:downcase!)
+      @@mac_address.strip! if @@mac_address.respond_to?(:strip!)
+      # Verify that the MAC address is in the right format.
+      # Nil it out if it isn't.
+      unless @@mac_address.respond_to?(:scan) &&
+          @@mac_address.scan(/#{(["[0-9a-f]{2}"] * 6).join(":")}/)
+        @@mac_address = nil
+      end
     end
     return @@mac_address
   end
+  class <<self
+    alias_method :mac_address, :get_mac_address
+  end
   
-  # Returns 128 bits of highly unpredictable data.
-  # The random number generator isn't perfect, but it's
-  # much, much better than the built-in pseudorandom number generators.
-  def UUID.true_random #:nodoc:
-    require 'benchmark'
-    hash = Digest::SHA1.new
-    performance = Benchmark.measure do
-      hash.update(rand.to_s)
-      hash.update(srand.to_s)
-      hash.update(rand.to_s)
-      hash.update(srand.to_s)
-      hash.update(Time.now.to_s)
-      hash.update(rand.to_s)
-      hash.update(self.object_id.to_s)
-      hash.update(rand.to_s)
-      hash.update(hash.object_id.to_s)
-      hash.update(self.methods.inspect)
-      hash.update($:.to_s)
+  # Allows users to set the MAC address manually in cases where the MAC
+  # address cannot be obtained programatically.
+  def self.mac_address=(new_mac_address)
+    @@mac_address = new_mac_address
+  end
+  
+  # 128 bits of unpredictable data.
+  def self.random_128 #:nodoc:
+    if !defined?(@random_device) || @random_device == nil
       begin
-        random_device = nil
+        @random_device = nil
         if File.exists? "/dev/urandom"
-          random_device = File.open "/dev/urandom", "r"
+          @random_device = File.open "/dev/urandom", "r"
         elsif File.exists? "/dev/random"
-          random_device = File.open "/dev/random", "r"
+          @random_device = File.open "/dev/random", "r"
         end
-        hash.update(random_device.read(20)) if random_device != nil
-      rescue
+      rescue Exception
       end
-      begin
-        srand(hash.to_s.to_i(16) >> 128)
-      rescue
-      end
-      hash.update(rand.to_s)
-      hash.update(UUID.true_random) if (rand(2) == 0)
     end
-    hash.update(performance.real.to_s)
-    hash.update(performance.inspect)
-    return UUID.convert_int_to_byte_string(hash.to_s[4..35].to_i(16), 16)
+    begin
+      return @random_device.read(16) if @random_device != nil
+    rescue Exception
+    end
+    return (1..8).to_a.map { rand(0x10000) }.pack("n8")
   end
   
-  def UUID.convert_int_to_byte_string(integer, size) #:nodoc:
+  def self.convert_int_to_byte_string(integer, size) #:nodoc:
     byte_string = ""
     for i in 0..(size - 1)
       byte_string << ((integer >> (((size - 1) - i) * 8)) & 0xFF)
@@ -556,7 +571,7 @@ class UUID
     return byte_string
   end
 
-  def UUID.convert_byte_string_to_int(byte_string) #:nodoc:
+  def self.convert_byte_string_to_int(byte_string) #:nodoc:
     integer = 0
     size = byte_string.size
     for i in 0..(size - 1)
@@ -569,4 +584,4 @@ end
 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")
+UUID_X500_NAMESPACE = UUID.parse("6ba7b814-9dad-11d1-80b4-00c04fd430c8")

data/rakefile

@@ -7,7 +7,7 @@ require 'rake/gempackagetask'
 require 'rake/contrib/rubyforgepublisher'
 
 PKG_NAME      = 'uuidtools'
-PKG_VERSION   = '1.0.0'
+PKG_VERSION   = '1.0.1'
 PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
 
 RELEASE_NAME  = "REL #{PKG_VERSION}"
@@ -16,7 +16,7 @@ RUBY_FORGE_PROJECT = "uuidtools"
 RUBY_FORGE_USER    = "vacindak"
 
 PKG_FILES = FileList[
-    "lib/**/*", "test/**/*", "examples/**/*", "doc/**/*", "[A-Z]*", "install.rb", "rakefile"
+    "lib/**/*", "test/**/*", "examples/**/*", "doc/**/*", "[A-Z]*", "rakefile"
 ].exclude(/\bCVS\b|~$/).exclude(/database\.yml/)
 
 desc "Default Task"
@@ -52,7 +52,7 @@ spec = Gem::Specification.new do |s|
   s.summary = "Generation of UUIDs."
   s.description = "Implements a simple system for generating UUIDs."
 
-  s.files = [ "rakefile", "install.rb", "README", "CHANGELOG" ]
+  s.files = [ "rakefile", "README", "CHANGELOG" ]
   dist_dirs.each do |dir|
     s.files = s.files + Dir.glob( "#{dir}/**/*" ).delete_if do |item|
       item.include?( "\.svn" ) || item.include?( "database\.yml" )
@@ -101,6 +101,46 @@ task :lines do
   puts "Total: Lines #{total_lines}, LOC #{total_codelines}"
 end
 
+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."
+
+  # 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
+  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
+  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
+    end
+  end
+  puts "#{(10000.0 / result.real)} version 5 per second."
+  
+end
+
 
 # Publishing ------------------------------------------------------
 

data/test/mac_address_test.rb

@@ -0,0 +1,13 @@
+require 'test/unit'
+require 'uuidtools'
+
+class MacAddressTest < Test::Unit::TestCase
+  def setup
+  end
+  
+  def test_mac_address_object
+    mac_address = UUID.mac_address
+    assert_not_nil(mac_address)
+    assert_equal(mac_address.object_id, UUID.mac_address.object_id)
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.11
+rubygems_version: 0.9.2
 specification_version: 1
 name: uuidtools
 version: !ruby/object:Gem::Version 
-  version: 1.0.0
-date: 2006-02-13 00:00:00 -05:00
+  version: 1.0.1
+date: 2007-04-28 00:00:00 -04:00
 summary: Generation of UUIDs.
 require_paths: 
-  - lib
+- lib
 email: bob@sporkmonger.com
 homepage: http://sporkmonger.com/projects/uuidtools
 rubyforge_project: uuidtools
@@ -18,31 +18,36 @@ bindir: bin
 has_rdoc: true
 required_ruby_version: !ruby/object:Gem::Version::Requirement 
   requirements: 
-    - 
-      - ">"
-      - !ruby/object:Gem::Version 
-        version: 0.0.0
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
   version: 
 platform: ruby
 signing_key: 
 cert_chain: 
+post_install_message: 
 authors: 
-  - Bob Aman
+- Bob Aman
 files: 
-  - rakefile
-  - install.rb
-  - README
-  - CHANGELOG
-  - lib/uuidtools.rb
-  - test/create_test.rb
-  - test/parse_test.rb
+- rakefile
+- README
+- CHANGELOG
+- lib/uuidtools.rb
+- test/create_test.rb
+- test/mac_address_test.rb
+- test/parse_test.rb
 test_files: []
+
 rdoc_options: 
-  - "--main"
-  - README
+- --main
+- README
 extra_rdoc_files: 
-  - README
+- README
 executables: []
+
 extensions: []
+
 requirements: []
-dependencies: []
+
+dependencies: []
+

data/install.rb

@@ -1,30 +0,0 @@
-require 'rbconfig'
-require 'find'
-require 'ftools'
-
-include Config
-
-# this was adapted from rdoc's install.rb by ways of Log4r
-
-$sitedir = CONFIG["sitelibdir"]
-unless $sitedir
-  version = CONFIG["MAJOR"] + "." + CONFIG["MINOR"]
-  $libdir = File.join(CONFIG["libdir"], "ruby", version)
-  $sitedir = $:.find {|x| x =~ /site_ruby/ }
-  if !$sitedir
-    $sitedir = File.join($libdir, "site_ruby")
-  elsif $sitedir !~ Regexp.quote(version)
-    $sitedir = File.join($sitedir, version)
-  end
-end
-
-# the acual gruntwork
-Dir.chdir("lib")
-
-Find.find("uuidtools.rb") { |f|
-  if f[-3..-1] == ".rb"
-    File::install(f, File.join($sitedir, *f.split(/\//)), 0644, true)
-  else
-    File::makedirs(File.join($sitedir, *f.split(/\//)))
-  end
-}