uuidtools 2.1.0 → 3.0.0

data/spec/uuidtools/uuid_parsing_spec.rb

@@ -1,66 +1,84 @@
-require File.join(File.dirname(__FILE__), "../spec_helper.rb")
+require File.expand_path("../../spec_helper.rb", __FILE__)
 
 describe UUIDTools::UUID, "when parsing" do
   it "should correctly parse the MAC address from a timestamp version UUID" do
-    UUIDTools::UUID.timestamp_create.mac_address.should ==
+    expect(UUIDTools::UUID.timestamp_create.mac_address).to eql(
       UUIDTools::UUID.mac_address
+    )
   end
 
   it "should correctly parse the variant from a timestamp version UUID" do
-    UUIDTools::UUID.timestamp_create.variant.should == 0b100
+    expect(UUIDTools::UUID.timestamp_create.variant).to eql(0b100)
   end
 
   it "should correctly parse the version from a timestamp version UUID" do
-    UUIDTools::UUID.timestamp_create.version.should == 1
+    expect(UUIDTools::UUID.timestamp_create.version).to eql(1)
   end
 
   it "should correctly parse the timestamp from a timestamp version UUID" do
-    UUIDTools::UUID.timestamp_create.timestamp.should < Time.now + 1
-    UUIDTools::UUID.timestamp_create.timestamp.should > Time.now - 1
+    expect(UUIDTools::UUID.timestamp_create.timestamp).to be < (Time.now + 1)
+    expect(UUIDTools::UUID.timestamp_create.timestamp).to be > (Time.now - 1)
   end
 
   it "should not treat a timestamp version UUID as a nil UUID" do
-    UUIDTools::UUID.timestamp_create.should_not be_nil_uuid
+    expect(UUIDTools::UUID.timestamp_create).not_to be_nil_uuid
   end
 
   it "should not treat a timestamp version UUID as a random node UUID" do
-    UUIDTools::UUID.timestamp_create.should_not be_random_node_id
+    allow(UUIDTools::UUID).to receive(:mac_address) { "aa:bb:cc:dd:ee:ff" }
+    expect(UUIDTools::UUID.timestamp_create).not_to be_random_node_id
   end
 
   it "should treat a timestamp version UUID as a random node UUID " +
       "if there is no MAC address" do
     old_mac_address = UUIDTools::UUID.mac_address
     UUIDTools::UUID.mac_address = nil
-    UUIDTools::UUID.timestamp_create.should be_random_node_id
+    expect(UUIDTools::UUID.timestamp_create).to be_random_node_id
     UUIDTools::UUID.mac_address = old_mac_address
   end
 
   it "should correctly identify the nil UUID" do
-    UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).should be_nil_uuid
+    expect(UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])).to be_nil_uuid
   end
 
   it "should correctly identify timestamp version UUIDs as valid" do
-    UUIDTools::UUID.timestamp_create.should be_valid
+    expect(UUIDTools::UUID.timestamp_create).to be_valid
   end
 
   it "should correctly identify random number version UUIDs as valid" do
-    UUIDTools::UUID.random_create.should be_valid
+    expect(UUIDTools::UUID.random_create).to be_valid
   end
 
   it "should correctly identify SHA1 hash version UUIDs as valid" do
-    UUIDTools::UUID.sha1_create(
+    expect(UUIDTools::UUID.sha1_create(
       UUIDTools::UUID_URL_NAMESPACE, 'http://sporkmonger.com'
-    ).should be_valid
+    )).to be_valid
   end
 
   it "should correctly identify MD5 hash version UUIDs as valid" do
-    UUIDTools::UUID.md5_create(
+    expect(UUIDTools::UUID.md5_create(
       UUIDTools::UUID_URL_NAMESPACE, 'http://sporkmonger.com'
-    ).should be_valid
+    )).to be_valid
   end
 
   it "should not identify the nil UUID as valid" do
-    UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).should_not be_valid
+    expect(UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])).not_to be_valid
+  end
+
+  it "should not identify UUIDs prefixed by other strings as valid" do
+    expect do
+      UUIDTools::UUID.parse("bogus\n#{UUIDTools::UUID.random_create}")
+    end.to raise_error(ArgumentError)
+  end
+
+  it "should not identify UUIDs suffixed by other strings as valid" do
+    expect do
+      UUIDTools::UUID.parse("#{UUIDTools::UUID.random_create}\nbogus")
+    end.to raise_error(ArgumentError)
+  end
+
+  it "should parse v7 UUIDs as valid" do
+    expect(UUIDTools::UUID.parse("01957ca6-fc1a-7322-956e-e9e6c53cab55")).to be_valid
   end
 
   it "should allow for sorting of UUID arrays" do
