assaf-uuid 2.0.1 → 2.0.2

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: assaf-uuid
 version: !ruby/object:Gem::Version 
-  version: 2.0.1
+  version: 2.0.2
 platform: ruby
 authors: 
 - Assaf Arkin
@@ -10,11 +10,12 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-08-13 00:00:00 -07:00
+date: 2009-05-16 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: macaddr
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
@@ -31,13 +32,8 @@ extensions: []
 extra_rdoc_files: 
 - README.rdoc
 - MIT-LICENSE
-files: 
-- test/test-uuid.rb
-- lib/uuid.rb
-- README.rdoc
-- MIT-LICENSE
-- Rakefile
-- CHANGELOG
+files: []
+
 has_rdoc: true
 homepage: http://github.com/assaf/uuid
 post_install_message: 

data/CHANGELOG

@@ -1,39 +0,0 @@
-2.0.1 (Pending)
-* 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/Rakefile

@@ -1,100 +0,0 @@
-# Adapted from the rake Rakefile.
-
-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']
-
-
-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
-end
-
-# Create the documentation.
-Rake::RDocTask.new do |rdoc|
-  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'=>['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|
-  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
-
-
-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
-
-=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
-
-task 'clobber' do
-  rm_f '.changes'
-end

data/lib/uuid.rb

@@ -1,282 +0,0 @@
-#
-# = 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-2008 Assaf Arkin, Eric Hodel
-# License:: MIT and/or Creative Commons Attribution-ShareAlike
-
-require 'fileutils'
-require 'thread'
-require 'tmpdir'
-
-require 'rubygems'
-require 'macaddr'
-
-
-##
-# = 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 = '2.0.1'
-
-  ##
-  # 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
-  FORMATS = {
-    :compact => '%08x%04x%04x%04x%012x',
-    :default => '%08x-%04x-%04x-%04x-%012x',
-    :urn     => 'urn:uuid:%08x-%04x-%04x-%04x-%012x',
-  }
-
-  ##
-  # 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
-
-  ##
-  # 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
-
-    template % [
-        clock        & 0xFFFFFFFF,
-       (clock >> 32) & 0xFFFF,
-      ((clock >> 48) & 0xFFFF | VERSION_CLOCK),
-      @sequence      & 0xFFFF,
-      @mac           & 0xFFFFFFFFFFFF
-    ]
-  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

@@ -1,82 +0,0 @@
-# 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_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))
-
-    e = assert_raise ArgumentError do
-      uuid.generate :unknown
-    end
-
-    assert_equal 'invalid UUID format :unknown', e.message
-  end
-
-  def test_class_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))
-
-    e = assert_raise ArgumentError do
-      UUID.generate :unknown
-    end
-    assert_equal 'invalid UUID format :unknown', e.message
-  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
-