uuidtools 2.1.4 → 2.1.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ebf635496c48e173f29b09b4719846a83ab15d19
+  data.tar.gz: cdf833d1f98797978853ee0d700277704ec9ad86
+SHA512:
+  metadata.gz: 33c70bffe56bd16152da53299f283067ec0087070a3b4a94347a01d30bceada03b879e3cf2df697e168deff94789c5c69933641f77707764d187debf52bad7e7
+  data.tar.gz: dd36f05b2ec9f696c6c1a1c413df01f0372e504be3c09d4db77340c7db3bd68253e326b835913ef2cf9f35fd534ccb777ea00d043b47a272da46a461607bc3fe

data/CHANGELOG

@@ -1,3 +1,7 @@
+== UUIDTools 2.1.5
+ * fixed issue with ip command vs ifconfig
+ * dumped RubyForge related cruft
+ * updated to modern RSpec syntax
 == UUIDTools 2.1.4
  * various OS-specific improvements to obtaining MAC address
 == UUIDTools 2.1.3

data/README.md

@@ -1,14 +1,15 @@
 # UUIDTools
 
 <dl>
-  <dt>Homepage</dt><dd><a href="http://uuidtools.rubyforge.org/">uuidtools.rubyforge.org</a></dd>
+  <dt>Homepage</dt><dd><a href="https://github.com/sporkmonger/uuidtools">sporkmonger/uuidtools</a></dd>
   <dt>Author</dt><dd><a href="mailto:bob@sporkmonger.com">Bob Aman</a></dd>
