startat 0.1.0

data/History.txt

@@ -0,0 +1,6 @@
+=== 0.1.0 / 2009-07-29
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,8 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+examples/print-to-the-future.rb
+examples/twitter-schedule-bot.rb
+lib/startat.rb
+test/test_startat.rb

data/README.txt

@@ -0,0 +1,68 @@
+= startat
+
+* http://startat.rubyforge.org/
+
+== DESCRIPTION:
+
+StartAt is a simple class for future code execution.  It is designed
+to execute a block of code at a specific point in time in the future.
+
+StartAt works by spawning a new thread, determining how long it must wait (in 
+seconds) until the future date and time is reached, calling sleep with the
+exact number of seconds to wait, and then executing the code block.
+
+StartAt was derived from a script written to post schedule information to
+Twitter for a symposium. The schedule robot posted event details exactly
+five minutes in advance of the event.
+
+== FEATURES/PROBLEMS:
+
+Issues:
+* This is an alpha release. The developer is interested in feedback on the API.
+* StartAt currently operates with whole seconds, not microseconds.
+* A running (waiting) StartAt object can be interrupted early with SIGALARM.
+* Thread safety issues have not been examined or addressed yet.
+
+== SYNOPSIS:
+
+  require 'date'
+  require 'startat'
+
+  future_time = DateTime.parse("2010-03-24 03:34:45 PM EDT")
+  action = lambda { print "The time is now!" }
+  future_event = StartAt.new(future_time, &action)
+  future_event.start
+  future_event.join
+
+== REQUIREMENTS:
+
+* date
+
+== INSTALL:
+
+* sudo gem install startat
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 Keith A. Watson <ikawnoclast@interocitry.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,12 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+
+Hoe.spec 'startat' do |p|
+  # self.rubyforge_name = 'startatx' # if different than 'startat'
+  p.developer('Keith Watson', 'ikawnoclast@interocitry.com')
+  p.remote_rdoc_dir = '' # Release to root
+end
+
+# vim: syntax=ruby

data/examples/print-to-the-future.rb

@@ -0,0 +1,70 @@
+#! /usr/bin/env ruby -w
+
+#
+# print-to-the-future.rb -- Schedules and prints messages in the future.
+#
+# Copyright (c) 2009 Keith A. Watson <ikawnoclast@interocitry.com>
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# 'Software'), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+require 'date'
+require 'startat'
+
+# The following is borrowed from the _Ruby Cookbook_, Lucas Carlson & Leonard 
+# Richardson, O'Reilly Press, page 111.
+# Time.to_datetime exists -- it's private though.
+class Time
+  def to_datetime
+    seconds = sec + Rational(usec, 10**6)
+    offset = Rational(utc_offset, 60 * 60 * 24)
+    DateTime.new(year, month, day, hour, min, seconds, offset)
+  end
+end
+
+Time_format = "%b %e %H:%M:%S"
+
+puts "Start time: #{DateTime.now.strftime(Time_format)}"
+
+schedule = {
+  (Time.now +  5).to_datetime     => "5 seconds later",
+  (Time.now +  10).to_datetime    => "10 seconds later",
+  (Time.now +  33).to_datetime    => "33 seconds later",
+  (Time.now + 1 * 60).to_datetime => "1 minute later",
+  (Time.now + 2 * 60).to_datetime => "2 minutes later and done."
+}
+
+scheduled_events = Array.new
+
+schedule.each { | event_time, msg |
+  action = lambda {
+    puts "#{DateTime.now.strftime(Time_format)} #{msg}"
+  }
+
+  # create and start the scheduler for the future event
+  future_event = StartAt.new(event_time, &action)
+  future_event.start
+
+  # store the event
+  scheduled_events.push(future_event)
+}
+
+# wait out the longest thread
+sleep 2 * 60 + 1

data/examples/twitter-schedule-bot.rb

