uv-rays 0.0.1

data/spec/scheduler_cron_spec.rb

@@ -0,0 +1,429 @@
+require 'uv-rays'
+
+describe UvRays::Scheduler::CronLine do
+
+    def cl(cronline_string)
+        UvRays::Scheduler::CronLine.new(cronline_string)
+    end
+
+    def match(line, time)
+        cl(line).matches?(time).should == true
+    end
+    def no_match(line, time)
+        cl(line).matches?(time).should == false
+    end
+    def to_a(line, array)
+        cl(line).to_array.should == array
+    end
+    def local(*args)
+        Time.local(*args)
+    end
+    alias lo local
+
+    def utc(*args)
+        Time.utc(*args)
+    end
+
+    describe '.new' do
+
+        it 'interprets cron strings correctly' do
+
+            to_a '* * * * *', [ [0], nil, nil, nil, nil, nil, nil, nil ]
+            to_a '10-12 * * * *', [ [0], [10, 11, 12], nil, nil,    nil, nil, nil, nil ]
+            to_a '* * * * sun,mon', [ [0], nil, nil, nil, nil, [0, 1], nil, nil ]
+            to_a '* * * * mon-wed', [ [0], nil, nil, nil, nil, [1, 2, 3], nil, nil ]
+            to_a '* * * * 7', [ [0], nil, nil, nil, nil, [0], nil, nil ]
+            to_a '* * * * 0', [ [0], nil, nil, nil, nil, [0], nil, nil ]
+            to_a '* * * * 0,1', [ [0], nil, nil, nil, nil, [0,1], nil, nil ]
+            to_a '* * * * 7,1', [ [0], nil, nil, nil, nil, [0,1], nil, nil ]
+            to_a '* * * * 7,0', [ [0], nil, nil, nil, nil, [0], nil, nil ]
+            to_a '* * * * sun,2-4', [ [0], nil, nil, nil, nil, [0, 2, 3, 4], nil, nil ]
+
+            to_a '* * * * sun,mon-tue', [ [0], nil, nil, nil, nil, [0, 1, 2], nil, nil ]
+
+            to_a '* * * * * *', [ nil, nil, nil, nil, nil, nil, nil, nil ]
+            to_a '1 * * * * *', [ [1], nil, nil, nil, nil, nil, nil, nil ]
+            to_a '7 10-12 * * * *', [ [7], [10, 11, 12], nil, nil, nil, nil, nil, nil ]
+            to_a '1-5 * * * * *', [ [1,2,3,4,5], nil, nil, nil, nil, nil, nil, nil ]
+
+            to_a '0 0 1 1 *', [ [0], [0], [0], [1], [1], nil, nil, nil ]
+
+            to_a '0 23-24 * * *', [ [0], [0], [23, 0], nil, nil, nil, nil, nil ]
+                #
+                # as reported by Aimee Rose in
+                # https://github.com/jmettraux/rufus-scheduler/issues/56
+
+            to_a '0 23-2 * * *', [ [0], [0], [23, 0, 1, 2], nil, nil, nil, nil, nil ]
+        end
+
+        it 'rejects invalid weekday expressions' do
+
+            lambda { cl '0 17 * * MON_FRI' }.should 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
+        end
+
+        it 'rejects invalid cronlines' do
+
+            lambda { cl '* nada * * 9' }.should raise_error(ArgumentError)
+        end
+
+        it 'interprets cron strings with TZ correctly' do
+
+            to_a('* * * * * EST', [ [0], nil, nil, nil, nil, nil, nil, 'EST' ])
+            to_a('* * * * * * EST', [ nil, nil, nil, nil, nil, nil, nil, 'EST' ])
+
+            to_a(
+                '* * * * * * America/Chicago',
+                [ nil, nil, nil, nil, nil, nil, nil, 'America/Chicago' ])
+            to_a(
+                '* * * * * * 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
+        end
+
+        it 'interprets cron strings with / (slashes) correctly' do
+
+            to_a(
+                '0 */2 * * *',
+                [ [0], [0], (0..11).collect { |e| e * 2 }, nil, nil, nil, nil, nil ])
+            to_a(
+                '0 7-23/2 * * *',
+                [ [0], [0], (7..23).select { |e| e.odd? }, nil, nil, nil, nil, nil ])
+            to_a(
+                '*/10 * * * *',
+                [ [0], [0, 10, 20, 30, 40, 50], nil, nil, nil, nil, nil, nil ])
+
+            # fighting https://github.com/jmettraux/rufus-scheduler/issues/65
+            #
+            to_a(
+                '*/10 * * * * Europe/Berlin',
+                [ [0], [ 0, 10, 20, 30, 40, 50], nil, nil, nil, nil, nil, 'Europe/Berlin' ])
+        end
+
+        it 'accepts lonely / (slashes) (like <= 2.0.19 did)' do
+
+            # fighting https://github.com/jmettraux/rufus-scheduler/issues/65
+
+            to_a(
+                '/10 * * * *',
+                [ [0], [ 0, 10, 20, 30, 40, 50], nil, nil, nil, nil, nil, nil ])
+        end
+
+        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)
+        end
+
+        it 'accepts items with initial 0' do
+
+            to_a '09 * * * *', [ [0], [9], nil, nil, nil, nil, nil, nil ]
+            to_a '09-12 * * * *', [ [0], [9, 10, 11, 12], nil, nil, nil, nil, nil, nil ]
+            to_a '07-08 * * * *', [ [0], [7, 8], nil, nil, nil, nil, nil, nil ]
+            to_a '* */08 * * *', [ [0], nil, [0, 8, 16], nil, nil, nil, nil, nil ]
+            to_a '* */07 * * *', [ [0], nil, [0, 7, 14, 21], nil, nil, nil, nil, nil ]
+            to_a '* 01-09/04 * * *', [ [0], nil, [1, 5, 9], nil, nil, nil, nil, nil ]
+            to_a '* * * * 06', [ [0], nil, nil, nil, nil, [6], nil, nil ]
+        end
+
+        it 'interprets cron strings with L correctly' do
+
+            to_a '* * L * *', [[0], nil, nil, ['L'], nil, nil, nil, nil ]
+            to_a '* * 2-5,L * *', [[0], nil, nil, [2,3,4,5,'L'], nil, nil, nil, nil ]
+            to_a '* * */8,L * *', [[0], nil, nil, [1,9,17,25,'L'], nil, nil, nil, nil ]
+        end
+
+        it 'does not support ranges for L' do
+
+            lambda { cl '* * 15-L * *'}.should raise_error(ArgumentError)
+            lambda { cl '* * L/4 * *'}.should raise_error(ArgumentError)
+        end
+
+        it 'does not support multiple Ls' do
+
+            lambda { cl '* * L,L * *'}.should raise_error(ArgumentError)
+        end
+
+        it 'raises if L is used for something else than days' do
+
+            lambda { cl '* L * * *'}.should 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)
+                #
+                # as reported by Aimee Rose in
+                # https://github.com/jmettraux/rufus-scheduler/pull/58
+        end
+    end
+
+    describe '#next_time' do
+
+        def nt(cronline, now)
+            UvRays::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
+
+            nt('10 12 13 12 *', now).should == 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
+
+            nt('0 0 * * *', now).should == now + 24 * 3600
+            nt('0 24 * * *', now).should == now + 24 * 3600
+
+            now = local(2008, 12, 31, 23, 59, 59, 0)
+
+            nt('* * * * *', now).should == 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)
+
+            nt('10 12 13 12 *', now).should == utc(1970, 12, 13, 12, 10)
+                # this one is slow (1 year == 3 seconds)
+            nt('* * 1 6 *', now).should == utc(1970, 6, 1)
+
+            nt('0 0 * * thu', now).should == 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)
+
+            nt('10 12 13 12 *', now).should == local(1970, 12, 13, 12, 10)
+                # this one is slow (1 year == 3 seconds)
+            nt('* * 1 6 *', now).should == local(1970, 6, 1)
+
+            nt('0 0 * * thu', now).should == local(1970, 1, 8)
+        end
+
+        it 'computes the next occurence correctly in UTC (TZ specified)' do
+
+            zone = 'Europe/Stockholm'
+            tz = TZInfo::Timezone.get(zone)
+            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)
+
+            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)
+
+            nt("0 0 * * thu #{zone}", now).should == utc(1970, 1, 7, 23)
+        end
+
+        #it 'computes the next occurence correctly in local TZ (TZ specified)' do
+        #    zone = 'Europe/Stockholm'
+        #    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)
+        #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)
+
+            nt('* * * * sun#2', local(1970, 1, 12)).should == 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)
+        end
+
+        it 'understands sun#L' do
+
+            nt('* * * * sun#L', local(1970, 1, 1)).should == local(1970, 1, 25)
+        end
+
+        it 'understands sun#-1' do
+
+            nt('* * * * sun#-1', local(1970, 1, 1)).should == local(1970, 1, 25)
+        end
+
+        it 'understands sun#-2' do
+
+            nt('* * * * sun#-2', local(1970, 1, 1)).should == 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)
+        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
+        end
+    end
+
+    describe '#previous_time' do
+
+        def pt(cronline, now)
+            UvRays::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)
+
+            pt('* * * * * sun', lo(1970, 1, 1)).should == lo(1969, 12, 28, 23, 59, 59)
+        end
+    end
+
+    describe '#matches?' do
+
+        it 'matches correctly in UTC (TZ not specified)' do
+
+            match '* * * * *', utc(1970, 1, 1, 0, 1)
+            match '* * * * sun', utc(1970, 1, 4)
+            match '* * * * * *', utc(1970, 1, 1, 0, 0, 1)
+            match '* * 13 * fri', utc(1970, 2, 13)
+
+            match '10 12 13 12 *', utc(1970, 12, 13, 12, 10)
+            match '* * 1 6 *', utc(1970, 6, 1)
+
+            match '0 0 * * thu', utc(1970, 1, 8)
+
+            match '0 0 1 1 *', utc(2012, 1, 1)
+            no_match '0 0 1 1 *', utc(2012, 1, 1, 1, 0)
+        end
+
+        it 'matches correctly in local TZ (TZ not specified)' do
+
+            match '* * * * *', local(1970, 1, 1, 0, 1)
+            match '* * * * sun', local(1970, 1, 4)
+            match '* * * * * *', local(1970, 1, 1, 0, 0, 1)
+            match '* * 13 * fri', local(1970, 2, 13)
+
+            match '10 12 13 12 *', local(1970, 12, 13, 12, 10)
+            match '* * 1 6 *', local(1970, 6, 1)
+
+            match '0 0 * * thu', local(1970, 1, 8)
+
+            match '0 0 1 1 *', local(2012, 1, 1)
+            no_match '0 0 1 1 *', local(2012, 1, 1, 1, 0)
+        end
+
+        it 'matches correctly in UTC (TZ specified)' do
+
+            zone = 'Europe/Stockholm'
+
+            match "* * * * * #{zone}", utc(1969, 12, 31, 23, 1)
+            match "* * * * sun #{zone}", utc(1970, 1, 3, 23)
+            match "* * * * * * #{zone}", utc(1969, 12, 31, 23, 0, 1)
+            match "* * 13 * fri #{zone}", utc(1970, 2, 12, 23)
+
+            match "10 12 13 12 * #{zone}", utc(1970, 12, 13, 11, 10)
+            match "* * 1 6 * #{zone}", utc(1970, 5, 31, 23)
+
+            match "0 0 * * thu #{zone}", utc(1970, 1, 7, 23)
+        end
+
+        it 'matches correctly when there is a sun#2 involved' do
+
+            match '* * 13 * fri#2', utc(1970, 2, 13)
+            no_match '* * 13 * fri#2', utc(1970, 2, 20)
+        end
+
+        it 'matches correctly when there is a L involved' do
+
+            match '* * L * *', utc(1970, 1, 31)
+            no_match '* * L * *', utc(1970, 1, 30)
+        end
+
+        it 'matches correctly when there is a sun#2,sun#3 involved' do
+
+            no_match '* * * * sun#2,sun#3', local(1970, 1, 4)
+            match '* * * * sun#2,sun#3', local(1970, 1, 11)
+            match '* * * * sun#2,sun#3', local(1970, 1, 18)
+            no_match '* * * * sun#2,sun#3', local(1970, 1, 25)
+        end
+    end
+
+    describe '#monthdays' do
+
+        it 'returns the appropriate "sun#2"-like string' do
+
+            class UvRays::Scheduler::CronLine
+                public :monthdays
+            end
+
+            cl = UvRays::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 ]
+
+            cl.monthdays(local(2011, 3, 11)).should == %w[ fri#2 fri#-3 ]
+        end
+    end
+
+    describe '#frequency' do
+
+        it 'returns the shortest delta between two occurrences' do
+
+            UvRays::Scheduler::CronLine.new('* * * * *').frequency.should == 60
+            UvRays::Scheduler::CronLine.new('* * * * * *').frequency.should == 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
+        end
+    end
+end

data/spec/scheduler_spec.rb

@@ -0,0 +1,90 @@
+require 'uv-rays'
+
+describe UvRays::Scheduler do
+    before :each do
+        @loop = Libuv::Loop.new
+        @general_failure = []
+        @timeout = @loop.timer do
+            @loop.stop
+            @general_failure << "test timed out"
+        end
+        @timeout.start(5000)
+        @scheduler = @loop.scheduler
+    end
+
+    it "should be able to schedule a one shot event using 'in'" do
+        @loop.run { |logger|
+            logger.progress do |level, errorid, error|
+                begin
+                    @general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
+                rescue Exception
+                    @general_failure << 'error in logger'
+                end
+            end
+
+            @event = @scheduler.in('0.5s') do |triggered, event|
+                @triggered_at = triggered
+                @result = event
+                @loop.stop
+            end
+        }
+
+        @general_failure.should == []
+        @event.should == @result
+        @diff = @triggered_at - @event.last_scheduled
+        (@diff >= 500 && @diff < 750).should == true
+    end
+
+    it "should be able to schedule a one shot event using 'at'" do
+        @loop.run { |logger|
+            logger.progress do |level, errorid, error|
+                begin
+                    @general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
+                rescue Exception
+                    @general_failure << 'error in logger'
+                end
+            end
+
+            @event = @scheduler.at(Time.now + 1) do |triggered, event|
+                @triggered_at = triggered
+                @result = event
+                @loop.stop
+            end
+        }
+
+        @general_failure.should == []
+        @event.should == @result
+        @diff = @triggered_at - @event.last_scheduled
+        (@diff >= 1000 && @diff < 1250).should == true
+    end
+
+    it "should be able to schedule a repeat event" do
+        @loop.run { |logger|
+            logger.progress do |level, errorid, error|
+                begin
+                    @general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
+                rescue Exception
+                    @general_failure << 'error in logger'
+                end
+            end
+
+            @run = 0
+            @event = @scheduler.every('0.25s') do |triggered, event|
+                @triggered_at = triggered
+                @result = event
+
+                @run += 1
+                if @run == 2
+                    @event.pause
+                    @loop.stop
+                end
+            end
+        }
+
+        @general_failure.should == []
+        @run.should == 2
+        @event.should == @result
+        @diff = @triggered_at - @event.last_scheduled
+        (@diff >= 250 && @diff < 500).should == true
+    end
+end

data/spec/scheduler_time_spec.rb

@@ -0,0 +1,132 @@
+
+#
+# Specifying rufus-scheduler
+#
+# Wed Apr 17 06:00:59 JST 2013
+#
+
+
+
+describe UvRays::Scheduler do
+
+    describe '.parse_duration' do
+
+        def pd(s)
+            UvRays::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
+        end
+
+        it 'calls #to_s on its input' do
+
+            pd(1).should == 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)
+
+            lambda { pd(' 1h ') }.should raise_error(ArgumentError)
+        end
+    end
+
+    describe '.to_duration' do
+
+        def td(o, opts={})
+            UvRays::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'
+        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'
+        end
+
+        it 'displays months if :months => true' do
+
+            td(1000, :months => true).should == '1s'
+            td(30 * 24 * 3600 * 1000 + 1000, :months => true).should == '1M1s'
+        end
+
+        it 'turns floats into duration strings' do
+
+            td(100).should == '100'
+            td(1100).should == '1s100'
+        end
+    end
+
+    describe '.to_duration_hash' do
+
+        def tdh(o, opts={})
+            UvRays::Scheduler.to_duration_hash(o, opts)
+        end
+
+        it 'turns integers duration hashes' do
+
+            tdh(0).should == {}
+            tdh(60000).should == { :m => 1 }
+        end
+
+        it 'turns floats duration hashes' do
+
+            tdh(128).should == { :ms => 128 }
+            tdh(60127).should == { :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 }
+        end
+    end
+end

data/uv-rays.gemspec

@@ -0,0 +1,31 @@
+require File.expand_path("../lib/uv-rays/version", __FILE__)
+
+Gem::Specification.new do |gem|
+    gem.name          = "uv-rays"
+    gem.version       = UvRays::VERSION
+    gem.license       = 'MIT'
+    gem.authors       = ["Stephen von Takach"]
+    gem.email         = ["steve@cotag.me"]
+    gem.homepage      = "https://github.com/cotag/uv-rays"
+    gem.summary       = "Abstractions for working with Libuv"
+    gem.description   = "Opinionated abstractions for Libuv"
+
+    gem.required_ruby_version = '>= 1.9.2'
+    gem.require_paths = ["lib"]
+
+    gem.add_runtime_dependency     'libuv'
+    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_development_dependency 'rspec', '>= 2.14'
+    gem.add_development_dependency 'rake', '>= 10.1'
+    gem.add_development_dependency 'yard'
+
+    gem.files = Dir["{lib}/**/*"] + %w(Rakefile uv-rays.gemspec README.md LICENSE)
+    gem.test_files = Dir["spec/**/*"]
+    gem.extra_rdoc_files = ["README.md"]
+end