uuid 1.0.4 → 2.0.0

data/CHANGELOG

@@ -1,19 +1,32 @@
-1.0.4 (1/2/2006)
-* Changed:  By default creates the uuid.state file in the working directory,
-            not in the installation directory, which requires sudo privileges (e.g. gem).
-
-1.0.3 (1/8/2006)
-* Fixed:    Work around YAML bug in serializing that occurs when MAC address
-            consists only of decimal digits. Credit: ebuprofen"
-
-1.0.2 (1/28/2006)
-* Changed:  Constants are not conditionally defined (removes warnings when
-            using in Rails.
-
-1.0.1 (1/26/2006)
-* Added:    Regular expressions to test if a string is a UUID.
-* Changed:  When used in ActiveRecord, adds as callback instead of overriding
-            save.
-
-1.0.0 (1/20/2005)
-* Changed:  Separated form reliable-msg into its own package.
+2.0.0 (2008-08-28)
+* Changed:  API. UUID.generate still works as it always did, but the rest of
+            the API is brand spanking new, so if you rely on anything besides
+						UUID.generate, or just curious, check out the rdocs.
+* Changed:  uuid.state replaced by ruby-uuid file. By default stored in
+            /var/tmp, or if that path is not accessible, as .ruby-uuid in the
+            home directory.
+* Changed:  ruby-uuid is now stored as binary file (faster read/write), if you
+            need to have a peek, open irb and type UUID.new.inspect.
+* Changed:  Source code and documentation for this release hosted on the
+            wonderful Github: http://github.com/assaf/uuid
+
+1.0.4 (2007-08-28)
+* Changed:  By default creates the uuid.state file in the working directory,
+            not in the installation directory, which requires sudo privileges
+            (e.g. gem).
+
+1.0.3 (2006-11-08)
+* Fixed:    Work around YAML bug in serializing that occurs when MAC address
+            consists only of decimal digits. Credit: ebuprofen"
+
+1.0.2 (2006-08-19)
+* Changed:  Constants are not conditionally defined (removes warnings when
+            using in Rails.
+
+1.0.1 (2006-07-27)
+* Added:    Regular expressions to test if a string is a UUID.
+* Changed:  When used in ActiveRecord, adds as callback instead of overriding
+            save.
+
+1.0.0 (2005-11-20)
+* Changed:  Separated form reliable-msg into its own package.

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2005,2007 Assaf Arkin
+Copyright (c) 2005-2008 Assaf Arkin, Eric Hodel
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -0,0 +1,103 @@
+= UUID Generator
+
+Generates universally unique identifiers (UUIDs) for use in distributed
+applications. Based on {RFC 4122}[http://www.ietf.org/rfc/rfc4122.txt].
+
+
+== Generating UUIDs
+
+Call #generate to generate a new UUID. The method returns a string in one of
+three formats. The default format is 36 characters long, and contains the 32
+hexadecimal octets and hyphens separating the various value parts. The
+<tt>:compact</tt> format omits the hyphens, while the <tt>:urn</tt> format
+adds the <tt>:urn:uuid</tt> prefix.
+
+For example:
+
+  uuid = UUID.new
+  10.times do
+    p uuid.generate
+  end
+
+
+== UUIDs in Brief
+
+UUID (universally unique identifier) are guaranteed to be unique across time
+and space.
+
+A UUID is 128 bit long, and consists of a 60-bit time value, a 16-bit
+sequence number and a 48-bit node identifier.
+
+The time value is taken from the system clock, and is monotonically
+incrementing.  However, since it is possible to set the system clock
+backward, a sequence number is added.  The sequence number is incremented
+each time the UUID generator is started.  The combination guarantees that
+identifiers created on the same machine are unique with a high degree of
+probability.
+
+Note that due to the structure of the UUID and the use of sequence number,
+there is no guarantee that UUID values themselves are monotonically
+incrementing.  The UUID value cannot itself be used to sort based on order
+of creation.
+
+To guarantee that UUIDs are unique across all machines in the network,
+the IEEE 802 MAC address of the machine's network interface card is used as
+the node identifier.
+
+For more information see {RFC 4122}[http://www.ietf.org/rfc/rfc4122.txt].
+
+
+== UUID State File
+
+The UUID generator uses a state file to hold the MAC address and sequence
+number.
+
+The MAC address is used to generate identifiers that are unique to your
+machine, preventing conflicts in distributed applications. The MAC
+address is six bytes (48 bit) long. It is automatically extracted from
+one of the network cards on your machine.
+
+The sequence number is incremented each time the UUID generator is
+first used by the application, to prevent multiple processes from
+generating the same set of identifiers, and deal with changes to the
+system clock.
+
+The UUID state file is created in <tt>/var/tmp/ruby-uuid</tt> or the Windows
+common application data directory using mode 0644.  If that directory is not
+writable, the file is created as <tt>.ruby-uuid</tt> in the home directory.
+If you need to create the file with a different mode, use UUID#state_file
+before running the UUID generator.
+
+State files are not portable across machines.
+
+
+== Latest and Greatest
+
+Stable release are made through RubyForge, to upgrade simply:
+
+  gem upgrade uuid
+
+You can subscribe for notifications of new releases through the reliable-msg
+project page at http://rubyforge.org/projects/reliable-msg
+
+Source code and documentation hosted on Github:
+
+  http://github.com/assaf/uuid
+
+To get UUID from source:
+
+  git clone git://github.com/assaf/uuid.git
+
+
+== Change Log
+
+:include: CHANGELOG
+
+
+== License
+
+This package is licensed under the MIT license and/or the {Creative
+Commons Attribution-ShareAlike}[http://creativecommons.org/licenses/by-sa/2.5/legalcode].
+
+:include: MIT-LICENSE
+

data/Rakefile

@@ -1,220 +1,100 @@
 # Adapted from the rake Rakefile.
 
-require "rubygems"
-require "rake/testtask"
-require "rake/rdoctask"
-require "rake/gempackagetask"
-
-VERSION_FILE = "lib/uuid.rb"
-# Create the GEM package.
-spec = Gem::Specification.new do |spec|
-  spec.name = "uuid"
-  spec.version = File.read(__FILE__.pathmap("%d/#{VERSION_FILE}")).scan(/VERSION\s*=\s*(['"])(.*)\1/)[0][1]
-  spec.summary = "UUID generator"
-  spec.description = <<-EOF
-    UUID generator for producing universally unique identifiers based
-    on RFC 4122 (http://www.ietf.org/rfc/rfc4122.txt).
-EOF
-  spec.author = "Assaf Arkin"
-  spec.email = "assaf@labnotes.org"
-  spec.homepage = "http://trac.labnotes.org/cgi-bin/trac.cgi/wiki/Ruby/UuidGenerator"
-  spec.files = FileList["{bin,test,lib,docs}/**/*", "README", "MIT-LICENSE", "Rakefile", "CHANGELOG"].to_a
-  spec.require_path = "lib"
-  spec.autorequire = "uuid.rb"
-  spec.bindir = "bin"
-  spec.executables = ["uuid-setup"]
-  spec.default_executable = "uuid-setup"
-  spec.has_rdoc = true
-  spec.rdoc_options << "--main" << "README" << "--title" <<  "UUID generator" << "--line-numbers"
-  spec.extra_rdoc_files = ["README"]
-  spec.rubyforge_project = "reliable-msg"
-end
+require 'rubygems'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'rubygems/source_info_cache'
+
 
+spec = Gem::Specification.load(File.join(File.dirname(__FILE__), 'uuid.gemspec'))
 
 desc "Default Task"
-task :default => [:test, :rdoc]
+task 'default' => ['test', 'rdoc']
+
+
+desc "If you're building from sources, run this task first to setup the necessary dependencies"
+task 'setup' do
+  windows = Config::CONFIG['host_os'] =~ /windows|cygwin|bccwin|cygwin|djgpp|mingw|mswin|wince/i
+  rb_bin = File.expand_path(Config::CONFIG['ruby_install_name'], Config::CONFIG['bindir'])
+  spec.dependencies.select { |dep| Gem::SourceIndex.from_installed_gems.search(dep).empty? }.each do |missing|
+    dep = Gem::Dependency.new(missing.name, missing.version_requirements)
+    spec = Gem::SourceInfoCache.search(dep, true, true).last
+    fail "#{dep} not found in local or remote repository!" unless spec
+    puts "Installing #{spec.full_name} ..."
+    args = [rb_bin, '-S', 'gem', 'install', spec.name, '-v', spec.version.to_s]
+    args.unshift('sudo') unless windows || ENV['GEM_HOME']
+    sh args.map{ |a| a.inspect }.join(' ')
+  end
+end
 
 
 desc "Run all test cases"
 Rake::TestTask.new do |test|
   test.verbose = true
-  test.test_files = ["test/*.rb"]
-  #test.warning = true
+  test.test_files = ['test/*.rb']
+  test.warning = true
 end
 
 # Create the documentation.
 Rake::RDocTask.new do |rdoc|
-  rdoc.main = "README"
-  rdoc.rdoc_files.include("README", "lib/**/*.rb")
+  rdoc.main = 'README.rdoc'
+  rdoc.rdoc_files.include('README.rdoc', 'lib/**/*.rb')
   rdoc.title = "UUID generator"
 end
 
+
 gem = Rake::GemPackageTask.new(spec) do |pkg|
   pkg.need_tar = true
   pkg.need_zip = true
 end
 
 desc "Install the package locally"
-task :install=>:package do |task|
-  system "gem", "install", "pkg/#{spec.name}-#{spec.version}.gem"
+task 'install'=>['setup', 'package'] do |task|
+  rb_bin = File.expand_path(Config::CONFIG['ruby_install_name'], Config::CONFIG['bindir'])
+  args = [rb_bin, '-S', 'gem', 'install', "pkg/#{spec.name}-#{spec.version}.gem"]
+  windows = Config::CONFIG['host_os'] =~ /windows|cygwin|bccwin|cygwin|djgpp|mingw|mswin|wince/i
+  args.unshift('sudo') unless windows || ENV['GEM_HOME']
+  sh args.map{ |a| a.inspect }.join(' ')
 end
 
 desc "Uninstall previously installed packaged"
-task :uninstall do |task|
-  system "gem", "uninstall", spec.name, "-v", spec.version.to_s
-end
-
-
-desc "Look for TODO and FIXME tags in the code"
-task :todo do
-  FileList["**/*.rb"].egrep /#.*(FIXME|TODO|TBD)/
-end
-
-
-# --------------------------------------------------------------------
-# Creating a release
-
-
-namespace :upload do
-  task :packages=>["rake:rdoc", "rake:package"] do |task|
-    require 'rubyforge'
-
-    # Read the changes for this release.
-    pattern = /(^(\d+\.\d+(?:\.\d+)?)\s+\(\d+\/\d+\/\d+\)\s*((:?^[^\n]+\n)*))/
-    changelog = File.read(__FILE__.pathmap("%d/CHANGELOG"))
-    changes = changelog.scan(pattern).inject({}) { |hash, set| hash[set[1]] = set[2] ; hash }
-    current = changes[spec.version.to_s]
-    if !current && spec.version.to_s =~ /\.0$/
-      current = changes[spec.version.to_s.split(".")[0..-2].join(".")] 
-    end
-    fail "No changeset found for version #{spec.version}" unless current
-
-    puts "Uploading #{spec.name} #{spec.version}"
-    files = %w( gem tgz zip ).map { |ext| "pkg/#{spec.name}-#{spec.version}.#{ext}" }
-    rubyforge = RubyForge.new
-    rubyforge.login    
-    File.open(".changes", 'w'){|f| f.write(current)}
-    rubyforge.userconfig.merge!("release_changes" => ".changes",  "preformatted" => true)
-    rubyforge.add_release spec.rubyforge_project.downcase, spec.name.downcase, spec.version, *files
-    rm ".changes"
-    puts "Release #{spec.version} uploaded"
-  end
+task 'uninstall' do |task|
+  rb_bin = File.expand_path(Config::CONFIG['ruby_install_name'], Config::CONFIG['bindir'])
+  args = [rb_bin, '-S', 'gem', 'install', spec.name, '-v', spec.version.to_s]
+  windows = Config::CONFIG['host_os'] =~ /windows|cygwin|bccwin|cygwin|djgpp|mingw|mswin|wince/i
+  args.unshift('sudo') unless windows || ENV['GEM_HOME']
+  sh args.map{ |a| a.inspect }.join(' ')
 end
 
-namespace :release do
-  task :ready? do
-    require 'highline'
-    require 'highline/import'
-
-    puts "This version: #{spec.version}"
-    puts
-    puts "Top 4 lines form CHANGELOG:"
-    puts File.readlines("CHANGELOG")[0..3].map { |l| "  #{l}" }
-    puts
-    ask("Top-entry in CHANGELOG file includes today's date?") =~ /yes/i or
-      fail "Please update CHANGELOG to include the right date"
-  end
 
-  task :post do
-    # Practical example of functional read but not comprehend code:
-    next_version = spec.version.to_ints.zip([0, 0, 1]).map { |a| a.inject(0) { |t,i| t + i } }.join(".")
-    puts "Updating #{VERSION_FILE} to next version number: #{next_version}"
-    ver_file = File.read(__FILE__.pathmap("%d/#{VERSION_FILE}")).
-      sub(/(VERSION\s*=\s*)(['"])(.*)\2/) { |line| "#{$1}#{$2}#{next_version}#{$2}" } 
-    File.open(__FILE__.pathmap("%d/#{VERSION_FILE}"), "w") { |file| file.write ver_file }
-    puts "Adding entry to CHANGELOG"
-    changelog = File.read(__FILE__.pathmap("%d/CHANGELOG"))
-    File.open(__FILE__.pathmap("%d/CHANGELOG"), "w") { |file| file.write "#{next_version} (Pending)\n\n#{changelog}" }
-  end
-
-  task :meat=>["clobber", "test", "upload:packages"]
-end
-
-desc "Upload release to RubyForge including docs, tag SVN"
-task :release=>[ "release:ready?", "release:meat", "release:post" ]
-
-=begin
-
-# Handle version number.
-class Version
-
-  PATTERN = /(\s*)VERSION.*(\d+\.\d+\.\d+)/
-
-  def initialize file, new_version
-    @file = file
-    @version = File.open @file, "r" do |file|
-      version = nil
-      file.each_line do |line|
-        match = line.match PATTERN
-        if match
-          version = match[2]
-          break
-        end
-      end
-      version
-    end
-    fail "Can't determine version number" unless @version
-    @new_version = new_version || @version
-  end
+task 'release'=>['setup', 'test', 'package'] do
+  
+  require 'rubyforge'
+=begin  
+  header = File.readlines('CHANGELOG').first
+  version, date = header.scan(/(\d+\.\d+\.\d+) \((\d{4}-\d{2}-\d{2})\)/).first
+  fail "CHANGELOG and spec version numbers do not match: #{version} != #{spec.version}" unless version == spec.version.to_s
+  today = Time.now.strftime('%Y-%m-%d')
+  fail "CHANGELOG entry not using today's date: #{date} != #{today}" unless date = today
 
-  def changed?
-    @version != @new_version
-  end
-
-  def number
-    @version
-  end
-
-  def next
-    @new_version
-  end
-
-  def update
-    puts "Updating to version #{@new_version}"
-    copy = "#{@file}.new"
-    open @file, "r" do |input|
-      open copy, "w" do |output|
-        input.each_line do |line|
-          match = line.match PATTERN
-          if match
-            output.puts "#{match[1]}VERSION = '#{@new_version}'"
-          else
-            output.puts line
-          end
-        end
-      end
-    end
-    mv copy, @file
-    @version = @new_version
+=end
+  changes = File.read('CHANGELOG')[/\d+.\d+.\d+.*\n((:?^[^\n]+\n)*)/]
+  File.open '.changes', 'w' do |file|
+    file.write changes
   end
 
+  puts "Uploading #{spec.name} #{spec.version}"
+  files = Dir['pkg/*.{gem,tgz,zip}']
+  rubyforge = RubyForge.new
+  rubyforge.configure
+  rubyforge.login    
+  rubyforge.userconfig.merge! 'release_changes'=>'.changes', 'preformatted'=>true
+  rubyforge.add_release spec.rubyforge_project.downcase, spec.name.downcase, spec.version, *files
+  rm_f '.changes'
+  puts "Release #{spec.version} uploaded"
 end
-version = Version.new "lib/uuid.rb", ENV["version"]
-
-
 
-
-desc "Make a new release"
-task :release => [:test, :prerelease, :clobber, :update_version, :package] do
-  puts
-  puts "**************************************************************"
-  puts "* Release #{version.number} Complete."
-  puts "* Packages ready to upload."
-  puts "**************************************************************"
-  puts
-end
-
-task :prerelease do
-  if !version.changed? && ENV["reuse"] != version.number
-    fail "Current version is #{version.number}, must specify reuse=ver to reuse existing version"
-  end
+task 'clobber' do
+  rm_f '.changes'
 end
-
-task :update_version => [:prerelease] do
-  if !version.changed?
-    puts "No version change ... skipping version update"
-  else
-    version.update
-  end
-end
-=end

data/lib/uuid.rb

@@ -2,394 +2,280 @@
 # = uuid.rb - UUID generator
 #
 # Author:: Assaf Arkin  assaf@labnotes.org
+#          Eric Hodel drbrain@segment7.net
 # Documentation:: http://trac.labnotes.org/cgi-bin/trac.cgi/wiki/Ruby/UuidGenerator
-# Copyright:: Copyright (c) 2005,2007 Assaf Arkin
+# Copyright:: Copyright (c) 2005-2008 Assaf Arkin, Eric Hodel
 # License:: MIT and/or Creative Commons Attribution-ShareAlike
 
-
+require 'fileutils'
 require 'thread'
-require 'yaml'
-require 'singleton'
-require 'logger'
+require 'tmpdir'
+
+require 'rubygems'
+require 'macaddr'
 
 
-# == Generating UUIDs
+##
+# = Generating UUIDs
 #
-# Call UUID.new to generate and return a new UUID. The method returns a string in one of three
-# formats. The default format is 36 characters long, and contains the 32 hexadecimal octets and
-# hyphens separating the various value parts. The <tt>:compact</tt> format omits the hyphens,
-# while the <tt>:urn</tt> format adds the <tt>:urn:uuid</tt> prefix.
+# Call #generate to generate a new UUID. The method returns a string in one of
+# three formats. The default format is 36 characters long, and contains the 32
+# hexadecimal octets and hyphens separating the various value parts. The
+# <tt>:compact</tt> format omits the hyphens, while the <tt>:urn</tt> format
+# adds the <tt>:urn:uuid</tt> prefix.
 #
 # For example:
-#  10.times do
-#    p UUID.new
-#  end
 #
-# ---
-# == UUIDs in Brief
+#   uuid = UUID.new
+#   
+#   10.times do
+#     p uuid.generate
+#   end
+#
+# = UUIDs in Brief
 #
-# UUID (universally unique identifier) are guaranteed to be unique across time and space.
+# UUID (universally unique identifier) are guaranteed to be unique across time
+# and space.
 #
-# A UUID is 128 bit long, and consists of a 60-bit time value, a 16-bit sequence number and
-# a 48-bit node identifier.
+# A UUID is 128 bit long, and consists of a 60-bit time value, a 16-bit
+# sequence number and a 48-bit node identifier.
 #
-# The time value is taken from the system clock, and is monotonically incrementing. However,
-# since it is possible to set the system clock backward, a sequence number is added. The
-# sequence number is incremented each time the UUID generator is started. The combination
-# guarantees that identifiers created on the same machine are unique with a high degree of
+# The time value is taken from the system clock, and is monotonically
+# incrementing.  However, since it is possible to set the system clock
+# backward, a sequence number is added.  The sequence number is incremented
+# each time the UUID generator is started.  The combination guarantees that
+# identifiers created on the same machine are unique with a high degree of
 # probability.
 #
-# Note that due to the structure of the UUID and the use of sequence number, there is no
-# guarantee that UUID values themselves are monotonically incrementing. The UUID value
-# cannot itself be used to sort based on order of creation.
+# Note that due to the structure of the UUID and the use of sequence number,
+# there is no guarantee that UUID values themselves are monotonically
+# incrementing.  The UUID value cannot itself be used to sort based on order
+# of creation.
 #
-# To guarantee that UUIDs are unique across all machines in the network, use the IEEE 802
-# MAC address of the machine's network interface card as the node identifier. Network interface
-# cards have unique MAC address that are 47-bit long (the last bit acts as a broadcast flag).
-# Use +ipconfig+ (Windows), or +ifconfig+ (Unix) to find the MAC address (aka physical address)
-# of a network card. It takes the form of six pairs of hexadecimal digits, separated by hypen or
-# colon, e.g. '<tt>08-0E-46-21-4B-35</tt>'
+# To guarantee that UUIDs are unique across all machines in the network,
+# the IEEE 802 MAC address of the machine's network interface card is used as
+# the node identifier.
 #
 # For more information see {RFC 4122}[http://www.ietf.org/rfc/rfc4122.txt].
-#
-# == Configuring the UUID generator
-#
-# The UUID generator requires a state file which maintains the MAC address and next sequence
-# number to use. By default, the UUID generator will use the file <tt>uuid.state</tt> contained
-# in the current directory.
-#
-# Use UUID.config to specify a different location for the UUID state file. If the UUID state file
-# does not exist, you can create one manually, or use UUID.config with the options <tt>:sequence</tt>
-# and <tt>:mac_addr</tt>.
-#
-# A UUID state file looks like:
-#   ---
-#   last_clock: "0x28227f76122d80"
-#   mac_addr: 08-0E-46-21-4B-35
-#   sequence: "0x1639"
-#
-#--
-# === Time-based UUID
-#
-# The UUID specification prescribes the following format for representing UUIDs. Four octets encode
-# the low field of the time stamp, two octects encode the middle field of the timestamp, and two
-# octets encode the high field of the timestamp with the version number. Two octets encode the
-# clock sequence number and six octets encode the unique node identifier.
-#
-# The timestamp is a 60 bit value holding UTC time as a count of 100 nanosecond intervals since
-# October 15, 1582. UUIDs generated in this manner are guaranteed not to roll over until 3400 AD.
-#
-# The clock sequence is used to help avoid duplicates that could arise when the clock is set backward
-# in time or if the node ID changes. Although the system clock is guaranteed to be monotonic, the
-# system clock is not guaranteed to be monotonic across system failures. The UUID cannot be sure
-# that no UUIDs were generated with timestamps larger than the current timestamp.
-#
-# If the clock sequence can be determined at initialization, it is incremented by one. The clock sequence
-# MUST be originally (i.e. once in the lifetime of a system) initialized to a random number to minimize the
-# correlation across systems. The initial value must not be correlated to the node identifier.
-#
-# The node identifier must be unique for each UUID generator. This is accomplished using the IEEE 802
-# network card address. For systems with multiple IEEE 802 addresses, any available address can be used.
-# For systems with no IEEE address, a 47 bit random value is used and the multicast bit is set so it will
-# never conflict with addresses obtained from network cards.
-#
-# === UUID state file
-#
-# The UUID state is contained in the UUID state file. The file name can be specified when configuring
-# the UUID generator with UUID.config. The default is to use the file +uuid.state+ in the current directory.
-#
-# The UUID state file is read once when the UUID generator is first used (or configured). The sequence
-# number contained in the UUID is read and used, and the state file is updated to the next sequence
-# number. The MAC address is also read from the state file. The current clock time (in 100ns resolution)
-# is stored in the state file whenever the sequence number is updated, but is never read.
-#
-# If the UUID generator detects that the system clock has been moved backwards, it will obtain a new
-# sequence in the same manner. So it is possible that the UUID state file will be updated while the
-# application is running.
-#++
-module UUID
- 
-  VERSION = '1.0.4'
-
-  # Regular expression to identify a 36 character UUID. Can be used for a partial match.
-  REGEXP = /[[:xdigit:]]{8}[:-][[:xdigit:]]{4}[:-][[:xdigit:]]{4}[:-][[:xdigit:]]{4}[:-][[:xdigit:]]{12}/
 
-  # Regular expression to identify a 36 character UUID. Can only be used for a full match.
-  REGEXP_FULL = /^[[:xdigit:]]{8}[:-][[:xdigit:]]{4}[:-][[:xdigit:]]{4}[:-][[:xdigit:]]{4}[:-][[:xdigit:]]{12}$/
+class UUID
 
-  # Regular expression to identify a 32 character UUID, no hyphens (compact) full match.
-  REGEXP_COMPACT = /^[[:xdigit:]]{32}$/
+  VERSION = '2.0.0'
 
-  # Default state file.
-  STATE_FILE = 'uuid.state'
+  ##
+  # Clock multiplier. Converts Time (resolution: seconds) to UUID clock
+  # (resolution: 10ns)
+  CLOCK_MULTIPLIER = 10000000
 
-  # Clock multiplier. Converts Time (resolution: seconds) to UUID clock (resolution: 10ns)
-  CLOCK_MULTIPLIER = 10000000 #:nodoc:
-
-  # Clock gap is the number of ticks (resolution: 10ns) between two Ruby Time ticks.
-  CLOCK_GAPS = 100000 #:nodoc:
+  ##
+  # Clock gap is the number of ticks (resolution: 10ns) between two Ruby Time
+  # ticks.
+  CLOCK_GAPS = 100000
 
+  ##
   # Version number stamped into the UUID to identify it as time-based.
-  VERSION_CLOCK = 0x0100 #:nodoc:
+  VERSION_CLOCK = 0x0100
 
+  ##
   # Formats supported by the UUID generator.
+  #
+  # <tt>:default</tt>:: Produces 36 characters, including hyphens separating
+  #                     the UUID value parts
+  # <tt>:compact</tt>:: Produces a 32 digits (hexadecimal) value with no
+  #                     hyphens
+  # <tt>:urn</tt>:: Adds the prefix <tt>urn:uuid:</tt> to the default format
   FORMATS = {
-    :compact=>'%08x%04x%04x%04x%012x',
-    :default=>'%08x-%04x-%04x-%04x-%012x', :urn=>'urn:uuid:%08x-%04x-%04x-%04x-%012x' } #:nodoc:
+    :compact => '%08x%04x%04x%04x%012x',
+    :default => '%08x-%04x-%04x-%04x-%012x',
+    :urn     => 'urn:uuid:%08x-%04x-%04x-%04x-%012x',
+  }
 
-  # Length (in characters) of UUIDs generated for each of the formats.
-  FORMATS_LENGTHS = { :compact=>32, :default=>36, :urn=>45 } #:nodoc:
+  ##
+  # MAC address (48 bits), sequence number and last clock
+  STATE_FILE_FORMAT = 'SLLQ'
 
-  ERROR_INVALID_SEQUENCE = "Invalid sequence number: found '%s', expected 4 hexdecimal digits" #:nodoc:
+  @state_file = nil
+  @mode = nil
+  @uuid = nil
 
-  ERROR_NOT_A_SEQUENCE = "Not a sequence number: expected integer between 0 and 0xFFFF" #:nodoc:
+  ##
+  # The access mode of the state file.  Set it with state_file.
 
-  ERROR_INVALID_MAC_ADDR = "Invalid MAC address: found '%s', expected a number in the format XX-XX-XX-XX-XX-XX" #:nodoc:
+  def self.mode
+    @mode
+  end
 
-  INFO_INITIALIZED = "Initialized UUID generator with sequence number 0x%04x and MAC address %s" #:nodoc:
+  ##
+  # Generates a new UUID string using +format+.  See FORMATS for a list of
+  # supported formats.
 
-  ERROR_INITIALIZED_RANDOM_1 = "Initialized UUID generator with random sequence number/MAC address." #:nodoc:
+  def self.generate(format = :default)
+    @uuid ||= new
+    @uuid.generate format
+  end
 
-  ERROR_INITIALIZED_RANDOM_2 = "UUIDs are not guaranteed to be unique. Please create a uuid.state file as soon as possible." #:nodoc:
+  ##
+  # Creates an empty state file in /var/tmp/ruby-uuid or the windows common
+  # application data directory using mode 0644.  Call with a different mode
+  # before creating a UUID generator if you want to open access beyond your
+  # user by default.
+  #
+  # If the default state dir is not writable, UUID falls back to ~/.ruby-uuid.
+  #
+  # State files are not portable across machines.
+  def self.state_file(mode = 0644)
+    return @state_file if @state_file
 
-  IFCONFIG_PATTERN = /[^:\-](?:[0-9A-Za-z][0-9A-Za-z][:\-]){5}[0-9A-Za-z][0-9A-Za-z][^:\-]/ #:nodoc:
+    @mode = mode
 
-  class << self
+    begin
+      require 'Win32API'
 
-    # Configures the UUID generator. Use this method to specify the UUID state file, logger, etc.
-    #
-    # The method accepts the following options:
-    # * <tt>:state_file</tt> -- Specifies the location of the state file. If missing, the default
-    #   is <tt>uuid.state</tt>
-    # * <tt>:logger<tt> -- The UUID generator will use this logger to report the state information (optional).
-    # * <tt>:sequence</tt> -- Specifies the sequence number (0 to 0xFFFF) to use. Required to
-    #   create a new state file, ignored if the state file already exists.
-    # * <tt>:mac_addr</tt> -- Specifies the MAC address (xx-xx-xx-xx-xx) to use. Required to
-    #   create a new state file, ignored if the state file already exists.
-    #
-    # For example, to create a new state file:
-    #  UUID.config :state_file=>'my-uuid.state', :sequence=>rand(0x10000), :mac_addr=>'0C-0E-35-41-60-65'
-    # To use an existing state file and log to +STDOUT+:
-    #  UUID.config :state_file=>'my-uuid.state', :logger=>Logger.new(STDOUT)
-    #
-    # :call-seq:
-    #   UUID.config(config)
-    #
-    def config(options)
-      options ||= {}
-      @@mutex.synchronize do
-        @@logger = options[:logger]
-        next_sequence options
-      end
-    end
+      csidl_common_appdata = 0x0023
+      path = 0.chr * 260
+      get_folder_path = Win32API.new('shell32', 'SHGetFolderPath', 'LLLLP', 'L')
+      get_folder_path.call 0, csidl_common_appdata, 0, 1, path
 
-    # Create a uuid.state file by finding the IEEE 802 NIC MAC address for this machine.
-    # Works for UNIX (ifconfig) and Windows (ipconfig). Creates the uuid.state file in the
-    # current directory.
-    def setup()
-      file = File.expand_path(File.join(Dir.pwd, STATE_FILE))
-      if File.exist? file
-        puts "UUID: Found an existing UUID state file: #{file}"
-      else
-        puts "UUID: No UUID state file found, attempting to create one for you:"
-        # Run ifconfig for UNIX, or ipconfig for Windows.
-        config = ""
-        Kernel.open("|ifconfig") { |input| input.each_line { |line| config << line } } rescue nil
-        Kernel.open("|ipconfig /all") { |input| input.each_line { |line| config << line } } rescue nil
-
-        addresses = config.scan(IFCONFIG_PATTERN).map { |addr| addr[1..-2] }
-        if addresses.empty?
-          puts "Could not find any IEEE 802 NIC MAC addresses for this machine."
-          puts "You need to create the uuid.state file manually."
-        else
-          puts "Found the following IEEE 802 NIC MAC addresses on your computer:"
-          addresses.each { |addr| puts "  #{addr}" }
-          puts "Selecting the first address #{addresses[0]} for use in your UUID state file."
-          File.open file, "w" do |output|
-            output.puts "mac_addr: \"#{addresses[0]}\""
-            output.puts format("sequence: \"0x%04x\"", rand(0x10000))
-          end
-          puts "Created a new UUID state file: #{file}"
-        end
-      end
-      file
+      state_dir = File.join(path.strip)
+    rescue LoadError
+      state_dir = File.join('', 'var', 'tmp')
     end
 
-  private
-
-    def next_sequence(config = nil)
-      # If called to advance the sequence number (config is nil), we have a state file that we're able to use.
-      # If called from configuration, use the specified or default state file.
-      state_file = (config && config[:state_file]) || @@state_file
-
-      unless state_file
-        if File.exist?(STATE_FILE)
-          state_file = STATE_FILE
-        else
-          file = File.expand_path(File.join(Dir.pwd, STATE_FILE))
-          state_file = File.exist?(file) ? file : setup
-        end
-      end
-      begin
-        File.open state_file, "r+" do |file|
-          # Lock the file for exclusive access, just to make sure it's not being read while we're
-          # updating its contents.
-          file.flock(File::LOCK_EX)
-          state = YAML::load file
-          # Get the sequence number. Must be a valid 16-bit hexadecimal value.
-          sequence = state['sequence']
-          if sequence
-            raise RuntimeError, format(ERROR_INVALID_SEQUENCE, sequence) unless sequence.is_a?(String) && sequence =~ /[0-9a-fA-F]{4}/
-            sequence = sequence.hex & 0xFFFF
-          else
-            sequence = rand(0x10000)
-          end
-          # Get the MAC address. Must be 6 pairs of hexadecimal octets. Convert MAC address into
-          # a 48-bit value with the higher bit being zero.
-          mac_addr = state['mac_addr']
-          raise RuntimeError, format(ERROR_INVALID_MAC_ADDR, mac_addr) unless
-            mac_addr.is_a?(String) && mac_addr =~ /([0-9a-fA-F]{2}[:\-]){5}[0-9a-fA-F]{2}/
-          mac_hex = mac_addr.scan(/[0-9a-fA-F]{2}/).join.hex & 0x7FFFFFFFFFFF
-
-          # If everything is OK, proceed to the next step. Grab the sequence number and store
-          # the new state. Start at beginning of file, and truncate file when done.
-          @@mac_addr, @@mac_hex, @@sequence, @@state_file = mac_addr, mac_hex, sequence, state_file
-          file.pos = 0
-          dump file, true
-          file.truncate file.pos
-        end
-        # Initialized.
-        if @@logger
-          @@logger.info format(INFO_INITIALIZED, @@sequence, @@mac_addr)
-        else
-          warn "UUID: " + format(INFO_INITIALIZED, @@sequence, @@mac_addr)
-        end
-        @@last_clock, @@drift = (Time.new.to_f * CLOCK_MULTIPLIER).to_i, 0
-      rescue Errno::ENOENT=>error
-        if !config
-          # Generate random values.
-          @@mac_hex, @@sequence, @@state_file = rand(0x800000000000) | 0xF00000000000, rand(0x10000), nil
-          # Initialized.
-          if @@logger
-            @@logger.error ERROR_INITIALIZED_RANDOM_1
-            @@logger.error ERROR_INITIALIZED_RANDOM_2
-          else
-            warn "UUID: " + ERROR_INITIALIZED_RANDOM_1
-            warn "UUID: " + ERROR_INITIALIZED_RANDOM_2
-          end
-          @@last_clock, @@drift = (Time.new.to_f * CLOCK_MULTIPLIER).to_i, 0
-        else
-          # No state file. If we were called for configuration with valid sequence number and MAC address,
-          # attempt to create state file. See code above for how we interpret these values.
-          sequence = config[:sequence]
-          raise RuntimeError, format(ERROR_NOT_A_SEQUENCE, sequence) unless sequence.is_a?(Integer)
-          sequence &= 0xFFFF
-          mac_addr = config[:mac_addr]
-          raise RuntimeError, format(ERROR_INVALID_MAC_ADDR, mac_addr) unless
-            mac_addr.is_a?(String) && mac_addr =~ /([0-9a-fA-F]{2}[:\-]){5}[0-9a-fA-F]{2}/
-          mac_hex = mac_addr.scan(/[0-9a-fA-F]{2}/).join.hex & 0x7FFFFFFFFFFF
-          File.open state_file, "w" do |file|
-            file.flock(File::LOCK_EX)
-            @@mac_addr, @@mac_hex, @@sequence, @@state_file = mac_addr, mac_hex, sequence, state_file
-            file.pos = 0
-            dump file, true
-            file.truncate file.pos
-          end
-          # Initialized.
-          if @@logger
-            @@logger.info format(INFO_INITIALIZED, @@sequence, @@mac_addr)
-          else
-            warn "UUID: " + format(INFO_INITIALIZED, @@sequence, @@mac_addr)
-          end
-          @@last_clock, @@drift = (Time.new.to_f * CLOCK_MULTIPLIER).to_i, 0
-        end
-      rescue Exception=>error
-        @@last_clock = nil
-        raise error
-      end
+    if File.writable?(state_dir) then
+      @state_file = File.join(state_dir, 'ruby-uuid')
+    else
+      @state_file = File.expand_path(File.join('~', '.ruby-uuid'))
     end
 
-    def dump(file, plus_one)
-      # Gets around YAML weirdness, like ont storing the MAC address as a string.
-      if @@sequence && @@mac_addr
-        file.puts "mac_addr: \"#{@@mac_addr}\""
-        file.puts "sequence: \"0x%04x\"" % ((plus_one ? @@sequence + 1 : @@sequence) & 0xFFFF)
-        file.puts "last_clock: \"0x%x\"" % (@@last_clock || (Time.new.to_f * CLOCK_MULTIPLIER).to_i)
+    @state_file
+  end
+
+  ##
+  # Create a new UUID generator.  You really only need to do this once.
+  def initialize
+    @drift = 0
+    @last_clock = (Time.now.to_f * CLOCK_MULTIPLIER).to_i
+    @mutex = Mutex.new
+
+    if File.exist?(self.class.state_file) then
+      next_sequence
+    else
+      @mac = Mac.addr.gsub(':', '').hex & 0x7FFFFFFFFFFF
+      @sequence = rand 0x10000
+
+      open_lock 'w' do |io|
+        write_state io
       end
     end
   end
 
-  @@mutex       = Mutex.new
-  @@last_clock  = nil
-  @@logger      = nil
-  @@state_file  = nil
+  ##
+  # Generates a new UUID string using +format+.  See FORMATS for a list of
+  # supported formats.
+  def generate(format = :default)
+    template = FORMATS[format]
 
-  # Generates and returns a new UUID string.
-  #
-  # The argument +format+ specifies which formatting template to use:
-  # * <tt>:default</tt> -- Produces 36 characters, including hyphens separating the UUID value parts
-  # * <tt>:compact</tt> -- Produces a 32 digits (hexadecimal) value with no hyphens
-  # * <tt>:urn</tt> -- Aadds the prefix <tt>urn:uuid:</tt> to the <tt>:default</tt> format
-  #
-  # For example:
-  #  print UUID.new :default
-  # or just
-  #  print UUID.new
-  #
-  # :call-seq:
-  #   UUID.new([format])  -> string
-  #
-  def new(format = nil)
-    # Determine which format we're using for the UUID string.
-    template = FORMATS[format || :default] or raise RuntimeError, "I don't know the format '#{format}'"
-
-    # The clock must be monotonically increasing. The clock resolution is at best 100 ns
-    # (UUID spec), but practically may be lower (on my setup, around 1ms). If this method
-    # is called too fast, we don't have a monotonically increasing clock, so the solution is
-    # to just wait.
-    # It is possible for the clock to be adjusted backwards, in which case we would end up
-    # blocking for a long time. When backward clock is detected, we prevent duplicates by
-    # asking for a new sequence number and continue with the new clock.
-    clock = @@mutex.synchronize do
-      # Initialize UUID generator if not already initialized. Uninitizlied UUID generator has no
-      # last known clock.
-      next_sequence unless @@last_clock
+    raise ArgumentError, "invalid UUID format #{format.inspect}" unless template
+
+    # The clock must be monotonically increasing. The clock resolution is at
+    # best 100 ns (UUID spec), but practically may be lower (on my setup,
+    # around 1ms). If this method is called too fast, we don't have a
+    # monotonically increasing clock, so the solution is to just wait.
+    #
+    # It is possible for the clock to be adjusted backwards, in which case we
+    # would end up blocking for a long time. When backward clock is detected,
+    # we prevent duplicates by asking for a new sequence number and continue
+    # with the new clock.
+
+    clock = @mutex.synchronize do
       clock = (Time.new.to_f * CLOCK_MULTIPLIER).to_i & 0xFFFFFFFFFFFFFFF0
-      if clock > @@last_clock
-        @@drift = 0
-        @@last_clock = clock
-      elsif clock = @@last_clock
-        drift = @@drift += 1
-        if drift < 10000
-          @@last_clock += 1
+
+      if clock > @last_clock then
+        @drift = 0
+        @last_clock = clock
+      elsif clock == @last_clock then
+        drift = @drift += 1
+
+        if drift < 10000 then
+          @last_clock += 1
         else
           Thread.pass
           nil
         end
       else
         next_sequence
-        @@last_clock = clock
+        @last_clock = clock
       end
-    end while not clock
-    sprintf template, clock & 0xFFFFFFFF, (clock >> 32)& 0xFFFF, ((clock >> 48) & 0xFFFF | VERSION_CLOCK),
-      @@sequence & 0xFFFF, @@mac_hex & 0xFFFFFFFFFFFF
+    end until clock
+
+    template % [
+        clock        & 0xFFFFFFFF,
+       (clock >> 32) & 0xFFFF,
+      ((clock >> 48) & 0xFFFF | VERSION_CLOCK),
+      @sequence      & 0xFFFF,
+      @mac           & 0xFFFFFFFFFFFF
+    ]
   end
 
-  alias uuid new
-  module_function :uuid, :new
+  ##
+  # Updates the state file with a new sequence number.
+  def next_sequence
+    open_lock 'r+' do |io|
+      @mac, @sequence, @last_clock = read_state(io)
 
-end
+      io.rewind
+      io.truncate 0
+
+      @sequence += 1
+
+      write_state io
+    end
+  rescue Errno::ENOENT
+    open_lock 'w' do |io|
+      write_state io
+    end
+  ensure
+    @last_clock = (Time.now.to_f * CLOCK_MULTIPLIER).to_i
+    @drift = 0
+  end
 
+  def inspect
+    mac = ("%08x" % @mac).scan(/[0-9a-f]{2}/).join(':')
+    "MAC: #{mac}  Sequence: #{@sequence}"
+  end
+
+protected
 
-class ActiveRecord::Base
-  class << self
-    def uuid_primary_key()
-      before_create { |record| record.id = UUID.new unless record.id }
+  ##
+  # Open the state file with an exclusive lock and access mode +mode+.
+  def open_lock(mode)
+    File.open self.class.state_file, mode, self.class.mode do |io|
+      begin
+        io.flock File::LOCK_EX
+        yield io
+      ensure
+        io.flock File::LOCK_UN
+      end
     end
   end
-end if defined?(ActiveRecord)
 
+  ##
+  # Read the state from +io+
+  def read_state(io)
+    mac1, mac2, seq, last_clock = io.read(32).unpack(STATE_FILE_FORMAT)
+    mac = (mac1 << 32) + mac2
 
-if __FILE__ == $0
-  UUID.setup
+    return mac, seq, last_clock
+  end
+
+
+  ##
+  # Write that state to +io+
+  def write_state(io)
+    mac2 =  @mac        & 0xffffffff
+    mac1 = (@mac >> 32) & 0xffff
+
+    io.write [mac1, mac2, @sequence, @last_clock].pack(STATE_FILE_FORMAT)
+  end
+  
 end