uv-rays 0.0.1 → 0.2.0

data/spec/scheduler_cron_spec.rb

@@ -1,19 +1,19 @@
 require 'uv-rays'
 
-describe UvRays::Scheduler::CronLine do
+describe UV::Scheduler::CronLine do
 
     def cl(cronline_string)
-        UvRays::Scheduler::CronLine.new(cronline_string)
+        UV::Scheduler::CronLine.new(cronline_string)
     end
 
     def match(line, time)
-        cl(line).matches?(time).should == true
+        expect(cl(line).matches?(time)).to eq(true)
     end
     def no_match(line, time)
-        cl(line).matches?(time).should == false
+        expect(cl(line).matches?(time)).to eq(false)
     end
     def to_a(line, array)
-        cl(line).to_array.should == array
+        expect(cl(line).to_array).to eq(array)
     end
     def local(*args)
         Time.local(*args)
@@ -58,17 +58,17 @@ describe UvRays::Scheduler::CronLine do
 
         it 'rejects invalid weekday expressions' do
 
-            lambda { cl '0 17 * * MON_FRI' }.should raise_error
+            expect  { cl '0 17 * * MON_FRI' }.to raise_error
                 # underline instead of dash
 
-            lambda { cl '* * * * 9' }.should raise_error
-            lambda { cl '* * * * 0-12' }.should raise_error
-            lambda { cl '* * * * BLABLA' }.should raise_error
+            expect  { cl '* * * * 9' }.to raise_error
+            expect  { cl '* * * * 0-12' }.to raise_error
+            expect  { cl '* * * * BLABLA' }.to raise_error
         end
 
         it 'rejects invalid cronlines' do
 
-            lambda { cl '* nada * * 9' }.should raise_error(ArgumentError)
+            expect  { cl '* nada * * 9' }.to raise_error(ArgumentError)
         end
 
         it 'interprets cron strings with TZ correctly' do
@@ -83,8 +83,8 @@ describe UvRays::Scheduler::CronLine do
                 '* * * * * * America/New_York',
                 [ nil, nil, nil, nil, nil, nil, nil, 'America/New_York' ])
 
-            lambda { cl '* * * * * NotATimeZone' }.should raise_error
-            lambda { cl '* * * * * * NotATimeZone' }.should raise_error
+            expect  { cl '* * * * * NotATimeZone' }.to raise_error
+            expect  { cl '* * * * * * NotATimeZone' }.to raise_error
         end
 
         it 'interprets cron strings with / (slashes) correctly' do
@@ -117,9 +117,9 @@ describe UvRays::Scheduler::CronLine do
 
         it 'does not support ranges for monthdays (sun#1-sun#2)' do
 
-            lambda {
-                UvRays::Scheduler::CronLine.new('* * * * sun#1-sun#2')
-            }.should raise_error(ArgumentError)
+            expect {
+                UV::Scheduler::CronLine.new('* * * * sun#1-sun#2')
+            }.to raise_error(ArgumentError)
         end
 
         it 'accepts items with initial 0' do
@@ -142,27 +142,27 @@ describe UvRays::Scheduler::CronLine do
 
         it 'does not support ranges for L' do
 
-            lambda { cl '* * 15-L * *'}.should raise_error(ArgumentError)
-            lambda { cl '* * L/4 * *'}.should raise_error(ArgumentError)
+            expect  { cl '* * 15-L * *'}.to raise_error(ArgumentError)
+            expect  { cl '* * L/4 * *'}.to raise_error(ArgumentError)
         end
 
         it 'does not support multiple Ls' do
 
-            lambda { cl '* * L,L * *'}.should raise_error(ArgumentError)
+            expect  { cl '* * L,L * *'}.to raise_error(ArgumentError)
         end
 
         it 'raises if L is used for something else than days' do
 
-            lambda { cl '* L * * *'}.should raise_error(ArgumentError)
+            expect  { cl '* L * * *'}.to raise_error(ArgumentError)
         end
 
         it 'raises for out of range input' do
 