@@ -0,0 +1,113 @@
+#!/opt/local/bin/ruby -w 
+
+#
+# twitter-schedule-bot.rb -- A code example for using StartAt for posting
+# a schedule of events for an event to Twitter.
+#
+# Copyright (c) 2009 Keith A. Watson <ikawnoclast@interocitry.com>
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# 'Software'), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+#
+# NOTE: This is an updated version of the code CERIAS used to post the
+# schedule of events for the 20009 CERIAS Information Security Symposium.
+# This code is missing the Twitter account details (username and password)
+# and the events have already elapsed. This is only an example, but is 
+# easily updated for your own events.
+#
+
+require 'rubygems'
+require 'twitter'
+require 'date'
+require 'startat'
+
+# message added to the beginning and end of the post
+header="CERIAS Symposium Schedule:"
+footer="#cerias"
+
+# amount of time before the actual event to post info (in seconds)
+leadTime = 5 * 60;
+
+# Twitter account object creation
+postService = Twitter::Base.new('myTwitterAccount', 'myTwitterPassword')
+
+# schedule array containing event times and messages
+schedule = {
+	DateTime.parse('2009-03-24 09:30:00 AM EDT') \
+	  => "Registration and Coffee in LWSN Commons",
+	DateTime.parse('2009-03-24 10:30:00 AM EDT') \
+	  => "Welcome in LWSN 1142",
+	DateTime.parse('2009-03-24 10:35:00 AM EDT') \
+	  => "Panel #1: Transitive Security & Standards Adoption in LWSN 1142",
+	DateTime.parse('2009-03-24 12:15:00 PM EDT') \
+	  => "Lunch in LWSN 1190",
+	DateTime.parse('2009-03-24 01:45:00 PM EDT') \
+	  => "Panel #2: Security in the Cloud in LWSN 1142",
+	DateTime.parse('2009-03-24 03:30:00 PM EDT') \
+	  => "Fireside Chat in LWSN 1142",
+	DateTime.parse('2009-03-24 07:00:00 PM EDT') \
+	  => "John Thompson, CEO Symantec in STEW Fowler Hall",
+	DateTime.parse('2009-03-25 08:00:00 AM EDT') \
+	  => "Registration and Coffee in LWSN Commons",
+	DateTime.parse('2009-03-25 08:30:00 AM EDT') \
+	  => "Morning Keynote Address: Dr. Ronald Ritchey in LWSN 1142",
+	DateTime.parse('2009-03-25 09:45:00 AM EDT') \
+	  => "Panel #3: Unsecured Economies in LWSN 1142",
+	DateTime.parse('2009-03-25 11:15:00 AM EDT') \
+	  => "Tech Talk Poster Preview in LWSN 1142",
+	DateTime.parse('2009-03-25 12:30:00 PM EDT') \
+	  => "Lunch and Awards in LWSN 1142",
+	DateTime.parse('2009-03-25 02:00:00 PM EDT') \
+	  => "Poster Session & CERIAS Anniversary Cake in LWSN Commons",
+	DateTime.parse('2009-03-25 04:30:00 PM EDT') \
+	  => "CERIAS Seminar in PFEN 241",
+}
+
+schedEvents = Array.new
+
+schedule.keys.each { | event |
+  # cacluate the time to post the message before the actual event
+  postTime = StartAt.get_time_before(event, leadTime)
+  # create the action of posting a message; pasted to the scheduler
+  action = lambda {
+    msg = "#{header} #{schedule[event]} starts at #{event.strftime("%l:%M")} #{footer}"
+    puts "#{DateTime.now.strftime("%b %e %H:%M:%S")} Posting the following message: \"#{msg}\" (length=#{msg.length})"
+    puts postService.post(msg).inspect
+  }
+  
+  # create and start the scheduler for the future event
+  futureEvent = StartAt.new(postTime, &action)
+  futureEvent.start
+
+  # store the event
+  schedEvents.push(futureEvent)
+}
+
+# find the longest running thread and join it
+longestEvent = StartAt.new(DateTime.now)
+schedEvents.each { | eventPostTime | 
+  if eventPostTime > longestEvent
+    longestEvent = eventPostTime
+  end
+}
+longestEvent.join
+
+exit 0

data/lib/startat.rb