@@ -69,59 +87,79 @@ describe UUIDTools::UUID, "when parsing" do
       uuids << UUIDTools::UUID.timestamp_create
     end
     uuids.sort!
-    uuids.first.should < uuids.last
-    uuids.last.should > uuids.first
+    expect(uuids.first).to be < uuids.last
+    expect(uuids.last).to be > uuids.first
   end
 
   it "should allow for comparison of UUIDs" do
-    UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).should <
+    expect(UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])).to be <
       UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 1])
-    UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 1]).should >
-      UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])
-    UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).should ==
+    expect(UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 1])).to be >
       UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])
+    expect(UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])).to eql(
+      UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]))
   end
 
   it "should produce the correct hexdigest for a UUID" do
-    UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).hexdigest.should ==
-      "00000000000000000000000000000000"
-    UUIDTools::UUID.new(1, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).hexdigest.should ==
-      "00000001000000000000000000000000"
-    UUIDTools::UUID.timestamp_create.hexdigest.size.should == 32
+    expect(UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).hexdigest).to eql(
+      '00000000000000000000000000000000')
+    expect(UUIDTools::UUID.new(1, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).hexdigest).to eql(
+      '00000001000000000000000000000000')
+    expect(UUIDTools::UUID.timestamp_create.hexdigest.size).to eql(32)
   end
 
   it "should produce a sane hash value for a UUID" do
     uuid = UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])
-    uuid.to_i.should == 0
-    uuid.hash.should be_kind_of(Fixnum)
+    expect(uuid.to_i).to eql(0)
+    expect(uuid.hash).to be_kind_of(Integer)
   end
 
   it "should produce the correct URI for a UUID" do
-    UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).to_uri.should ==
-      "urn:uuid:00000000-0000-0000-0000-000000000000"
+    expect(UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).to_uri).to eql(
+      'urn:uuid:00000000-0000-0000-0000-000000000000')
   end
 
   it "should correctly test UUID equality" do
-    UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).should be_eql(
+    expect(UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])).to eql(
       UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])
     )
   end
 
   it "should correctly parse integers" do
-    UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).should ==
-      UUIDTools::UUID.parse_int(0)
-    UUIDTools::UUID.parse_int(0).should be_nil_uuid
+    expect(UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])).to eql(
+      UUIDTools::UUID.parse_int(0))
+    expect(UUIDTools::UUID.parse_int(0)).to be_nil_uuid
     uuid = UUIDTools::UUID.timestamp_create
-    UUIDTools::UUID.parse_int(uuid.to_i).should == uuid
+    expect(UUIDTools::UUID.parse_int(uuid.to_i)).to eql(uuid)
   end
 
   it "should correctly parse hexdigests" do
-    UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0]).should ==
-      UUIDTools::UUID.parse_hexdigest("00000000000000000000000000000000")
-    UUIDTools::UUID.parse_hexdigest(
-      "00000000000000000000000000000000"
-    ).should be_nil_uuid
+    expect(UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])).to eql(
+      UUIDTools::UUID.parse_hexdigest('00000000000000000000000000000000'))
+    expect(UUIDTools::UUID.parse_hexdigest(
+      '00000000000000000000000000000000'
+    )).to be_nil_uuid
     uuid = UUIDTools::UUID.timestamp_create
-    UUIDTools::UUID.parse_hexdigest(uuid.hexdigest).should == uuid
+    expect(UUIDTools::UUID.parse_hexdigest(uuid.hexdigest)).to eql(uuid)
+  end
+
+  it "should correctly parse raw bytes" do
+    # NOTE: Short Input
+    expect(UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])).to eql(
+      UUIDTools::UUID.parse_raw(+"")
+    )
+
+    # NOTE: Nil Input
+    expect(
+      UUIDTools::UUID.parse_raw(+"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0")
+    ).to be_nil_uuid
+
+    # NOTE: Realistic Input
+    uuid = UUIDTools::UUID.timestamp_create
+    expect(UUIDTools::UUID.parse_raw(uuid.raw)).to eql(uuid)
+
+    # NOTE: Long input
+    raw192bit = "\1\2\3\4\5\6\7\8" + uuid.raw
+    expect(UUIDTools::UUID.parse_raw(raw192bit)).to eql(uuid)
   end
 end

data/tasks/benchmark.rake