-            lambda { cl '60-62 * * * *'}.should raise_error(ArgumentError)
-            lambda { cl '62 * * * *'}.should raise_error(ArgumentError)
-            lambda { cl '60 * * * *'}.should raise_error(ArgumentError)
-            lambda { cl '* 25-26 * * *'}.should raise_error(ArgumentError)
-            lambda { cl '* 25 * * *'}.should raise_error(ArgumentError)
+            expect  { cl '60-62 * * * *'}.to raise_error(ArgumentError)
+            expect  { cl '62 * * * *'}.to raise_error(ArgumentError)
+            expect  { cl '60 * * * *'}.to raise_error(ArgumentError)
+            expect  { cl '* 25-26 * * *'}.to raise_error(ArgumentError)
+            expect  { cl '* 25 * * *'}.to raise_error(ArgumentError)
                 #
                 # as reported by Aimee Rose in
                 # https://github.com/jmettraux/rufus-scheduler/pull/58
@@ -172,66 +172,66 @@ describe UvRays::Scheduler::CronLine do
     describe '#next_time' do
 
         def nt(cronline, now)
-            UvRays::Scheduler::CronLine.new(cronline).next_time(now)
+            UV::Scheduler::CronLine.new(cronline).next_time(now)
         end
 
         it 'computes the next occurence correctly' do
 
             now = Time.at(0).getutc # Thu Jan 01 00:00:00 UTC 1970
 
-            nt('* * * * *', now).should == now + 60
-            nt('* * * * sun', now).should == now + 259200
-            nt('* * * * * *', now).should == now + 1
-            nt('* * 13 * fri', now).should == now + 3715200
+            expect(nt('* * * * *', now)).to eq(now + 60)
+            expect(nt('* * * * sun', now)).to eq(now + 259200)
+            expect(nt('* * * * * *', now)).to eq(now + 1)
+            expect(nt('* * 13 * fri', now)).to eq(now + 3715200)
 
-            nt('10 12 13 12 *', now).should == now + 29938200
+            expect(nt('10 12 13 12 *', now)).to eq(now + 29938200)
                 # this one is slow (1 year == 3 seconds)
                 #
                 # historical note:
                 # (comment made in 2006 or 2007, the underlying libs got better and
                 # that slowness is gone)
 
-            nt('0 0 * * thu', now).should == now + 604800
-            nt('00 0 * * thu', now).should == now + 604800
+            expect(nt('0 0 * * thu', now)).to eq(now + 604800)
+            expect(nt('00 0 * * thu', now)).to eq(now + 604800)
 
-            nt('0 0 * * *', now).should == now + 24 * 3600
-            nt('0 24 * * *', now).should == now + 24 * 3600
+            expect(nt('0 0 * * *', now)).to eq(now + 24 * 3600)
+            expect(nt('0 24 * * *', now)).to eq(now + 24 * 3600)
 
             now = local(2008, 12, 31, 23, 59, 59, 0)
 
-            nt('* * * * *', now).should == now + 1
+            expect(nt('* * * * *', now)).to eq(now + 1)
         end
 
         it 'computes the next occurence correctly in UTC (TZ not specified)' do
 
             now = utc(1970, 1, 1)
 
-            nt('* * * * *', now).should == utc(1970, 1, 1, 0, 1)
-            nt('* * * * sun', now).should == utc(1970, 1, 4)
-            nt('* * * * * *', now).should == utc(1970, 1, 1, 0, 0, 1)
-            nt('* * 13 * fri', now).should == utc(1970, 2, 13)
+            expect(nt('* * * * *', now)).to eq(utc(1970, 1, 1, 0, 1))
+            expect(nt('* * * * sun', now)).to eq(utc(1970, 1, 4))
+            expect(nt('* * * * * *', now)).to eq(utc(1970, 1, 1, 0, 0, 1))
+            expect(nt('* * 13 * fri', now)).to eq(utc(1970, 2, 13))
 