-  <dt>Copyright</dt><dd>Copyright © 2005-2012 Bob Aman</dd>
+  <dt>Copyright</dt><dd>Copyright © 2005-2014 Bob Aman</dd>
   <dt>License</dt><dd>Apache 2.0</dd>
 </dl>
 
 [![Build Status](https://secure.travis-ci.org/sporkmonger/uuidtools.png)](http://travis-ci.org/sporkmonger/uuidtools)
 [![Dependency Status](https://gemnasium.com/sporkmonger/uuidtools.png)](https://gemnasium.com/sporkmonger/uuidtools)
+[![Gittip Donate](http://img.shields.io/gittip/sporkmonger.png)](https://www.gittip.com/sporkmonger/ "Support Open Source Development w/ Gittip")
 
 # Description
 

data/Rakefile

@@ -10,11 +10,12 @@ PKG_FILE_NAME      = "#{PKG_NAME}-#{PKG_VERSION}"
 
 RELEASE_NAME       = "REL #{PKG_VERSION}"
 
-RUBY_FORGE_PROJECT = PKG_NAME
-RUBY_FORGE_USER    = "sporkmonger"
-RUBY_FORGE_PATH    = "/var/www/gforge-projects/#{RUBY_FORGE_PROJECT}"
-RUBY_FORGE_URL     = "http://#{RUBY_FORGE_PROJECT}.rubyforge.org/"
+GIT_HUB_USER       = "sporkmonger"
+GIT_HUB_URL        = "https://github.com/#{GIT_HUB_USER}/#{PKG_NAME}"
 
+PKG_AUTHOR         = "Bob Aman"
+PKG_AUTHOR_EMAIL   = "bob@sporkmonger.com"
+PKG_HOMEPAGE       = GIT_HUB_URL
 PKG_SUMMARY        = "UUID generator"
 PKG_DESCRIPTION    = <<-TEXT
 A simple universally unique ID generation library.

data/lib/uuidtools.rb

@@ -1,6 +1,6 @@
 # encoding:utf-8
 #--
-# Copyright (C) 2005-2012 Bob Aman
+# Copyright (C) 2005-2014 Bob Aman
 #
 #    Licensed under the Apache License, Version 2.0 (the "License");
 #    you may not use this file except in compliance with the License.
@@ -156,9 +156,7 @@ module UUIDTools
         raise TypeError,
           "Expected String, got #{uuid_string.class.name} instead."
       end
-      uuid_components = uuid_string.downcase.scan(
-        Regexp.new("^([0-9a-f]{8})-([0-9a-f]{4})-([0-9a-f]{4})-" +
-          "([0-9a-f]{2})([0-9a-f]{2})-([0-9a-f]{12})$")).first
+      uuid_components = uuid_string.downcase.scan(UUIDTools::UUID_REGEXP).first
       raise ArgumentError, "Invalid UUID format." if uuid_components.nil?
       time_low = uuid_components[0].to_i(16)
       time_mid = uuid_components[1].to_i(16)
@@ -395,6 +393,7 @@ module UUIDTools
     ##
     # Compares two UUIDs lexically
     def <=>(other_uuid)
+      return nil unless other_uuid.is_a?(UUIDTools::UUID)
       check = self.time_low <=> other_uuid.time_low
       return check if check != 0
       check = self.time_mid <=> other_uuid.time_mid
@@ -554,7 +553,7 @@ module UUIDTools
 
     #
     # Find the path of the ifconfig(8) command if it is present
-    # 
+    #
     def self.ifconfig_path
       path = `which #{UUID.ifconfig_command} 2>/dev/null`.strip
       path = UUID.ifconfig_path_default if (path == "" && File.exist?(UUID.ifconfig_path_default))
@@ -579,7 +578,7 @@ module UUIDTools
 
       # if it does not exist, try the ip command
       if ifconfig_path == nil
-        ifconfig_path = UUID.ip_path
+        ifconfig_path = "#{UUID.ip_path} addr list"
         # all makes no sense when using ip(1)
         all = nil
       end
@@ -607,9 +606,14 @@ module UUIDTools
       end
 
       mac = parse_mac.call(instring)
-      # expand octets that were compressed (solaris)
-      mac.split(':').map { |c| (c.length == 1 ? "0#{c}" : c)}.join(':')
-
+      if mac
+        # expand octets that were compressed (solaris)
+        return (mac.split(':').map do |octet|
+          (octet.length == 1 ? "0#{octet}" : octet)
+        end).join(':')
+      else
+        return nil
+      end
     end
 
     ##
@@ -618,7 +622,7 @@ module UUIDTools
     def self.mac_address
       if !defined?(@@mac_address)
         require 'rbconfig'
-        
+
         os_class = UUID.os_class
 
         if os_class == :windows
@@ -718,6 +722,11 @@ module UUIDTools
     end
   end
 
+  ##
+  # Constant Regexp that matches a UUID and captures its components.
+  UUID_REGEXP = Regexp.new("^([0-9a-f]{8})-([0-9a-f]{4})-([0-9a-f]{4})-" +
+                          "([0-9a-f]{2})([0-9a-f]{2})-([0-9a-f]{12})$")
+
   ##
   # Constant that represents the DNS namespace.
   UUID_DNS_NAMESPACE = UUID.parse("6ba7b810-9dad-11d1-80b4-00c04fd430c8")

data/lib/uuidtools/version.rb

@@ -1,6 +1,6 @@
 # encoding:utf-8
 #--
-# Copyright (C) 2005-2012 Bob Aman
+# Copyright (C) 2005-2014 Bob Aman
 #
 #    Licensed under the Apache License, Version 2.0 (the "License");
 #    you may not use this file except in compliance with the License.
@@ -22,7 +22,7 @@ unless defined? UUIDTools::VERSION
     module VERSION #:nodoc:
       MAJOR = 2
       MINOR = 1
-      TINY  = 4
+      TINY  = 5
 
       STRING = [MAJOR, MINOR, TINY].join('.')
     end

data/spec/uuidtools/mac_address_spec.rb

@@ -22,10 +22,10 @@ end
 #
 solaris_sample = <<EOF
 lo0: flags=2001000849<UP,LOOPBACK,RUNNING,MULTICAST,IPv4,VIRTUAL> mtu 8232 index 1
-        inet 127.0.0.1 netmask ff000000 
+        inet 127.0.0.1 netmask ff000000
 igb1: flags=1000843<UP,BROADCAST,RUNNING,MULTICAST,IPv4> mtu 1500 index 2
         inet 10.51.0.18 netmask ffffff00 broadcast 10.51.0.255
-        ether 0:21:28:fa:c6:65 
+        ether 0:21:28:fa:c6:65
 igb2: flags=1000843<UP,BROADCAST,RUNNING,MULTICAST,IPv4> mtu 1500 index 3
         inet 10.99.0.12 netmask ffffff00 broadcast 10.99.0.255
         ether 0:21:28:fa:c6:66
@@ -40,14 +40,14 @@ windows_sample = <<EOF
 Windows IP Configuration
 
         Host Name . . . . . . . . . . . . : OFFICE
-        Primary Dns Suffix  . . . . . . . : 
+        Primary Dns Suffix  . . . . . . . :
         Node Type . . . . . . . . . . . . : Unknown
         IP Routing Enabled. . . . . . . . : No
         WINS Proxy Enabled. . . . . . . . : No
 
 Ethernet adapter Local Area Connection:
 
-        Connection-specific DNS Suffix  . : 
+        Connection-specific DNS Suffix  . :
         Description . . . . . . . . . . . : Realtek PCIe GBE Family Controller
         Physical Address. . . . . . . . . : E0-CB-4E-5D-BC-E9
         Dhcp Enabled. . . . . . . . . . . : No
@@ -72,7 +72,7 @@ eth0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
         RX errors 0  dropped 0  overruns 0  frame 0
         TX packets 99075  bytes 23551085 (22.4 MiB)
         TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0
-        device interrupt 20  memory 0xf2600000-f2620000  
+        device interrupt 20  memory 0xf2600000-f2620000
 
 lo: flags=73<UP,LOOPBACK,RUNNING>  mtu 65536
         inet 127.0.0.1  netmask 255.0.0.0
@@ -95,35 +95,35 @@ eth0      Link encap:Ethernet  HWaddr 00:80:C8:F8:4A:51
           UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
           RX packets:190312 errors:0 dropped:0 overruns:0 frame:0
           TX packets:86955 errors:0 dropped:0 overruns:0 carrier:0
-          collisions:0 txqueuelen:100 
+          collisions:0 txqueuelen:100
           RX bytes:30701229 (29.2 Mb)  TX bytes:7878951 (7.5 Mb)
-          Interrupt:9 Base address:0x5000 
+          Interrupt:9 Base address:0x5000
 
-lo        Link encap:Local Loopback  
+lo        Link encap:Local Loopback
           inet addr:127.0.0.1  Mask:255.0.0.0
           UP LOOPBACK RUNNING  MTU:16436  Metric:1
           RX packets:306 errors:0 dropped:0 overruns:0 frame:0
           TX packets:306 errors:0 dropped:0 overruns:0 carrier:0
-          collisions:0 txqueuelen:0 
+          collisions:0 txqueuelen:0
           RX bytes:29504 (28.8 Kb)  TX bytes:29504 (28.8 Kb)
 EOF
 
 linux_mac_2 = "00:80:c8:f8:4a:51"
 
 linux_ip_sample = <<EOF
-1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN 
+1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN
     link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
     inet 127.0.0.1/8 scope host lo
-    inet6 ::1/128 scope host 
+    inet6 ::1/128 scope host
        valid_lft forever preferred_lft forever
 2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP qlen 1000
     link/ether 00:26:2d:f6:0b:94 brd ff:ff:ff:ff:ff:ff
     inet 10.16.187.125/22 brd 10.16.187.255 scope global eth0
-    inet6 fe80::226:2dff:fef6:b94/64 scope link 
+    inet6 fe80::226:2dff:fef6:b94/64 scope link
        valid_lft forever preferred_lft forever
 3: wlan0: <BROADCAST,MULTICAST> mtu 1500 qdisc mq state DOWN qlen 1000
     link/ether 00:26:c6:c6:1a:b4 brd ff:ff:ff:ff:ff:ff
-4: virbr0: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc noqueue state DOWN 
+4: virbr0: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc noqueue state DOWN
     link/ether 52:54:00:e3:cf:d3 brd ff:ff:ff:ff:ff:ff
     inet 192.168.122.1/24 brd 192.168.122.255 scope global virbr0
 5: virbr0-nic: <BROADCAST,MULTICAST> mtu 1500 qdisc pfifo_fast master virbr0 state DOWN qlen 500
@@ -139,14 +139,14 @@ freebsd_sample = <<EOF
 igb0: flags=8843<UP,BROADCAST,RUNNING,SIMPLEX,MULTICAST> metric 0 mtu 1500
         options=401bb<RXCSUM,TXCSUM,VLAN_MTU,VLAN_HWTAGGING,JUMBO_MTU,VLAN_HWCSUM,TSO4,VLAN_HWTSO>
         ether 00:25:90:2b:81:32
-        inet6 fe80::225:90ff:fe2b:8132%igb0 prefixlen 64 scopeid 0x1 
+        inet6 fe80::225:90ff:fe2b:8132%igb0 prefixlen 64 scopeid 0x1
         nd6 options=29<PERFORMNUD,IFDISABLED,AUTO_LINKLOCAL>
         media: Ethernet autoselect (1000baseT <full-duplex>)
         status: active
 igb1: flags=8843<UP,BROADCAST,RUNNING,SIMPLEX,MULTICAST> metric 0 mtu 1500
         options=401bb<RXCSUM,TXCSUM,VLAN_MTU,VLAN_HWTAGGING,JUMBO_MTU,VLAN_HWCSUM,TSO4,VLAN_HWTSO>
         ether 00:25:90:2b:81:32
-        inet6 fe80::225:90ff:fe2b:8133%igb1 prefixlen 64 scopeid 0x2 
+        inet6 fe80::225:90ff:fe2b:8133%igb1 prefixlen 64 scopeid 0x2
         nd6 options=29<PERFORMNUD,IFDISABLED,AUTO_LINKLOCAL>
         media: Ethernet autoselect (1000baseT <full-duplex>)
 EOF
@@ -180,24 +180,24 @@ openbsd_mac = "00:0d:b9:28:ab:44"
 macos_sample = <<EOF
 lo0: flags=8049<UP,LOOPBACK,RUNNING,MULTICAST> mtu 16384
 	options=3<RXCSUM,TXCSUM>
-	inet6 fe80::1%lo0 prefixlen 64 scopeid 0x1 
-	inet 127.0.0.1 netmask 0xff000000 
-	inet6 ::1 prefixlen 128 
+	inet6 fe80::1%lo0 prefixlen 64 scopeid 0x1
+	inet 127.0.0.1 netmask 0xff000000
+	inet6 ::1 prefixlen 128
 gif0: flags=8010<POINTOPOINT,MULTICAST> mtu 1280
 stf0: flags=0<> mtu 1280
 en0: flags=8963<UP,BROADCAST,SMART,RUNNING,PROMISC,SIMPLEX,MULTICAST> mtu 1500
 	options=27<RXCSUM,TXCSUM,VLAN_MTU,TSO4>
-	ether 58:b0:35:a4:cd:0c 
-	inet6 fe80::5ab0:35ff:fea4:cd0c%en0 prefixlen 64 scopeid 0x4 
+	ether 58:b0:35:a4:cd:0c
+	inet6 fe80::5ab0:35ff:fea4:cd0c%en0 prefixlen 64 scopeid 0x4
 	inet 192.168.142.136 netmask 0xfffffff0 broadcast 192.168.142.143
 	media: autoselect (1000baseT <full-duplex,flow-control>)
 	status: active
 en1: flags=8823<UP,BROADCAST,SMART,SIMPLEX,MULTICAST> mtu 1500
-	ether d8:30:62:51:dd:3d 
+	ether d8:30:62:51:dd:3d
 	media: autoselect (<unknown type>)
 	status: inactive
 p2p0: flags=8802<BROADCAST,SIMPLEX,MULTICAST> mtu 2304
-	ether 0a:30:62:51:dd:3d 
+	ether 0a:30:62:51:dd:3d
 	media: autoselect
 	status: inactive
 EOF
@@ -205,7 +205,7 @@ EOF
 macos_mac = "58:b0:35:a4:cd:0c"
 
 # Gather the samples and MAC addresses for simple access
-samples = { 
+samples = {
   :macos => macos_sample,
   :windows => windows_sample,
   :solaris => solaris_sample,
@@ -240,14 +240,13 @@ describe UUIDTools::UUID, "when obtaining a MAC address" do
 
   it "should obtain a MAC address" do
     pending_if_root_required()
-    @mac_address.should_not be_nil
+    expect(@mac_address).not_to be_nil
   end
 
   it "should cache the MAC address" do
     pending_if_root_required()
-    @mac_address.object_id.should == UUIDTools::UUID.mac_address.object_id
+    expect(@mac_address.object_id).to eql(UUIDTools::UUID.mac_address.object_id)
   end
-
 end
 
 describe UUIDTools::UUID, "before obtaining a MAC address" do
@@ -262,51 +261,51 @@ describe UUIDTools::UUID, "before obtaining a MAC address" do
 
   it "should parse windows MAC addresses" do
     # mock ifconfig() to return the windows sample
-    UUIDTools::UUID.stub(:ifconfig).and_return(samples[:windows])
+    allow(UUIDTools::UUID).to receive(:ifconfig) { samples[:windows] }
     mac = UUIDTools::UUID.mac_address
-    mac.should be == macs[:windows]
+    expect(mac).to eql(macs[:windows])
   end
 
   it "should parse solaris MAC addresses" do
-    UUIDTools::UUID.stub(:ifconfig).and_return(samples[:solaris])
+    allow(UUIDTools::UUID).to receive(:ifconfig) { samples[:solaris] }
     mac = UUIDTools::UUID.mac_address
-    mac.should be == macs[:solaris]
+    expect(mac).to eql(macs[:solaris])
   end
 
   it "should parse freebsd MAC addresses" do
-    UUIDTools::UUID.stub(:ifconfig).and_return(samples[:freebsd])
+    allow(UUIDTools::UUID).to receive(:ifconfig) { samples[:freebsd] }
     mac = UUIDTools::UUID.mac_address
-    mac.should be == macs[:freebsd]
+    expect(mac).to eql(macs[:freebsd])
   end
 
   it "should parse openbsd MAC addresses" do
-    UUIDTools::UUID.stub(:ifconfig).and_return(samples[:openbsd])
+    allow(UUIDTools::UUID).to receive(:ifconfig) { samples[:openbsd] }
     mac = UUIDTools::UUID.mac_address
-    mac.should be == macs[:openbsd]
+    expect(mac).to eql(macs[:openbsd])
   end
 
   it "should parse linux MAC addresses with ifconfig" do
-    UUIDTools::UUID.stub(:ifconfig).and_return(samples[:linux])
+    allow(UUIDTools::UUID).to receive(:ifconfig) { samples[:linux] }
     mac = UUIDTools::UUID.mac_address
-    mac.should be == macs[:linux]
+    expect(mac).to eql(macs[:linux])
   end
 
   it "should parse a linux HWaddr address with ifconfig" do
-    UUIDTools::UUID.stub(:ifconfig).and_return(samples[:linux2])
+    allow(UUIDTools::UUID).to receive(:ifconfig) { samples[:linux2] }
     mac = UUIDTools::UUID.mac_address
-    mac.should be == macs[:linux2]
+    expect(mac).to eql(macs[:linux2])
   end
 
   it "should parse macos MAC addresses with ifconfig" do
-    UUIDTools::UUID.stub(:ifconfig).and_return(samples[:macos])
+    allow(UUIDTools::UUID).to receive(:ifconfig) { samples[:macos] }
     mac = UUIDTools::UUID.mac_address
-    mac.should be == macs[:macos]
+    expect(mac).to eql(macs[:macos])
   end
 
   it "should parse linux MAC addresses with ip" do
-    UUIDTools::UUID.stub(:ifconfig).and_return(samples[:linuxip])
+    allow(UUIDTools::UUID).to receive(:ifconfig) { samples[:linuxip] }
     mac = UUIDTools::UUID.mac_address
-    mac.should be == macs[:linuxip]
+    expect(mac).to eql(macs[:linuxip])
   end
 
   it "should identify the default os classes" do
@@ -315,15 +314,15 @@ describe UUIDTools::UUID, "before obtaining a MAC address" do
     end
 
     os_class = UUIDTools::UUID.os_class
-    os_class.should be == nil
+    expect(os_class).to be_nil
 
     RbConfig::CONFIG['target_os'] = 'linux'
     os_class = UUIDTools::UUID.os_class
-    os_class.should be == nil
+    expect(os_class).to be_nil
 
     RbConfig::CONFIG['target_os'] = 'darwin'
     os_class = UUIDTools::UUID.os_class
-    os_class.should be == nil
+    expect(os_class).to be_nil
   end
 
   it "should identify the solaris os classes" do
@@ -332,7 +331,7 @@ describe UUIDTools::UUID, "before obtaining a MAC address" do
     end
 
     os_class = UUIDTools::UUID.os_class
-    os_class.should be == :solaris
+    expect(os_class).to eql(:solaris)
   end
 
   it "should identify the BSD os classes" do
@@ -341,11 +340,11 @@ describe UUIDTools::UUID, "before obtaining a MAC address" do
     end
 
     os_class = UUIDTools::UUID.os_class
-    os_class.should be == :netbsd
+    expect(os_class).to eql(:netbsd)
 
     RbConfig::CONFIG['target_os'] = "openbsd"
     os_class = UUIDTools::UUID.os_class
-    os_class.should be == :openbsd
+    expect(os_class).to eql(:openbsd)
 
   end
 
@@ -354,15 +353,15 @@ describe UUIDTools::UUID, "before obtaining a MAC address" do
       CONFIG['target_os'] = "win"
     end
     os_class = UUIDTools::UUID.os_class
-    os_class.should be == :windows
+    expect(os_class).to eql(:windows)
 
     RbConfig::CONFIG['target_os'] = "w32"
     os_class = UUIDTools::UUID.os_class
-    os_class.should be == :windows
+    expect(os_class).to eql(:windows)
 
     RbConfig::CONFIG['target_os'] = "darwin"
     os_class = UUIDTools::UUID.os_class
-    os_class.should be == nil
+    expect(os_class).to be_nil
 
   end
 
@@ -374,17 +373,17 @@ describe UUIDTools::UUID, "before obtaining a MAC address" do
     UUIDTools::UUID.ifconfig_command="sh"
     UUIDTools::UUID.ifconfig_path_default="notfound"
     ifconfig_path = UUIDTools::UUID.ifconfig_path
-#    ifconfig_path.should be == "/usr/bin/sh"
+#    expect(ifconfig_path).to eql("/usr/bin/sh")
 
     # Test what happens if it does not
     UUIDTools::UUID.ifconfig_command="nosuchthing"
     UUIDTools::UUID.ifconfig_path_default="default"
-    
+
     # ifconfig_path checks if the IFCONFIG_PATH command file exists
-    File.stub(:exist?).and_return(true)
+    allow(File).to receive(:exist?) { true }
 
     ifconfig_path = UUIDTools::UUID.ifconfig_path
-#    ifconfig_path.should be == "default"
+#    expect(ifconfig_path).to eql("default")
 
     UUIDTools::UUID.ifconfig_command=save_ifconfig_command
     UUIDTools::UUID.ifconfig_path_default=save_ifconfig_path
@@ -399,61 +398,57 @@ describe UUIDTools::UUID, "before obtaining a MAC address" do
     UUIDTools::UUID.ip_command="sh"
     UUIDTools::UUID.ip_path_default="notfound"
     ip_path = UUIDTools::UUID.ip_path
-#    ip_path.should be == "/usr/bin/sh"
+#    expect(ip_path).to eql("/usr/bin/sh")
 
     # Test what happens if it does not
     UUIDTools::UUID.ip_command="nosuchthing"
     UUIDTools::UUID.ip_path_default="default"
-    
+
     # ifconfig_path checks if the IP_PATH command file exists
-    File.stub(:exist?).and_return(true)
+    allow(File).to receive(:exist?) { true }
 
     ifconfig_path = UUIDTools::UUID.ip_path
-#    ifconfig_path.should be == "default"
+#    expect(ifconfig_path).to eql("default")
 
     UUIDTools::UUID.ip_command=save_ip_command
     UUIDTools::UUID.ip_path_default=save_ip_path
   end
 
-  it "should return the output of the ifconfig program" do
-    pending "I'm not quite sure how to mock backticks"
-  end
-
   it "should be able to parse windows ipconfig output" do
     mac = UUIDTools::UUID.first_mac samples[:windows]
-    mac.should be == macs[:windows]
+    expect(mac).to eql(macs[:windows])
   end
 
   it "should be able to parse solaris ifconfig output" do
     mac = UUIDTools::UUID.first_mac samples[:solaris]
-    mac.should be == macs[:solaris]
+    expect(mac).to eql(macs[:solaris])
   end
 
   it "should be able to parse freebsd ifconfig output" do
     mac = UUIDTools::UUID.first_mac samples[:freebsd]
-    mac.should be == macs[:freebsd]
+    expect(mac).to eql(macs[:freebsd])
   end
 
   it "should be able to parse openbsd ifconfig output" do
     mac = UUIDTools::UUID.first_mac samples[:openbsd]
-    mac.should be == macs[:openbsd]
+    expect(mac).to eql(macs[:openbsd])
   end
 
   it "should be able to parse linux ifconfig output" do
     mac = UUIDTools::UUID.first_mac samples[:linux]
-    mac.should be == macs[:linux]
+    expect(mac).to eql(macs[:linux])
 
     mac2 = UUIDTools::UUID.first_mac samples[:linux2]
-    mac2.should be == macs[:linux2]
+    expect(mac2).to eql(macs[:linux2])
   end
 
   it "should be able to parse macos ifconfig output" do
     mac = UUIDTools::UUID.first_mac samples[:macos]
-    mac.should be == macs[:macos]
+    expect(mac).to eql(macs[:macos])
   end
 
   it "should be able to parse ip addr output" do
     mac = UUIDTools::UUID.first_mac samples[:linuxip]
-    mac.should be == macs[:linuxip]
+    expect(mac).to eql(macs[:linuxip])
   end
 end

data/spec/uuidtools/utility_spec.rb

@@ -7,15 +7,15 @@ describe SecureRandom do
       bits << SecureRandom.random_bytes(16)
     end
     # Check to make sure that none of the 10,000 strings were duplicates
-    (bits.map {|x| x.to_s}).uniq.size.should == bits.size
+    expect((bits.map {|x| x.to_s}).uniq.size).to eql(bits.size)
   end
 
   it "should return the correct number of random bits" do
-    SecureRandom.random_bytes(16).size.should == 16
-    SecureRandom.random_bytes(6).size.should == 6
+    expect(SecureRandom.random_bytes(16).size).to eql(16)
+    expect(SecureRandom.random_bytes(6).size).to eql(6)
   end
 
   it "should return a sane random number" do
-    SecureRandom.random_number(5000).should < 5000
+    expect(SecureRandom.random_number(5000)).to be < 5000
   end
 end

data/spec/uuidtools/uuid_creation_spec.rb

@@ -2,36 +2,38 @@ require File.expand_path("../../spec_helper.rb", __FILE__)
 
 describe UUIDTools::UUID, "when generating" do
   it "should correctly generate SHA1 variant UUIDs" do
-    UUIDTools::UUID.sha1_create(
+    expect(UUIDTools::UUID.sha1_create(
       UUIDTools::UUID_URL_NAMESPACE, 'http://sporkmonger.com'
-    ).to_s.should == "f2d04685-b787-55da-8644-9bd28a6f5a53"
+    ).to_s).to eql('f2d04685-b787-55da-8644-9bd28a6f5a53')
   end
 
   it "should correctly generate MD5 variant UUIDs" do
-    UUIDTools::UUID.md5_create(
+    expect(UUIDTools::UUID.md5_create(
       UUIDTools::UUID_URL_NAMESPACE, 'http://sporkmonger.com'
-    ).to_s.should == "15074785-9071-3fe3-89bd-876e4b9e919b"
+    ).to_s).to eql('15074785-9071-3fe3-89bd-876e4b9e919b')
   end
 
   it "should correctly generate timestamp variant UUIDs" do
-    UUIDTools::UUID.timestamp_create.should_not be_random_node_id
-    UUIDTools::UUID.timestamp_create.to_s.should_not ==
+    expect(UUIDTools::UUID.timestamp_create).not_to be_random_node_id
+    expect(UUIDTools::UUID.timestamp_create.to_s).not_to eql(
       UUIDTools::UUID.timestamp_create.to_s
+    )
     current_time = Time.now
-    UUIDTools::UUID.timestamp_create(current_time).to_s.should_not ==
+    expect(UUIDTools::UUID.timestamp_create(current_time).to_s).not_to eql(
       UUIDTools::UUID.timestamp_create(current_time).to_s
+    )
     uuids = []
     1000.times do
       uuids << UUIDTools::UUID.timestamp_create
     end
     # Check to make sure that none of the 1,000 UUIDs were duplicates
-    (uuids.map {|x| x.to_s}).uniq.size.should == uuids.size
+    expect((uuids.map {|x| x.to_s}).uniq.size).to eql(uuids.size)
   end
 
   it "should correctly generate UUIDs without a MAC address" do
     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 = mac_address
   end
 
@@ -41,88 +43,88 @@ describe UUIDTools::UUID, "when generating" do
       uuids << UUIDTools::UUID.random_create
     end
     # Check to make sure that none of the 1,000 UUIDs were duplicates
-    (uuids.map {|x| x.to_s}).uniq.size.should == uuids.size
+    expect((uuids.map {|x| x.to_s}).uniq.size).to eql(uuids.size)
   end
 
   it "should not have internal state used in string representations" do
     uuid = UUIDTools::UUID.random_create
     uuid_string = uuid.to_s.dup
     uuid.to_s.gsub!("-", "/")
-    uuid.to_s.should == uuid_string
+    expect(uuid.to_s).to eql(uuid_string)
   end
 
   it "should throw an exception if a segment has an invalid value" do
-    (lambda do
+    expect(lambda do
       UUIDTools::UUID.new(-1, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])
-    end).should raise_error(ArgumentError)
-    (lambda do
+    end).to raise_error(ArgumentError)
+    expect(lambda do
       UUIDTools::UUID.new(4294967296, 0, 0, 0, 0, [0, 0, 0, 0, 0, 0])
-    end).should raise_error(ArgumentError)
+    end).to raise_error(ArgumentError)
   end
 
   it "should throw an exception if a segment has an invalid value" do
-    (lambda do
+    expect(lambda do
       UUIDTools::UUID.new(0, -1, 0, 0, 0, [0, 0, 0, 0, 0, 0])
-    end).should raise_error(ArgumentError)
-    (lambda do
+    end).to raise_error(ArgumentError)
+    expect(lambda do
       UUIDTools::UUID.new(0, 65536, 0, 0, 0, [0, 0, 0, 0, 0, 0])
-    end).should raise_error(ArgumentError)
+    end).to raise_error(ArgumentError)
   end
 
   it "should throw an exception if a segment has an invalid value" do
-    (lambda do
+    expect(lambda do
       UUIDTools::UUID.new(0, 0, -1, 0, 0, [0, 0, 0, 0, 0, 0])
-    end).should raise_error(ArgumentError)
-    (lambda do
+    end).to raise_error(ArgumentError)
+    expect(lambda do
       UUIDTools::UUID.new(0, 0, 65536, 0, 0, [0, 0, 0, 0, 0, 0])
-    end).should raise_error(ArgumentError)
+    end).to raise_error(ArgumentError)
   end
 
   it "should throw an exception if a segment has an invalid value" do
-    (lambda do
+    expect(lambda do
       UUIDTools::UUID.new(0, 0, 0, -1, 0, [0, 0, 0, 0, 0, 0])
-    end).should raise_error(ArgumentError)
-    (lambda do
+    end).to raise_error(ArgumentError)
+    expect(lambda do
       UUIDTools::UUID.new(0, 0, 0, 256, 0, [0, 0, 0, 0, 0, 0])
-    end).should raise_error(ArgumentError)
+    end).to raise_error(ArgumentError)
   end
 
   it "should throw an exception if a segment has an invalid value" do
-    (lambda do
+    expect(lambda do
       UUIDTools::UUID.new(0, 0, 0, 0, -1, [0, 0, 0, 0, 0, 0])
-    end).should raise_error(ArgumentError)
-    (lambda do
+    end).to raise_error(ArgumentError)
+    expect(lambda do
       UUIDTools::UUID.new(0, 0, 0, 0, 256, [0, 0, 0, 0, 0, 0])
-    end).should raise_error(ArgumentError)
+    end).to raise_error(ArgumentError)
   end
 
   it "should throw an exception if nodes are not a collection" do
-    (lambda do
+    expect(lambda do
       UUIDTools::UUID.new(0, 0, 0, 0, 0, :bogus)
-    end).should raise_error(TypeError)
+    end).to raise_error(TypeError)
   end
 
   it "should throw an exception if nodes are the wrong size" do
-    (lambda do
+    expect(lambda do
       UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0])
-    end).should raise_error(ArgumentError)
+    end).to raise_error(ArgumentError)
   end
 
   it "should throw an exception if any nodes have invalid values" do
-    (lambda do
+    expect(lambda do
       UUIDTools::UUID.new(0, 0, 0, 0, 0, [0, 0, 0, 0, 0, 256])
-    end).should raise_error(ArgumentError)
+    end).to raise_error(ArgumentError)
   end
 
   it "should throw an exception if parsing anything but a String" do
-    (lambda do
+    expect(lambda do
       UUIDTools::UUID.parse(:bogus)
-    end).should raise_error(TypeError)
+    end).to raise_error(TypeError)
   end
 
   it "should throw an exception if raw parsing anything but a String" do
-    (lambda do
+    expect(lambda do
       UUIDTools::UUID.parse_raw(:bogus)
-    end).should raise_error(TypeError)
+    end).to raise_error(TypeError)
   end
 end

data/spec/uuidtools/uuid_parsing_spec.rb

@@ -2,65 +2,66 @@ 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
+    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 allow for sorting of UUID arrays" do
@@ -69,59 +70,59 @@ 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(Fixnum)
   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
 end

data/tasks/gem.rake

@@ -28,9 +28,9 @@ namespace :gem do
 
     s.require_path = "lib"
 
-    s.author = "Bob Aman"
-    s.email = "bob@sporkmonger.com"
-    s.homepage = RUBY_FORGE_URL
+    s.author = PKG_AUTHOR
+    s.email = PKG_AUTHOR_EMAIL
+    s.homepage = PKG_HOMEPAGE
   end
 
   Gem::PackageTask.new(GEM_SPEC) do |p|

data/tasks/rspec.rake

@@ -8,7 +8,6 @@ namespace :spec do
     t.pattern = FileList['spec/**/*_spec.rb']
     t.rspec_opts = ['--color', '--format', 'documentation']
 
-    t.rcov = true
     t.rcov_opts = [
       '--exclude', 'lib\\/compat',
       '--exclude', 'spec',
@@ -23,13 +22,11 @@ namespace :spec do
   RSpec::Core::RakeTask.new(:normal) do |t|
     t.pattern = FileList['spec/**/*_spec.rb'].exclude(/compat/)
     t.rspec_opts = ['--color', '--format', 'documentation']
-    t.rcov = false
   end
 
   RSpec::Core::RakeTask.new(:all) do |t|
     t.pattern = FileList['spec/**/*_spec.rb']
     t.rspec_opts = ['--color', '--format', 'documentation']
-    t.rcov = false
   end
 
   desc "Generate HTML Specdocs for all specs"

metadata

@@ -1,89 +1,83 @@
 --- !ruby/object:Gem::Specification
 name: uuidtools
 version: !ruby/object:Gem::Version
-  version: 2.1.4
-  prerelease: 
+  version: 2.1.5
 platform: ruby
 authors:
 - Bob Aman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-25 00:00:00.000000000 Z
+date: 2014-08-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.7.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.7.3
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.9.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.9.0
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.8.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.8.2
 - !ruby/object:Gem::Dependency
   name: launchy
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.0.0
-description: ! 'A simple universally unique ID generation library.
-
-'
+description: |
+  A simple universally unique ID generation library.
 email: bob@sporkmonger.com
 executables: []
 extensions: []
 extra_rdoc_files:
 - README.md
 files:
+- CHANGELOG
+- LICENSE.txt
+- README.md
+- Rakefile
 - lib/compat/securerandom.rb
 - lib/uuidtools.rb
 - lib/uuidtools/version.rb
@@ -98,37 +92,31 @@ files:
 - tasks/git.rake
 - tasks/metrics.rake
 - tasks/rspec.rake
-- tasks/rubyforge.rake
 - tasks/yard.rake
 - website/index.html
-- CHANGELOG
-- LICENSE.txt
-- README.md
-- Rakefile
-homepage: http://uuidtools.rubyforge.org/
+homepage: https://github.com/sporkmonger/uuidtools
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options:
-- --main
+- "--main"
 - README.md
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: UUID generator
 test_files: []

data/tasks/rubyforge.rake

@@ -1,89 +0,0 @@
-namespace :gem do
-  desc 'Package and upload to RubyForge'
-  task :release => ["gem:package"] do |t|
-    require 'rubyforge'
-
-    v = ENV['VERSION'] or abort 'Must supply VERSION=x.y.z'
-    abort "Versions don't match #{v} vs #{PROJ.version}" if v != PKG_VERSION
-    pkg = "pkg/#{GEM_SPEC.full_name}"
-
-    rf = RubyForge.new
-    rf.configure
-    puts 'Logging in...'
-    rf.login
-
-    c = rf.userconfig
-    changelog = File.open("CHANGELOG") { |file| file.read }
-    c['release_changes'] = changelog
-    c['preformatted'] = true
-
-    files = ["#{pkg}.tgz", "#{pkg}.zip", "#{pkg}.gem"]
-
-    puts "Releasing #{PKG_NAME} v. #{PKG_VERSION}"
-    rf.add_release RUBY_FORGE_PROJECT, PKG_NAME, PKG_VERSION, *files
-  end
-end
-
-namespace :doc do
-  desc "Publish RDoc to RubyForge"
-  task :release => ["doc:yard"] do
-    require "rake/contrib/sshpublisher"
-    require "yaml"
-
-    config = YAML.load(
-      File.read(File.expand_path('~/.rubyforge/user-config.yml'))
-    )
-    host = "#{config['username']}@rubyforge.org"
-    remote_dir = RUBY_FORGE_PATH + "/api"
-    local_dir = "doc"
-    Rake::SshDirPublisher.new(host, remote_dir, local_dir).upload
-  end
-end
-
-namespace :spec do
-  desc "Publish specdoc to RubyForge"
-  task :release => ["spec:specdoc"] do
-    require "rake/contrib/sshpublisher"
-    require "yaml"
-
-    config = YAML.load(
-      File.read(File.expand_path('~/.rubyforge/user-config.yml'))
-    )
-    host = "#{config['username']}@rubyforge.org"
-    remote_dir = RUBY_FORGE_PATH + "/specdoc"
-    local_dir = "specdoc"
-    Rake::SshDirPublisher.new(host, remote_dir, local_dir).upload
-  end
-
-  namespace :rcov do
-    desc "Publish coverage report to RubyForge"
-    task :release => ["spec:rcov"] do
-      require "rake/contrib/sshpublisher"
-      require "yaml"
-
-      config = YAML.load(
-        File.read(File.expand_path('~/.rubyforge/user-config.yml'))
-      )
-      host = "#{config['username']}@rubyforge.org"
-      remote_dir = RUBY_FORGE_PATH + "/coverage"
-      local_dir = "coverage"
-      Rake::SshDirPublisher.new(host, remote_dir, local_dir).upload
-    end
-  end
-end
-
-namespace :website do
-  desc "Publish website to RubyForge"
-  task :release => ["doc:release", "spec:release", "spec:rcov:release"] do
-    require "rake/contrib/sshpublisher"
-    require "yaml"
-
-    config = YAML.load(
-      File.read(File.expand_path('~/.rubyforge/user-config.yml'))
-    )
-    host = "#{config['username']}@rubyforge.org"
-    remote_dir = RUBY_FORGE_PATH
-    local_dir = "website"
-    Rake::SshDirPublisher.new(host, remote_dir, local_dir).upload
-  end
-end