@@ -1,38 +1,57 @@
 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."
+  $LOAD_PATH.unshift File.expand_path('../..', __FILE__)
+  require 'lib/uuidtools'
 
-  # 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
+  def format_float(float)
+    ("%.2f" % float).rjust(9, ' ')
   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
+  def format_result(result, action, iterations)
+    $stdout.puts "#{format_float(iterations / result.real)} | #{action}"
   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
+  def benchmark(name, n = 10000)
+    result = Benchmark.measure do
+      n.times { yield }
     end
+
+    format_result(result, name, n)
   end
-  puts "#{(10000.0 / result.real)} version 5 per second."
+
+  $stdout.puts ' x/second | Benchmark'
+  $stdout.puts '---------- -----------'
+
+  ##
+  # Benchmark UUID creation
+  namespace = UUIDTools::UUID_URL_NAMESPACE
+  url = "http://www.ietf.org/rfc/rfc4122.txt"
+
+  benchmark('Version 1') { UUIDTools::UUID.timestamp_create.to_s }
+  benchmark('Version 3') { UUIDTools::UUID.md5_create(namespace, url).to_s }
+  benchmark('Version 4') { UUIDTools::UUID.random_create.to_s }
+  benchmark('Version 5') { UUIDTools::UUID.sha1_create(namespace, url).to_s }
+
+  ## 
+  # Benchmark UUID parsing
+  uuid_s = UUIDTools::UUID.random_create.to_s
+  benchmark('UUID::parse', 40000) { UUIDTools::UUID.parse(uuid_s) }
+
+  uuid_raw = UUIDTools::UUID.random_create.raw
+  benchmark('UUID::parse_raw', 40000) { UUIDTools::UUID.parse_raw(uuid_raw) }
+
+  uuid_i = UUIDTools::UUID.random_create.to_i
+  benchmark('UUID::parse_int', 40000) { UUIDTools::UUID.parse_int(uuid_i) }
+
+  uuid_hex = UUIDTools::UUID.random_create.hexdigest
+  benchmark('UUID::parse_hexdigest', 40000) { UUIDTools::UUID.parse_hexdigest(uuid_hex) }
+
+  ##
+  # Benchmark UUID private api
+  byte_string = UUIDTools::UUID.timestamp_create.raw
+  benchmark('UUID::convert_byte_string_to_int') { UUIDTools::UUID.convert_byte_string_to_int(byte_string) }
+
+  bigint = UUIDTools::UUID.timestamp_create.to_i
+  benchmark('UUID::convert_int_to_byte_string') { UUIDTools::UUID.convert_int_to_byte_string(bigint, 16) }
 end

data/tasks/gem.rake

@@ -1,41 +1,54 @@
-require "rake/gempackagetask"
+require "rubygems/package_task"
+require "rake"
+require "rake/clean"
+
+CLOBBER.include("pkg")
 
 namespace :gem do
   GEM_SPEC = Gem::Specification.new do |s|
-    unless s.respond_to?(:add_development_dependency)
-      puts "The gem spec requires a newer version of RubyGems."
-      exit(1)
-    end
-
     s.name = PKG_NAME
     s.version = PKG_VERSION
     s.summary = PKG_SUMMARY
     s.description = PKG_DESCRIPTION
+    s.licenses = ["Apache-2.0"]
 
     s.files = PKG_FILES.to_a
 
-    s.has_rdoc = true
-    s.extra_rdoc_files = %w( README )
-    s.rdoc_options.concat ["--main",  "README"]
+    s.extra_rdoc_files = %w( README.md )
+    s.rdoc_options.concat ["--main",  "README.md"]
 
-    s.add_development_dependency("rake", ">= 0.8.3")
-    s.add_development_dependency("rspec", ">= 1.1.11")
-    s.add_development_dependency("launchy", ">= 0.3.2")
+    if !s.respond_to?(:add_development_dependency)
+      puts "Cannot build Gem with this version of RubyGems."
+      exit(1)
+    end
+
+    s.add_development_dependency("rake", ">= 0.7.3")
+    s.add_development_dependency("rspec", ">= 2.9.0")
+    s.add_development_dependency("yard", ">= 0.8.2")
+    s.add_development_dependency("launchy", ">= 2.0.0")
 
     s.require_path = "lib"
 
-    s.author = "Bob Aman"
-    s.email = "bob@sporkmonger.com"
-    s.homepage = "http://#{PKG_NAME}.rubyforge.org/"
-    s.rubyforge_project = RUBY_FORGE_PROJECT
+    s.author = PKG_AUTHOR
+    s.email = PKG_AUTHOR_EMAIL
+    s.homepage = PKG_HOMEPAGE
   end
 