-            nt('10 12 13 12 *', now).should == utc(1970, 12, 13, 12, 10)
+            expect(nt('10 12 13 12 *', now)).to eq(utc(1970, 12, 13, 12, 10))
                 # this one is slow (1 year == 3 seconds)
-            nt('* * 1 6 *', now).should == utc(1970, 6, 1)
+            expect(nt('* * 1 6 *', now)).to eq(utc(1970, 6, 1))
 
-            nt('0 0 * * thu', now).should == utc(1970, 1, 8)
+            expect(nt('0 0 * * thu', now)).to eq(utc(1970, 1, 8))
         end
 
         it 'computes the next occurence correctly in local TZ (TZ not specified)' do
 
             now = local(1970, 1, 1)
 
-            nt('* * * * *', now).should == local(1970, 1, 1, 0, 1)
-            nt('* * * * sun', now).should == local(1970, 1, 4)
-            nt('* * * * * *', now).should == local(1970, 1, 1, 0, 0, 1)
-            nt('* * 13 * fri', now).should == local(1970, 2, 13)
+            expect(nt('* * * * *', now)).to eq(local(1970, 1, 1, 0, 1))
+            expect(nt('* * * * sun', now)).to eq(local(1970, 1, 4))
+            expect(nt('* * * * * *', now)).to eq(local(1970, 1, 1, 0, 0, 1))
+            expect(nt('* * 13 * fri', now)).to eq(local(1970, 2, 13))
 
-            nt('10 12 13 12 *', now).should == local(1970, 12, 13, 12, 10)
+            expect(nt('10 12 13 12 *', now)).to eq(local(1970, 12, 13, 12, 10))
                 # this one is slow (1 year == 3 seconds)
-            nt('* * 1 6 *', now).should == local(1970, 6, 1)
+            expect(nt('* * 1 6 *', now)).to eq(local(1970, 6, 1))
 
-            nt('0 0 * * thu', now).should == local(1970, 1, 8)
+            expect(nt('0 0 * * thu', now)).to eq(local(1970, 1, 8))
         end
 
         it 'computes the next occurence correctly in UTC (TZ specified)' do
@@ -241,15 +241,15 @@ describe UvRays::Scheduler::CronLine do
             now = tz.local_to_utc(local(1970, 1, 1))
                 # Midnight in zone, UTC
 
-            nt("* * * * * #{zone}", now).should == utc(1969, 12, 31, 23, 1)
-            nt("* * * * sun #{zone}", now).should == utc(1970, 1, 3, 23)
-            nt("* * * * * * #{zone}", now).should == utc(1969, 12, 31, 23, 0, 1)
-            nt("* * 13 * fri #{zone}", now).should == utc(1970, 2, 12, 23)
+            expect(nt("* * * * * #{zone}", now)).to eq(utc(1969, 12, 31, 23, 1))
+            expect(nt("* * * * sun #{zone}", now)).to eq(utc(1970, 1, 3, 23))
+            expect(nt("* * * * * * #{zone}", now)).to eq(utc(1969, 12, 31, 23, 0, 1))
+            expect(nt("* * 13 * fri #{zone}", now)).to eq(utc(1970, 2, 12, 23))
 
-            nt("10 12 13 12 * #{zone}", now).should == utc(1970, 12, 13, 11, 10)
-            nt("* * 1 6 * #{zone}", now).should == utc(1970, 5, 31, 23)
+            expect(nt("10 12 13 12 * #{zone}", now)).to eq(utc(1970, 12, 13, 11, 10))
+            expect(nt("* * 1 6 * #{zone}", now)).to eq(utc(1970, 5, 31, 23))
 
-            nt("0 0 * * thu #{zone}", now).should == utc(1970, 1, 7, 23)
+            expect(nt("0 0 * * thu #{zone}", now)).to eq(utc(1970, 1, 7, 23))
         end
 
         #it 'computes the next occurence correctly in local TZ (TZ specified)' do
