gn0m30-uuid 2.1.2

data/CHANGELOG

@@ -0,0 +1,49 @@
+2.1.1 (2010-01-25)
+* added the :teenie format
+
+2.1.0 (2009-12-16)
+* Added uuid.validate -- easier to implement than explain why it's wrong.
+
+2.0.2 (2009-06-10)
+* Maintenance release. Added uuid.gemspec file in packaging, tested against
+Ruby 1.9.1.
+
+2.0.1 (2008-08-28)
+* Fixed:    MAC address parses correctly when using colon as separator, not
+            when using hyphen (ruby-mingw32). If your MAC address is all zero
+            (check with UUID.new.inspect), remove the ruby-uuid file, and it
+            will reset to the actual MAC address. (Rasha)
+* Fixed:    UUID.new.inspect not showing full MAC address.
+
+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

@@ -0,0 +1,20 @@
+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
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,97 @@
+= 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
+four 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.
+
+The gn0m30 fork of uuid adds another format, the <tt>:teenie</tt> format
+converts the numeric portions of the default format to base 62 representations
+for use in situations where case sensitive keys might be useful like Amazon S3.
+
+
+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 Gemcutter, to upgrade simply:
+
+  gem upgrade gn0m30-uuid
+
+
+gn0m30-uuid is forked from UUID available here: http://github.com/assaf/uuid
+
+Source code and documentation hosted on Github: http://github.com/gn0m30/uuid
+
+
+== License
+
+This package is licensed under the MIT license and/or the Creative
+Commons Attribution-ShareAlike.
+
+:include: MIT-LICENSE
+

data/Rakefile

@@ -0,0 +1,60 @@
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+
+spec = Gem::Specification.load(File.expand_path("gn0m30-uuid.gemspec", File.dirname(__FILE__)))
+
+desc "Default Task"
+task :default => :test
+
+
+desc "If you're building from sources, run this task first to setup the necessary dependencies"
+task 'setup' do
+  missing = spec.dependencies.select { |dep| Gem::SourceIndex.from_installed_gems.search(dep).empty? }
+  missing.each do |dep|
+    if Gem::SourceIndex.from_installed_gems.search(dep).empty?
+      puts "Installing #{dep.name} ..."
+      rb_bin = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
+      args = []
+      args << rb_bin << '-S' << 'gem' << 'install' << dep.name
+      args << '--version' << dep.version_requirements.to_s
+      args << '--source' << 'http://gems.rubyforge.org'
+      args << '--install-dir' << ENV['GEM_HOME'] if ENV['GEM_HOME']
+      sh *args
+    end
+  end
+end
+
+
+desc "Run all test cases"
+Rake::TestTask.new do |test|
+  test.verbose = true
+  test.test_files = ['test/*.rb']
+  test.warning = true
+end
+
+# Create the documentation.
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_files.include "README.rdoc", "lib/**/*.rb"
+  rdoc.options = spec.rdoc_options
+end
+
+
+
+desc "Push new release to gemcutter and git tag"
+task :push do
+  sh "git push"
+  puts "Tagging version #{spec.version} .."
+  sh "git tag v#{spec.version}"
+  sh "git push --tag"
+  puts "Building and pushing gem .."
+  sh "gem build #{spec.name}.gemspec"
+  sh "gem push #{spec.name}-#{spec.version}.gem"
+end
+
+desc "Install #{spec.name} locally"
+task :install do
+  sh "gem build #{spec.name}.gemspec"
+  sudo = "sudo" unless File.writable?( Gem::ConfigMap[:bindir])
+  sh "#{sudo} gem install #{spec.name}-#{spec.version}.gem"
+end

data/gn0m30-uuid.gemspec