-  Rake::GemPackageTask.new(GEM_SPEC) do |p|
+  Gem::PackageTask.new(GEM_SPEC) do |p|
     p.gem_spec = GEM_SPEC
     p.need_tar = true
     p.need_zip = true
   end
 
+  desc "Generates .gemspec file"
+  task :gemspec do
+    spec_string = GEM_SPEC.to_ruby
+
+    File.open("#{GEM_SPEC.name}.gemspec", "w") do |file|
+      file.write spec_string
+    end
+  end
+
   desc "Show information about the gem"
   task :debug do
     puts GEM_SPEC.to_ruby
@@ -65,4 +78,4 @@ end
 desc "Alias to gem:package"
 task "gem" => "gem:package"
 
-task "clobber" => ["gem:clobber_package"]
+task "gem:release" => "gem:gemspec"

data/tasks/rspec.rake

@@ -0,0 +1,55 @@
+require "rspec/core/rake_task"
+require "rake/clean"
+
+CLOBBER.include("coverage", "specdoc")
+
+namespace :spec do
+  RSpec::Core::RakeTask.new(:rcov) do |t|
+    t.pattern = FileList['spec/**/*_spec.rb']
+    t.rspec_opts = ['--color', '--format', 'documentation']
+
+    t.rcov_opts = [
+      '--exclude', 'lib\\/compat',
+      '--exclude', 'spec',
+      '--exclude', '\\.rvm\\/gems',
+      '--exclude', '1\\.8\\/gems',
+      '--exclude', '1\\.9\\/gems',
+      '--exclude', '\\.rvm',
+      '--exclude', '\\/Library\\/Ruby'
+    ]
+  end
+
+  RSpec::Core::RakeTask.new(:normal) do |t|
+    t.pattern = FileList['spec/**/*_spec.rb'].exclude(/compat/)
+    t.rspec_opts = ['--color', '--format', 'documentation']
+  end
+
+  RSpec::Core::RakeTask.new(:all) do |t|
+    t.pattern = FileList['spec/**/*_spec.rb']
+    t.rspec_opts = ['--color', '--format', 'documentation']
+  end
+
+  desc "Generate HTML Specdocs for all specs"
+  RSpec::Core::RakeTask.new(:specdoc) do |t|
+    specdoc_path = File.expand_path(
+      File.join(File.dirname(__FILE__), '..', 'documentation')
+    )
+    Dir.mkdir(specdoc_path) if !File.exist?(specdoc_path)
+
+    output_file = File.join(specdoc_path, 'index.html')
+    t.pattern = FileList['spec/**/*_spec.rb']
+    t.rspec_opts = ["--format", "\"html:#{output_file}\"", "--diff"]
+    t.fail_on_error = false
+  end
+
+  namespace :rcov do
+    desc "Browse the code coverage report."
+    task :browse => "spec:rcov" do
+      require "launchy"
+      Launchy::Browser.run("coverage/index.html")
+    end
+  end
+end
+
+desc "Alias to spec:normal"
+task "spec" => "spec:normal"

data/tasks/yard.rake

@@ -0,0 +1,22 @@
+require "rake"
+require "rake/clean"
+
+CLOBBER.include("doc")
+
+require "yard"
+require "yard/rake/yardoc_task"
+
+namespace :doc do
+  desc "Generate Yardoc documentation"
+  YARD::Rake::YardocTask.new do |yardoc|
+    yardoc.name = "yard"
+    yardoc.options = ["--verbose", "--markup", "markdown"]
+    yardoc.files = FileList[
+      "lib/**/*.rb", "ext/**/*.c",
+      "README.md", "CHANGELOG.md", "LICENSE.txt"
+    ].exclude(/idna/)
+  end
+end
+
+desc "Alias to doc:yard"
+task "doc" => "doc:yard"