@@ -257,72 +257,72 @@ describe UvRays::Scheduler::CronLine do
         #    tz = TZInfo::Timezone.get(zone)
         #    now = tz.local_to_utc(utc(1970, 1, 1)).localtime
         #        # Midnight in zone, local time
-        #    nt("* * * * * #{zone}", now).should == local(1969, 12, 31, 18, 1)
-        #    nt("* * * * sun #{zone}", now).should == local(1970, 1, 3, 18)
-        #    nt("* * * * * * #{zone}", now).should == local(1969, 12, 31, 18, 0, 1)
-        #    nt("* * 13 * fri #{zone}", now).should == local(1970, 2, 12, 18)
-        #    nt("10 12 13 12 * #{zone}", now).should == local(1970, 12, 13, 6, 10)
-        #    nt("* * 1 6 * #{zone}", now).should == local(1970, 5, 31, 19)
-        #    nt("0 0 * * thu #{zone}", now).should == local(1970, 1, 7, 18)
+        #    expect(nt("* * * * * #{zone}", now)).to eq(local(1969, 12, 31, 18, 1))
+        #    expect(nt("* * * * sun #{zone}", now)).to eq(local(1970, 1, 3, 18))
+        #    expect(nt("* * * * * * #{zone}", now)).to eq(local(1969, 12, 31, 18, 0, 1))
+        #    expect(nt("* * 13 * fri #{zone}", now)).to eq(local(1970, 2, 12, 18))
+        #    expect(nt("10 12 13 12 * #{zone}", now)).to eq(local(1970, 12, 13, 6, 10))
+        #    expect(nt("* * 1 6 * #{zone}", now)).to eq(local(1970, 5, 31, 19))
+        #    expect(nt("0 0 * * thu #{zone}", now)).to eq(local(1970, 1, 7, 18))
         #end
 
         it 'computes the next time correctly when there is a sun#2 involved' do
 
-            nt('* * * * sun#1', local(1970, 1, 1)).should == local(1970, 1, 4)
-            nt('* * * * sun#2', local(1970, 1, 1)).should == local(1970, 1, 11)
+            expect(nt('* * * * sun#1', local(1970, 1, 1))).to eq(local(1970, 1, 4))
+            expect(nt('* * * * sun#2', local(1970, 1, 1))).to eq(local(1970, 1, 11))
 
-            nt('* * * * sun#2', local(1970, 1, 12)).should == local(1970, 2, 8)
+            expect(nt('* * * * sun#2', local(1970, 1, 12))).to eq(local(1970, 2, 8))
         end
 
         it 'computes the next time correctly when there is a sun#2,sun#3 involved' do
 
-            nt('* * * * sun#2,sun#3', local(1970, 1, 1)).should == local(1970, 1, 11)
-            nt('* * * * sun#2,sun#3', local(1970, 1, 12)).should == local(1970, 1, 18)
+            expect(nt('* * * * sun#2,sun#3', local(1970, 1, 1))).to eq(local(1970, 1, 11))
+            expect(nt('* * * * sun#2,sun#3', local(1970, 1, 12))).to eq(local(1970, 1, 18))
         end
 
         it 'understands sun#L' do
 
-            nt('* * * * sun#L', local(1970, 1, 1)).should == local(1970, 1, 25)
+            expect(nt('* * * * sun#L', local(1970, 1, 1))).to eq(local(1970, 1, 25))
         end
 
         it 'understands sun#-1' do
 
-            nt('* * * * sun#-1', local(1970, 1, 1)).should == local(1970, 1, 25)
+            expect(nt('* * * * sun#-1', local(1970, 1, 1))).to eq(local(1970, 1, 25))
         end
 
         it 'understands sun#-2' do
 
-            nt('* * * * sun#-2', local(1970, 1, 1)).should == local(1970, 1, 18)
+            expect(nt('* * * * sun#-2', local(1970, 1, 1))).to eq(local(1970, 1, 18))
         end
 
         it 'computes the next time correctly when "L" (last day of month)' do
 