@@ -0,0 +1,121 @@
+require 'date'
+
+#
+# StartAt is class for executing code at a specific point in the future.
+# The object is initialized with a #DateTime object with a point of time in the
+# future and a code block to be executed. Calling #start will calculate the
+# wait time (in seconds), initialize a #Thread that will then +sleep+ for the 
+# appropriate amount of time, and then the code block will be executed.
+#
+# For example:
+#
+#       require 'date'
+#       require 'startat'
+#
+#       bday = DateTime.parse("2009-08-20 08:30:00 AM EDT")
+#       action = lambda { puts "Happy Birthday, Dad!" }
+#       wait_for_it = StartAt.new(bday, &action)
+#       wait_for_it.start
+#       wait_for_it.join
+#
+#
+# StartAt was originally written to post schedule information for a symposium to
+# Twitter (see the examples directory). 
+#
+class StartAt
+  VERSION = '0.1.0'
+  include Comparable
+
+  Seconds_per_day = 24 * 60 * 60 # :nodoc:
+
+  attr_reader :start_datetime
+
+  # Returns a new future action object that will execute the code block
+  # at a point in the future as defined by #start_datetime.
+  def initialize(start_datetime, &block)
+    @thread_started = false
+    if start_datetime.class == DateTime
+      @start_datetime = start_datetime
+    else
+      raise ArgumentError.new("must have a DateTime object")
+    end
+    if block
+      @action = block
+    elsif block_given?
+      @action = lambda { yield }
+    else 
+      raise ArgumentError.new("missing a block")
+    end
+  end
+
+  # Compares the start #DateTime of the current future action with the 
+  # start time of the #other future action.
+  def <=> (other)
+    @start_datetime <=> other.start_datetime
+  end
+
+  # Starts the future action thread by determining the time needed to wait
+  # based on the start date and then executes the code block once the time 
+  # has elapsed.
+  def start
+    if ! @thread_started
+      @sleeper = Thread.new do
+        wait = get_wait_time()
+        # Check that the wait time is positive, otherwise the future
+        # event time has already past. We skip it, since a warning
+        # message was produced in wait_time.
+        if wait > 0
+          sleep wait
+          @action.call
+        end
+      end
+      @thread_started = true
+    end
+  end
+
+  # Cancels a running future action object thread.
+  def cancel
+    if ! @thread_started
+      @sleeper.exit
+      @thread_started = false
+    end
+  end
+
+  alias kill cancel
+
+  # Returns the status of a future action object thread. See #Thread#status
+  def status
+    @sleeper.status
+  end
+
+  # Joins the current thread to the future action thread. See #Thread.join
+  def join
+    @sleeper.join
+  end
+
+  # Takes a future #DateTime object and returns a #DateTime object for the time
+  # before as specified in +time_before+ in seconds.
+  def self.get_time_before(future_datetime, time_before)
+    future_datetime - Rational(time_before, Seconds_per_day)
+  end
+
+  # Takes a future #DateTime object and returns a #DateTime object for the time
+  # after as specified in +time_before+ in seconds.
+  def self.get_time_after(future_datetime, time_after)
+    future_datetime + Rational(time_after, Seconds_per_day)
+  end
+
+  private
+
+  def get_wait_time
+    # 1. Find the difference between the time now and the future time.
+    # 2. DateTime objects store time in whole seconds, so convert to the
+    #     number of seconds in a day and return an interger.
+    wait_time = (((@start_datetime - DateTime.now) * Seconds_per_day) + 1).to_i
+    # send a warning message if the wait time is negative since the future
+    #  time is no in the past.
+    warn "Specified date and time of #{@start_datetime.to_s} has already elapsed" if wait_time <= 0
+    return wait_time
+  end
+
+end

data/test/test_startat.rb