data/uuidtools.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+# stub: uuidtools 3.0.0 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "uuidtools".freeze
+  s.version = "3.0.0".freeze
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib".freeze]
+  s.authors = ["Bob Aman".freeze]
+  s.date = "2025-03-09"
+  s.description = "A simple universally unique ID generation library.\n".freeze
+  s.email = "bob@sporkmonger.com".freeze
+  s.extra_rdoc_files = ["README.md".freeze]
+  s.files = ["CHANGELOG".freeze, "LICENSE.txt".freeze, "README.md".freeze, "Rakefile".freeze, "lib".freeze, "lib/compat".freeze, "lib/compat/securerandom.rb".freeze, "lib/uuidtools".freeze, "lib/uuidtools.rb".freeze, "lib/uuidtools/version.rb".freeze, "spec".freeze, "spec/spec.opts".freeze, "spec/spec_helper.rb".freeze, "spec/uuidtools".freeze, "spec/uuidtools/mac_address_spec.rb".freeze, "spec/uuidtools/utility_spec.rb".freeze, "spec/uuidtools/uuid_creation_spec.rb".freeze, "spec/uuidtools/uuid_parsing_spec.rb".freeze, "tasks".freeze, "tasks/benchmark.rake".freeze, "tasks/gem.rake".freeze, "tasks/git.rake".freeze, "tasks/metrics.rake".freeze, "tasks/rspec.rake".freeze, "tasks/yard.rake".freeze, "uuidtools.gemspec".freeze, "website".freeze, "website/index.html".freeze]
+  s.homepage = "https://github.com/sporkmonger/uuidtools".freeze
+  s.licenses = ["Apache-2.0".freeze]
+  s.rdoc_options = ["--main".freeze, "README.md".freeze]
+  s.rubygems_version = "3.6.3".freeze
+  s.summary = "UUID generator".freeze
+
+  s.specification_version = 4
+
+  s.add_development_dependency(%q<rake>.freeze, [">= 0.7.3".freeze])
+  s.add_development_dependency(%q<rspec>.freeze, [">= 2.9.0".freeze])
+  s.add_development_dependency(%q<yard>.freeze, [">= 0.8.2".freeze])
+  s.add_development_dependency(%q<launchy>.freeze, [">= 2.0.0".freeze])
+end

metadata

@@ -1,61 +1,86 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: uuidtools
-version: !ruby/object:Gem::Version 
-  version: 2.1.0
+version: !ruby/object:Gem::Version
+  version: 3.0.0
 platform: ruby
-authors: 
+authors:
 - Bob Aman
-autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2009-10-12 00:00:00 -04:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2025-03-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.7.3
   type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        version: 0.8.3
-    version: 
-- !ruby/object:Gem::Dependency 
+      - !ruby/object:Gem::Version
+        version: 0.7.3
+- !ruby/object:Gem::Dependency
   name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.9.0
   type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        version: 1.1.11
-    version: 
-- !ruby/object:Gem::Dependency 
+      - !ruby/object:Gem::Version
+        version: 2.9.0
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.2
+- !ruby/object:Gem::Dependency
   name: launchy
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
   type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        version: 0.3.2
-    version: 
-description: |
-  A simple universally unique ID generation library.
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+description: 'A simple universally unique ID generation library.
 
+  '
 email: bob@sporkmonger.com
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
-- README
-files: 
+extra_rdoc_files:
+- README.md
+files:
+- CHANGELOG
+- LICENSE.txt
+- README.md
+- Rakefile
 - lib/compat/securerandom.rb
-- lib/uuidtools/version.rb
 - lib/uuidtools.rb
+- lib/uuidtools/version.rb
 - spec/spec.opts
 - spec/spec_helper.rb
 - spec/uuidtools/mac_address_spec.rb
@@ -63,46 +88,34 @@ files:
 - spec/uuidtools/uuid_creation_spec.rb
 - spec/uuidtools/uuid_parsing_spec.rb
 - tasks/benchmark.rake
-- tasks/clobber.rake
 - tasks/gem.rake
 - tasks/git.rake
 - tasks/metrics.rake
-- tasks/rdoc.rake
-- tasks/rubyforge.rake
-- tasks/spec.rake
+- tasks/rspec.rake
+- tasks/yard.rake
+- uuidtools.gemspec
 - website/index.html
-- CHANGELOG
-- LICENSE
-- Rakefile
-- README
-has_rdoc: true
-homepage: http://uuidtools.rubyforge.org/
-licenses: []
-
-post_install_message: 
-rdoc_options: 
-- --main
-- README
-require_paths: 
+homepage: https://github.com/sporkmonger/uuidtools
+licenses:
+- Apache-2.0
+metadata: {}
+rdoc_options:
+- "--main"
+- README.md
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
+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'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-rubyforge_project: uuidtools
-rubygems_version: 1.3.4
-signing_key: 
-specification_version: 3
+rubygems_version: 3.6.3
+specification_version: 4
 summary: UUID generator
 test_files: []
-