-            nt('* * L * *', lo(1970, 1, 1)).should == lo(1970, 1, 31)
-            nt('* * L * *', lo(1970, 2, 1)).should == lo(1970, 2, 28)
-            nt('* * L * *', lo(1972, 2, 1)).should == lo(1972, 2, 29)
-            nt('* * L * *', lo(1970, 4, 1)).should == lo(1970, 4, 30)
+            expect(nt('* * L * *', lo(1970, 1, 1))).to eq(lo(1970, 1, 31))
+            expect(nt('* * L * *', lo(1970, 2, 1))).to eq(lo(1970, 2, 28))
+            expect(nt('* * L * *', lo(1972, 2, 1))).to eq(lo(1972, 2, 29))
+            expect(nt('* * L * *', lo(1970, 4, 1))).to eq(lo(1970, 4, 30))
         end
 
         it 'returns a time with subseconds chopped off' do
 
-            nt('* * * * *', Time.now).usec.should == 0
-            nt('* * * * *', Time.now).iso8601(10).match(/\.0+[^\d]/).should_not == nil
+            expect(nt('* * * * *', Time.now).usec).to eq(0)
+            expect(nt('* * * * *', Time.now).iso8601(10).match(/\.0+[^\d]/)).not_to eq(nil)
         end
     end
 
     describe '#previous_time' do
 
         def pt(cronline, now)
-            UvRays::Scheduler::CronLine.new(cronline).previous_time(now)
+            UV::Scheduler::CronLine.new(cronline).previous_time(now)
         end
 
         it 'returns the previous time the cron should have triggered' do
 
-            pt('* * * * sun', lo(1970, 1, 1)).should == lo(1969, 12, 28, 23, 59, 00)
-            pt('* * 13 * *', lo(1970, 1, 1)).should == lo(1969, 12, 13, 23, 59, 00)
-            pt('0 12 13 * *', lo(1970, 1, 1)).should == lo(1969, 12, 13, 12, 00)
+            expect(pt('* * * * sun', lo(1970, 1, 1))).to eq(lo(1969, 12, 28, 23, 59, 00))
+            expect(pt('* * 13 * *', lo(1970, 1, 1))).to eq(lo(1969, 12, 13, 23, 59, 00))
+            expect(pt('0 12 13 * *', lo(1970, 1, 1))).to eq(lo(1969, 12, 13, 12, 00))
 
-            pt('* * * * * sun', lo(1970, 1, 1)).should == lo(1969, 12, 28, 23, 59, 59)
+            expect(pt('* * * * * sun', lo(1970, 1, 1))).to eq(lo(1969, 12, 28, 23, 59, 59))
         end
     end
 
@@ -400,17 +400,17 @@ describe UvRays::Scheduler::CronLine do
 
         it 'returns the appropriate "sun#2"-like string' do
 
-            class UvRays::Scheduler::CronLine
+            class UV::Scheduler::CronLine
                 public :monthdays
             end
 
-            cl = UvRays::Scheduler::CronLine.new('* * * * *')
+            cl = UV::Scheduler::CronLine.new('* * * * *')
 