@@ -0,0 +1,22 @@
+spec = Gem::Specification.new do |spec|
+  spec.name = 'gn0m30-uuid'
+  spec.version = '2.1.2'
+  spec.summary = "UUID generator with teenie format"
+  spec.description = <<-EOF
+UUID generator for producing universally unique identifiers based on RFC 4122
+(http://www.ietf.org/rfc/rfc4122.txt).
+EOF
+
+  spec.authors << 'Assaf Arkin' << 'Eric Hodel' << 'jim nist'
+  spec.email = 'reggie@loco8.org'
+  spec.homepage = 'http://github.com/gn0m30/uuid'
+
+  spec.files = Dir['{bin,test,lib,docs}/**/*'] + ['README.rdoc', 'MIT-LICENSE', 'Rakefile', 'CHANGELOG', 'gn0m30-uuid.gemspec']
+  spec.has_rdoc = true
+  spec.rdoc_options << '--main' << 'README.rdoc' << '--title' <<  'UUID generator' << '--line-numbers'
+                       '--webcvs' << 'http://github.com/assaf/uuid'
+  spec.extra_rdoc_files = ['README.rdoc', 'MIT-LICENSE']
+
+  spec.add_dependency 'macaddr', ['~>1.0']
+  spec.add_dependency 'base62', ['~>0.1.0']
+end

data/lib/uuid.rb

@@ -0,0 +1,326 @@
+#
+# = uuid.rb - UUID generator
+#
+# Author:: Assaf Arkin  assaf@labnotes.org
+#          Eric Hodel drbrain@segment7.net
+# Copyright:: Copyright (c) 2005-2008 Assaf Arkin, Eric Hodel
+# License:: MIT and/or Creative Commons Attribution-ShareAlike
+
+require 'fileutils'
+require 'thread'
+require 'tmpdir'
+
+require 'rubygems'
+require 'macaddr'
+require 'base62'
+
+
+##
+# = 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].
+
+class UUID
+
+  # Version number.
+  module Version
+    version = Gem::Specification.load(File.expand_path("../gn0m30-uuid.gemspec", File.dirname(__FILE__))).version.to_s.split(".").map { |i| i.to_i }
+    MAJOR = version[0]
+    MINOR = version[1]
+    PATCH = version[2]
+    STRING = "#{MAJOR}.#{MINOR}.#{PATCH}"
+  end
+
+  VERSION = Version::STRING
+
+  ##
+  # Clock multiplier. Converts Time (resolution: seconds) to UUID clock
+  # (resolution: 10ns)
+  CLOCK_MULTIPLIER = 10000000
+
+  ##
+  # 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
+
+  ##
+  # 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
+  # <tt>:teenie</tt>:: converts numeric portions of default format to base62
+  FORMATS = {
+    :compact => '%08x%04x%04x%04x%012x',
+    :default => '%08x-%04x-%04x-%04x-%012x',
+    :urn     => 'urn:uuid:%08x-%04x-%04x-%04x-%012x',
+    :teenie  => '%6.6s%3.3s%3.3s%3.3s%9.9s',
+  }
+
+  ##
+  # MAC address (48 bits), sequence number and last clock
+  STATE_FILE_FORMAT = 'SLLQ'
+
+  @state_file = nil
+  @mode = nil
+  @uuid = nil
+
+  ##
+  # The access mode of the state file.  Set it with state_file.
+
+  def self.mode
+    @mode
+  end
+
+  ##
+  # Generates a new UUID string using +format+.  See FORMATS for a list of
+  # supported formats.
+
+  def self.generate(format = :default)
+    @uuid ||= new
+    @uuid.generate format
+  end
+
+  ##
+  # 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
+
+    @mode = mode
+
+    begin
+      require 'Win32API'
+
+      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
+
+      state_dir = File.join(path.strip)
+    rescue LoadError
+      state_dir = File.join('', 'var', 'tmp')
+    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
+
+    @state_file
+  end
+
+  ##
+  # Specify the path of the state file.
+  def self.state_file=(path)
+    @state_file = path
+  end
+
+  ##
+  # Returns true if +uuid+ is in compact, default or urn formats.  Does not
+  # validate the layout (RFC 4122 section 4) of the UUID.
+  # does not validate :teenie format. see validate_teenie
+  def self.validate(uuid)
+    return true if uuid =~ /\A[\da-f]{32}\z/i
+    return true if
+      uuid =~ /\A(urn:uuid:)?[\da-f]{8}-([\da-f]{4}-){3}[\da-f]{12}\z/i
+  end
+
+  ##
+  # Returns true if +uuid+ is in teenie format
+  def self.validate_teenie(uuid)
+    return true if uuid =~ /\A[\da-fA-f]{24}\z/i
+  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
+      fail "Cannot determine MAC address from any available interface, tried with #{Mac.addr}" if @mac == 0
+      @sequence = rand 0x10000
+
+      open_lock 'w' do |io|
+        write_state io
+      end
+    end
+  end
+
+  ##
+  # Generates a new UUID string using +format+.  See FORMATS for a list of
+  # supported formats.
+  def generate(format = :default)
+    template = FORMATS[format]
+
+    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 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
+      end
+    end until clock
+
+    part1 = clock & 0xFFFFFFFF
+    part2 = (clock >> 32) & 0xFFFF
+    part3 = ((clock >> 48) & 0xFFFF | VERSION_CLOCK)
+    part4 = @sequence & 0xFFFF
+    part5 = @mac & 0xFFFFFFFFFFFF
+
+    # for this special case, the parts are going to be strings which we will 0 pad
+    if format == :teenie
+      part1 = part1.base62_encode
+      part2 = part2.base62_encode
+      part3 = part3.base62_encode
+      part4 = part4.base62_encode
+      part5 = part5.base62_encode
+
+      (template % [part1, part2, part3, part4, part5]).gsub(' ', '0')
+    else
+      template % [part1, part2, part3, part4, part5]
+    end
+  end
+
+  ##
+  # Updates the state file with a new sequence number.
+  def next_sequence
+    open_lock 'r+' do |io|
+      @mac, @sequence, @last_clock = read_state(io)
+
+      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 = ("%012x" % @mac).scan(/[0-9a-f]{2}/).join(':')
+    "MAC: #{mac}  Sequence: #{@sequence}"
+  end
+
+protected
+
+  ##
+  # 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
+
+  ##
+  # 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
+
+    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

data/test/test-uuid.rb

@@ -0,0 +1,118 @@
+# Author:: Assaf Arkin  assaf@labnotes.org
+#          Eric Hodel drbrain@segment7.net
+# Copyright:: Copyright (c) 2005-2008 Assaf Arkin, Eric Hodel
+# License:: MIT and/or Creative Commons Attribution-ShareAlike
+
+require 'test/unit'
+require 'uuid'
+
+class TestUUID < Test::Unit::TestCase
+
+  def test_state_file_creation
+    path = UUID.state_file
+    File.delete path if File.exist?(path)
+    UUID.new.generate
+    File.exist?(path)
+  end
+
+  def test_state_file_specify
+    path = File.join("path", "to", "ruby-uuid")
+    UUID.state_file = path
+    assert_equal path, UUID.state_file
+  end
+
+  def test_instance_generate
+    uuid = UUID.new
+    assert_match(/\A[\da-f]{32}\z/i, uuid.generate(:compact))
+
+    assert_match(/\A[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}\z/i,
+                 uuid.generate(:default))
+
+    assert_match(/^urn:uuid:[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}\z/i,
+                 uuid.generate(:urn))
+
+    assert_match(/\A[\da-fA-f]{24}\z/i, uuid.generate(:teenie))
+
+    e = assert_raise ArgumentError do
+      uuid.generate :unknown
+    end
+
+    assert_equal 'invalid UUID format :unknown', e.message
+  end
+
+  def test_class_generate
+    assert_match(/\A[\da-f]{32}\z/i, UUID.generate(:compact))
+
+    assert_match(/\A[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}\z/i,
+                 UUID.generate(:default))
+
+    assert_match(/^urn:uuid:[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}\z/i,
+                 UUID.generate(:urn))
+
+    assert_match(/\A[\da-fA-f]{24}\z/i, UUID.generate(:teenie))
+
+    e = assert_raise ArgumentError do
+      UUID.generate :unknown
+    end
+    assert_equal 'invalid UUID format :unknown', e.message
+  end
+
+  def test_class_validate
+    assert !UUID.validate('')
+
+    assert  UUID.validate('01234567abcd8901efab234567890123'), 'compact'
+    assert  UUID.validate('01234567-abcd-8901-efab-234567890123'), 'default'
+    assert  UUID.validate('urn:uuid:01234567-abcd-8901-efab-234567890123'),
+            'urn'
+    assert  UUID.validate_teenie('4etJlQGyu04qEJs002f129iS'), 'teenie'
+
+    assert  UUID.validate('01234567ABCD8901EFAB234567890123'), 'compact'
+    assert  UUID.validate('01234567-ABCD-8901-EFAB-234567890123'), 'default'
+    assert  UUID.validate('urn:uuid:01234567-ABCD-8901-EFAB-234567890123'),
+            'urn'
+    assert  UUID.validate_teenie('1ldIDgGyv04qEJs002f129iS'), 'teenie'
+  end
+
+  def test_class_invalids
+    assert_nil  UUID.validate('01234567abcd8901efab234567890123000'), 'compact - too long'
+    assert_nil  UUID.validate('01234567abcd8901efab23456789012'), 'compact - too short'
+    assert_nil  UUID.validate('01234567abcd8901efzb234567890123'), 'compact - bad chars'
+
+    assert_nil  UUID.validate_teenie('1ldIDgGyv04qEJs002f129iSaaaaa'), 'teenie - too long'
+    assert_nil  UUID.validate_teenie('4etJlQGyu04qEJs02f129iS'), 'teenie - too short'
+    assert_nil  UUID.validate_teenie('1ldIDgGyv04qEJs002f1-9iS'), 'teenie - bad chars'
+  end
+
+  def test_monotonic
+    seen = {}
+    uuid_gen = UUID.new
+
+    20_000.times do
+      uuid = uuid_gen.generate
+      assert !seen.has_key?(uuid), "UUID repeated"
+      seen[uuid] = true
+    end
+  end
+
+  def test_same_mac
+    class << foo = UUID.new
+      attr_reader :mac
+    end
+    class << bar = UUID.new
+      attr_reader :mac
+    end
+    assert_equal foo.mac, bar.mac
+  end
+
+  def test_increasing_sequence
+    class << foo = UUID.new
+      attr_reader :sequence
+    end
+    class << bar = UUID.new
+      attr_reader :sequence
+    end
+    assert_equal foo.sequence + 1, bar.sequence
+  end
+
+end
+

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification 
+name: gn0m30-uuid
+version: !ruby/object:Gem::Version 
+  version: 2.1.2
+platform: ruby
+authors: 
+- Assaf Arkin
+- Eric Hodel
+- jim nist
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-18 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: macaddr
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "1.0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: base62
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.1.0
+    version: 
+description: |
+  UUID generator for producing universally unique identifiers based on RFC 4122
+  (http://www.ietf.org/rfc/rfc4122.txt).
+
+email: reggie@loco8.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- MIT-LICENSE
+files: 
+- test/test-uuid.rb
+- lib/uuid.rb
+- README.rdoc
+- MIT-LICENSE
+- Rakefile
+- CHANGELOG
+- gn0m30-uuid.gemspec
+has_rdoc: true
+homepage: http://github.com/gn0m30/uuid
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+- --title
+- UUID generator
+- --line-numbers
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: UUID generator with teenie format
+test_files: []
+