@@ -0,0 +1,142 @@
+require "test/unit"
+require "date"
+require "startat"
+
+# The following is borrowed from the _Ruby Cookbook_, Lucas Carlson & Leonard 
+# Richardson, O'Reilly Press, page 111.
+# Time.to_datetime exists -- it's private though.
+class Time
+  def to_datetime
+    seconds = sec + Rational(usec, 10**6)
+    offset = Rational(utc_offset, 60 * 60 * 24)
+    DateTime.new(year, month, day, hour, min, seconds, offset)
+  end
+end
+
+# Unit test suite
+class TestStartat < Test::Unit::TestCase
+  def test_initialization1
+    action = lambda { val = true }
+    test = nil
+    start = DateTime.now
+    assert_nothing_raised(ArgumentError) {
+      test = StartAt.new(start, &action)
+    }
+    assert_not_nil test
+    assert_equal(start, test.start_datetime)
+  end
+  
+  def test_initialization2
+    test = nil
+    start = DateTime.now
+    assert_nothing_raised(ArgumentError) {
+      test = StartAt.new(start) { val = true }
+    }
+    assert_not_nil test
+    assert_same(start, test.start_datetime)
+  end
+  
+  def test_initialization3
+    test = StartAt
+    assert_raise(ArgumentError) {
+      test.new(DateTime.now)
+    }
+  end
+  
+  def test_initialization4
+    assert_raise(ArgumentError) {
+      test = StartAt.new(Time.now) { val = true }
+    }
+  end
+  
+  def test_initialization5
+    assert_raise(ArgumentError) {
+      test = StartAt.new("This should fail") { val = true }
+    }
+  end
+  
+  def test_start1
+    action = lambda { val = true }
+    test = StartAt.new((Time.now + 5).to_datetime, &action)
+    test.start
+    assert_equal("sleep", test.status)
+    test.cancel
+  end
+  
+  def test_stop1
+    action = lambda { val = true }
+    test = StartAt.new((Time.now + 5).to_datetime, &action)
+    test.start
+    test.cancel
+    assert(test.status)
+  end
+  
+  def test_stop2
+    action = lambda { val = true }
+    test = StartAt.new((Time.now + 5).to_datetime, &action)
+    test.start
+    test.kill
+    assert(test.status)
+  end
+  
+  def comparison1
+    test1 = StartAt
+    test2 = StartAt
+    test1.new((Time.now + 2).to_datetime) { val1 = true }
+    test2.new((Time.now + 3).to_datetime) { val2 = true }
+    assert_not_equal(test1, test2)
+  end
+  
+  def comparison2
+    date_time = (Time.now + 2).to_datetime
+    test1 = StartAt.new(date_time) { val1 = true }
+    test2 = StartAt.new(date_time) { val2 = true }
+    assert_equal(test1, test2)
+  end
+  
+  def comparison3
+    test1 = StartAt
+    test2 = StartAt
+    test1.new((Time.now + 2).to_datetime) { val1 = true }
+    test2.new((Time.now + 3).to_datetime) { val2 = true }
+    assert_operator(test1, :<, test2)
+  end
+  
+  def test_invalid_time1
+    action = lambda { val = true }
+    test = StartAt.new((Time.now - 2).to_datetime, &action)
+    test.start
+    assert(!test.status)
+  end
+  
+  def test_timing1
+    val = true
+    test = StartAt.new((Time.now + 2).to_datetime) { val = false }
+    test.start
+    assert(val)
+    sleep 1
+    assert(val)
+    sleep 2
+    assert(!val)
+  end
+  
+  def test_get_time_before1
+    time_now = Time.now
+    datetime_now = time_now.to_datetime
+    lead_times = [ 5, 30, 120, 3600, 43200, 86400, 604800 ]
+    lead_times.each { | lead_time | 
+      time_before = StartAt.get_time_before(datetime_now, lead_time)
+      assert_equal((time_now - lead_time).to_datetime, time_before)
+    }
+  end
+
+  def test_get_time_after1
+    time_now = Time.now
+    datetime_now = time_now.to_datetime
+    lead_times = [ 5, 30, 120, 3600, 43200, 86400, 604800 ]
+    lead_times.each { | lead_time | 
+      time_before = StartAt.get_time_after(datetime_now, lead_time)
+      assert_equal((time_now + lead_time).to_datetime, time_before)
+    }
+  end
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification 
+name: startat
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Keith Watson
+autorequire: 
+bindir: bin
+cert_chain: 
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDRDCCAiygAwIBAgIBADANBgkqhkiG9w0BAQUFADBIMRQwEgYDVQQDDAtpa2F3
+  bm9jbGFzdDEbMBkGCgmSJomT8ixkARkWC2ludGVyb2NpdHJ5MRMwEQYKCZImiZPy
+  LGQBGRYDY29tMB4XDTA5MDcyOTEzNTcxOFoXDTEwMDcyOTEzNTcxOFowSDEUMBIG
+  A1UEAwwLaWthd25vY2xhc3QxGzAZBgoJkiaJk/IsZAEZFgtpbnRlcm9jaXRyeTET
+  MBEGCgmSJomT8ixkARkWA2NvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC
+  ggEBAM6Pn7BiDNnNRWUQzmuPBr3vNgp9TIB1SrJ3a9c1iJY6sYaTZD4M+JUmMpfo
+  FzQGdAAASOY0aJpBaZdA13fEC7fCed7pr44sf5mxZv1cNsUrXJbw9ZNBQFHyouz6
+  YTvO7pd24F2/DmxngutwlgCZlXwvkB5mrEfNbqIof3UhYkvK7mHBEJ5AWlGQ1nft
+  K0x72nTi3ZIg0mufz2kMadWcwK8I7A74FuGdFbMcLmoXJb4DwxCKb3APnS8UzoYV
+  /y5ddiogWbSEi+coOY0t6BkkS0kAEPf1tW6UtWB8yI+/807kyP/BQ3sQ2IoBAi04
+  +khoWTEyqkYzWmH2zRYSuh5U7RMCAwEAAaM5MDcwCQYDVR0TBAIwADALBgNVHQ8E
+  BAMCBLAwHQYDVR0OBBYEFMSjxPX6jYn3js6kC8BqsQH1c3+VMA0GCSqGSIb3DQEB
+  BQUAA4IBAQCE9cS2qD2MGQ4mWHIQOeJk9y7mQle7L25Z3tuMVNG0tPwmnZlaXpeE
+  DSYDKVCCoJQCH6m0H5KX7Jns0Y3/4unzQzfGVEh1JNojay5f2sV4YwRO+33/Ymxd
+  hhqmbytCY5ie36XoOC0aayVulcqMaHfgUVAUPN3bBudPANpVdF79yqBhjuNuCl3R
+  AwTBaYaGwOoSCGMUpOh0F4ADlqFKlZZMlxr2WXQJD2cqfMnLuzKgoL5V/Hkes8OL
+  Wh0bTgBFH0mpCwLpypJgZiuM6xhz90YTH7WzLSz9itIx2Vhrvylvxq4ePPfuefPX
+  Ia165vMqyt5W7zBTANDsPWi6m1DiaDTD
+  -----END CERTIFICATE-----
+
+date: 2009-07-29 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.3.2
+    version: 
+description: |-
+  StartAt is a simple class for future code execution.  It is designed
+  to execute a block of code at a specific point in time in the future.
+  
+  StartAt works by spawning a new thread, determining how long it must wait (in 
+  seconds) until the future date and time is reached, calling sleep with the
+  exact number of seconds to wait, and then executing the code block.
+  
+  StartAt was derived from a script written to post schedule information to
+  Twitter for a symposium. The schedule robot posted event details exactly
+  five minutes in advance of the event.
+email: 
+- ikawnoclast@interocitry.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- examples/print-to-the-future.rb
+- examples/twitter-schedule-bot.rb
+- lib/startat.rb
+- test/test_startat.rb
+has_rdoc: true
+homepage: http://startat.rubyforge.org/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: startat
+rubygems_version: 1.3.4
+signing_key: 
+specification_version: 3
+summary: StartAt is a simple class for future code execution
+test_files: 
+- test/test_startat.rb

metadata.gz.sig

@@ -0,0 +1,3 @@
+bʼw�!>[�7���
+r���Sb��m)C��?N��$�- �L��%�T6(SVU��[wy���f�v��
+�W0���b���X�ʟ�H@@^�⠍�����d�%䀫q����sB-@����?t������ۇ�S��!*���m�h�gb�:�"3��x�*���Lc��P��ي�'\��x5ʹC���6����0�� 3�uz}������6X�3�ܫ���]���D��,��vDN{B�サ�0�X�q