-            cl.monthdays(local(1970, 1, 1)).should == %w[ thu#1 thu#-5 ]
-            cl.monthdays(local(1970, 1, 7)).should == %w[ wed#1 wed#-4 ]
-            cl.monthdays(local(1970, 1, 14)).should == %w[ wed#2 wed#-3 ]
+            expect(cl.monthdays(local(1970, 1, 1))).to eq(%w[ thu#1 thu#-5 ])
+            expect(cl.monthdays(local(1970, 1, 7))).to eq(%w[ wed#1 wed#-4 ])
+            expect(cl.monthdays(local(1970, 1, 14))).to eq(%w[ wed#2 wed#-3 ])
 
-            cl.monthdays(local(2011, 3, 11)).should == %w[ fri#2 fri#-3 ]
+            expect(cl.monthdays(local(2011, 3, 11))).to eq(%w[ fri#2 fri#-3 ])
         end
     end
 
@@ -418,12 +418,12 @@ describe UvRays::Scheduler::CronLine do
 
         it 'returns the shortest delta between two occurrences' do
 
-            UvRays::Scheduler::CronLine.new('* * * * *').frequency.should == 60
-            UvRays::Scheduler::CronLine.new('* * * * * *').frequency.should == 1
+            expect(UV::Scheduler::CronLine.new('* * * * *').frequency).to eq(60)
+            expect(UV::Scheduler::CronLine.new('* * * * * *').frequency).to eq(1)
 
-            UvRays::Scheduler::CronLine.new('5 23 * * *').frequency.should == 24 * 3600
-            UvRays::Scheduler::CronLine.new('5 * * * *').frequency.should == 3600
-            UvRays::Scheduler::CronLine.new('10,20,30 * * * *').frequency.should == 600
+            expect(UV::Scheduler::CronLine.new('5 23 * * *').frequency).to eq(24 * 3600)
+            expect(UV::Scheduler::CronLine.new('5 * * * *').frequency).to eq(3600)
+            expect(UV::Scheduler::CronLine.new('10,20,30 * * * *').frequency).to eq(600)
         end
     end
 end

data/spec/scheduler_spec.rb

@@ -1,6 +1,6 @@
 require 'uv-rays'
 
-describe UvRays::Scheduler do
+describe UV::Scheduler do
     before :each do
         @loop = Libuv::Loop.new
         @general_failure = []
@@ -29,10 +29,10 @@ describe UvRays::Scheduler do
             end
         }
 
-        @general_failure.should == []
-        @event.should == @result
+        expect(@general_failure).to eq([])
+        expect(@event).to eq(@result)
         @diff = @triggered_at - @event.last_scheduled
-        (@diff >= 500 && @diff < 750).should == true
+        expect((@diff >= 500 && @diff < 750)).to eq(true)
     end
 
     it "should be able to schedule a one shot event using 'at'" do
@@ -52,10 +52,10 @@ describe UvRays::Scheduler do
             end
         }
 
-        @general_failure.should == []
-        @event.should == @result
+        expect(@general_failure).to eq([])
+        expect(@event).to eq(@result)
         @diff = @triggered_at - @event.last_scheduled
-        (@diff >= 1000 && @diff < 1250).should == true
+        expect((@diff >= 1000 && @diff < 1250)).to eq(true)
     end
 
     it "should be able to schedule a repeat event" do
@@ -81,10 +81,10 @@ describe UvRays::Scheduler do
             end
         }
 
-        @general_failure.should == []
-        @run.should == 2
-        @event.should == @result
+        expect(@general_failure).to eq([])
+        expect(@run).to eq(2)
+        expect(@event).to eq(@result)
         @diff = @triggered_at - @event.last_scheduled
-        (@diff >= 250 && @diff < 500).should == true
+        expect((@diff >= 250 && @diff < 500)).to eq(true)
     end
 end

data/spec/scheduler_time_spec.rb

@@ -7,126 +7,126 @@
 
 
 
-describe UvRays::Scheduler do
+describe UV::Scheduler do
 
     describe '.parse_duration' do
 
         def pd(s)
-            UvRays::Scheduler.parse_duration(s)
+            UV::Scheduler.parse_duration(s)
         end
 
         it 'parses duration strings' do
 
-            pd('-1.0d1.0w1.0d').should == -777600000
-            pd('-1d1w1d').should == -777600000
-            pd('-1w2d').should == -777600000
-            pd('-1h10s').should == -3610000
-            pd('-1h').should == -3600000
-            pd('-5.').should == -5
-            pd('-2.5s').should == -2500
-            pd('-1s').should == -1000
-            pd('-500').should == -500
-            pd('').should == 0
-            pd('5.0').should == 5
-            pd('0.5').should == 0
-            pd('.5').should == 0
-            pd('5.').should == 5
-            pd('500').should == 500
-            pd('1000').should == 1000
-            pd('1').should == 1
-            pd('1s').should == 1000
-            pd('2.5s').should == 2500
-            pd('1h').should == 3600000
-            pd('1h10s').should == 3610000
-            pd('1w2d').should == 777600000
-            pd('1d1w1d').should == 777600000
-            pd('1.0d1.0w1.0d').should == 777600000
-
-            pd('.5m').should == 30000
-            pd('5.m').should == 300000
-            pd('1m.5s').should == 60500
-            pd('-.5m').should == -30000
-
-            pd('1').should == 1
-            pd('0.1').should == 0
-            pd('1s').should == 1000
+            expect(pd('-1.0d1.0w1.0d')).to eq(-777600000)
+            expect(pd('-1d1w1d')).to eq(-777600000)
+            expect(pd('-1w2d')).to eq(-777600000)
+            expect(pd('-1h10s')).to eq(-3610000)
+            expect(pd('-1h')).to eq(-3600000)
+            expect(pd('-5.')).to eq(-5)
+            expect(pd('-2.5s')).to eq(-2500)
+            expect(pd('-1s')).to eq(-1000)
+            expect(pd('-500')).to eq(-500)
+            expect(pd('')).to eq(0)
+            expect(pd('5.0')).to eq(5)
+            expect(pd('0.5')).to eq(0)
+            expect(pd('.5')).to eq(0)
+            expect(pd('5.')).to eq(5)
+            expect(pd('500')).to eq(500)
+            expect(pd('1000')).to eq(1000)
+            expect(pd('1')).to eq(1)
+            expect(pd('1s')).to eq(1000)
+            expect(pd('2.5s')).to eq(2500)
+            expect(pd('1h')).to eq(3600000)
+            expect(pd('1h10s')).to eq(3610000)
+            expect(pd('1w2d')).to eq(777600000)
+            expect(pd('1d1w1d')).to eq(777600000)
+            expect(pd('1.0d1.0w1.0d')).to eq(777600000)
+
+            expect(pd('.5m')).to eq(30000)
+            expect(pd('5.m')).to eq(300000)
+            expect(pd('1m.5s')).to eq(60500)
+            expect(pd('-.5m')).to eq(-30000)
+
+            expect(pd('1')).to eq(1)
+            expect(pd('0.1')).to eq(0)
+            expect(pd('1s')).to eq(1000)
         end
 
         it 'calls #to_s on its input' do
 
-            pd(1).should == 1
+            expect(pd(1)).to eq(1)
         end
 
         it 'raises on wrong duration strings' do
 
-            lambda { pd('-') }.should raise_error(ArgumentError)
-            lambda { pd('h') }.should raise_error(ArgumentError)
-            lambda { pd('whatever') }.should raise_error(ArgumentError)
-            lambda { pd('hms') }.should raise_error(ArgumentError)
+            expect  { pd('-') }.to raise_error(ArgumentError)
+            expect  { pd('h') }.to raise_error(ArgumentError)
+            expect  { pd('whatever') }.to raise_error(ArgumentError)
+            expect  { pd('hms') }.to raise_error(ArgumentError)
 
-            lambda { pd(' 1h ') }.should raise_error(ArgumentError)
+            expect  { pd(' 1h ') }.to raise_error(ArgumentError)
         end
     end
 
     describe '.to_duration' do
 
         def td(o, opts={})
-            UvRays::Scheduler.to_duration(o, opts)
+            UV::Scheduler.to_duration(o, opts)
         end
 
         it 'turns integers into duration strings' do
 
-            td(0).should == '0s'
-            td(60000).should == '1m'
-            td(61000).should == '1m1s'
-            td(3661000).should == '1h1m1s'
-            td(24 * 3600 * 1000).should == '1d'
-            td(7 * 24 * 3600 * 1000 + 1000).should == '1w1s'
-            td(30 * 24 * 3600 * 1000 + 1000).should == '4w2d1s'
+            expect(td(0)).to eq('0s')
+            expect(td(60000)).to eq('1m')
+            expect(td(61000)).to eq('1m1s')
+            expect(td(3661000)).to eq('1h1m1s')
+            expect(td(24 * 3600 * 1000)).to eq('1d')
+            expect(td(7 * 24 * 3600 * 1000 + 1000)).to eq('1w1s')
+            expect(td(30 * 24 * 3600 * 1000 + 1000)).to eq('4w2d1s')
         end
 
         it 'ignores seconds and milliseconds if :drop_seconds => true' do
 
-            td(0, :drop_seconds => true).should == '0m'
-            td(5000, :drop_seconds => true).should == '0m'
-            td(61000, :drop_seconds => true).should == '1m'
+            expect(td(0, :drop_seconds => true)).to eq('0m')
+            expect(td(5000, :drop_seconds => true)).to eq('0m')
+            expect(td(61000, :drop_seconds => true)).to eq('1m')
         end
 
         it 'displays months if :months => true' do
 
-            td(1000, :months => true).should == '1s'
-            td(30 * 24 * 3600 * 1000 + 1000, :months => true).should == '1M1s'
+            expect(td(1000, :months => true)).to eq('1s')
+            expect(td(30 * 24 * 3600 * 1000 + 1000, :months => true)).to eq('1M1s')
         end
 
         it 'turns floats into duration strings' do
 
-            td(100).should == '100'
-            td(1100).should == '1s100'
+            expect(td(100)).to eq('100')
+            expect(td(1100)).to eq('1s100')
         end
     end
 
     describe '.to_duration_hash' do
 
         def tdh(o, opts={})
-            UvRays::Scheduler.to_duration_hash(o, opts)
+            UV::Scheduler.to_duration_hash(o, opts)
         end
 
         it 'turns integers duration hashes' do
 
-            tdh(0).should == {}
-            tdh(60000).should == { :m => 1 }
+            expect(tdh(0)).to eq({})
+            expect(tdh(60000)).to eq({ :m => 1 })
         end
 
         it 'turns floats duration hashes' do
 
-            tdh(128).should == { :ms => 128 }
-            tdh(60127).should == { :m => 1, :ms => 127 }
+            expect(tdh(128)).to eq({ :ms => 128 })
+            expect(tdh(60127)).to eq({ :m => 1, :ms => 127 })
         end
 
         it 'drops seconds and milliseconds if :drop_seconds => true' do
 
-            tdh(61127).should == { :m => 1, :s => 1, :ms => 127 }
-            tdh(61127, :drop_seconds => true).should == { :m => 1 }
+            expect(tdh(61127)).to eq({ :m => 1, :s => 1, :ms => 127 })
+            expect(tdh(61127, :drop_seconds => true)).to eq({ :m => 1 })
         end
     end
 end

data/uv-rays.gemspec

@@ -2,7 +2,7 @@ require File.expand_path("../lib/uv-rays/version", __FILE__)
 
 Gem::Specification.new do |gem|
     gem.name          = "uv-rays"
-    gem.version       = UvRays::VERSION
+    gem.version       = UV::VERSION
     gem.license       = 'MIT'
     gem.authors       = ["Stephen von Takach"]
     gem.email         = ["steve@cotag.me"]
@@ -13,13 +13,13 @@ Gem::Specification.new do |gem|
     gem.required_ruby_version = '>= 1.9.2'
     gem.require_paths = ["lib"]
 
-    gem.add_runtime_dependency     'libuv'
+    gem.add_runtime_dependency     'libuv', '>= 0.11.19'
     gem.add_runtime_dependency     'bisect'
     gem.add_runtime_dependency     'tzinfo'
     gem.add_runtime_dependency     'cookiejar'
     gem.add_runtime_dependency     'ipaddress'
     gem.add_runtime_dependency     'addressable'
-    gem.add_runtime_dependency     'http-parser'
+    gem.add_runtime_dependency     'http-parser', '>= 1.0.4'
 
     gem.add_development_dependency 'rspec', '>= 2.14'
     gem.add_development_dependency 'rake', '>= 10.1'