clockwork 0.7.3 → 0.7.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fae14bd8566db2cb7c3be8c5c9625b01dc66ae00
-  data.tar.gz: ecbed0c0a9cf6017a0e62f62da9cfb67112624da
+  metadata.gz: bb04c64391be1de07e805c05256430c06c1d0da6
+  data.tar.gz: 3804849a9e343ce52d62609390da392ccb2c6274
 SHA512:
-  metadata.gz: c75686b464777f74d87ca6b15d3ac1d57ee83f190e22d32c6b585fecb86c5192575f90d6151588e9454f7d3f8054bd1c63f3fa4d6a3a067f1d93bbd10a14fe4a
-  data.tar.gz: c68c69e967a99422394197ed570c2c0ce0968e73a7495ec44a55158b99a6c6450a84fd3160d4707d95c5385ddc00b584f4fb350a6b0566b44222f8201215c504
+  metadata.gz: d3adf3511969f14520a4d3273dbf3555d690a8a2cb467e217825ce66f8cae9d8cae3c1431f31784ff987061c6acff1c8e081b91bebac858e96ac8013d071a67d
+  data.tar.gz: 06a2920e423ecf3f656b2b5f10ad5a8a32cf5bff46a55a12416b94f77bd484b3bf443a3cfdde7267e89a011cc282ef2580ae883191b167918f23cc6e9383c833

data/README.md

@@ -136,7 +136,7 @@ module Clockwork
 end
 ```
 
-This tells clockwork to fetch all MyScheduledTask instances from the database, and create an event for each, configured based on the instances' `frequency`, `name`, and `at` methods. It also says to reload the tasks from the database every 1.minute - we need to frequently do this as they could have changed (but you can choose a sensible reload frequency by changing the `every:` option). Note that the database sync event will always run on the minute-boundary (i.e. HH:MM::00), and that events which have been synced from the database won't be run in that same clock cycle (this prevents a task from the database being run twice).
+This tells clockwork to fetch all MyScheduledTask instances from the database, and create an event for each, configured based on the instances' `frequency`, `name`, and `at` methods. It also says to reload the tasks from the database every 1.minute - we need to frequently do this as they could have changed (but you can choose a sensible reload frequency by changing the `every:` option).
 
 Rails ActiveRecord models are a perfect candidate for the model class, but you could use something else. The only requirements are:
 
@@ -144,7 +144,7 @@ Rails ActiveRecord models are a perfect candidate for the model class, but you c
   2. the instances returned respond to:
       `frequency` returning the how frequently (in seconds) the database task should be run
       `name` returning the task's job name (this is what gets passed into the block above)
-      `at` return nil or '' if not using :at, or any acceptable clockwork :at string
+      `at` return nil or `''` if not using `:at`, or otherwise any acceptable clockwork `:at` string
 
 Here's an example of one way of setting up your ActiveRecord models, using Sidekiq for background tasks, and making the model class a worker:
 

data/clockwork.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "clockwork"
-  s.version = "0.7.3"
+  s.version = "0.7.4"
 
   s.authors = ["Adam Wiggins", "tomykaira"]
   s.license = 'MIT'

data/lib/clockwork/manager_with_database_tasks.rb

@@ -8,14 +8,71 @@ module Clockwork
 
   extend Methods
 
-  class ManagerWithDatabaseTasks < Manager
+  class DatabaseEventSyncPerformer
+
+    def initialize(manager, model, proc)
+      @manager = manager
+      @model = model
+      @block = proc
+      @events = {}
+    end
+
+    # Ensure clockwork events reflect database tasks
+    # Adds any new tasks, modifies updated ones, and delets removed ones
+    def sync
+      model_ids_that_exist = []
+
+      @model.all.each do |db_task|
+        model_ids_that_exist << db_task.id
+        
+        if !event_exists_for_task(db_task) || db_task_has_changed(db_task)
+          create_event_for_database_task(db_task)
+        end
+      end
+
+      remove_deleted_database_tasks(model_ids_that_exist)
+    end
+
+    def events
+      @events.values
+    end
 
-    SECOND_TO_RUN_DATABASE_SYNC_AT = 0
+    def add_event(e, task_id)
+      @events[task_id] = e
+    end
+
+    protected
+
+      def create_event_for_database_task(db_task)
+        options = { 
+          :from_database => true, 
+          :db_task_id =>  db_task.id,
+          :performer => self,
+          :at => db_task.at.blank? ? nil : db_task.at.split(',')
+        }
+
+        @manager.every db_task.frequency, db_task.name, options, &@block
+      end
+
+      def event_exists_for_task(db_task)
+        @events[db_task.id]
+      end
+
+      def remove_deleted_database_tasks(model_ids_that_exist)
+        @events.reject!{|db_task_id, _| !model_ids_that_exist.include?(db_task_id) }
+      end
+
+      def db_task_has_changed(task)
+        event = @events[task.id]
+        task.name != event.job || task.frequency != event.instance_variable_get(:@period)
+      end
+  end
+
+  class ManagerWithDatabaseTasks < Manager
 
     def initialize
       super
-      @events_from_database = []
-      @next_sync_database_tasks_identifier = 0
+      @database_event_sync_performers = []
     end
 
     def sync_database_tasks(options={}, &block)
@@ -24,64 +81,33 @@ module Clockwork
       end
       raise ArgumentError.new(":every must be greater or equal to 1.minute") if options[:every] < 1.minute
 
-      model = options[:model]
-      frequency = options[:every]
-      sync_task_id = get_sync_task_id
-
-      # Prevent database tasks from running in same cycle as the database sync,
-      # as this can lead to the same task being run twice
-      options_to_run_database_sync_in_own_cycle  = { :if => lambda { |t| t.sec == SECOND_TO_RUN_DATABASE_SYNC_AT } }
+      sync_performer = DatabaseEventSyncPerformer.new(self, options[:model], block)
+      @database_event_sync_performers << sync_performer
 
       # create event that syncs clockwork events with database events
-      every frequency, "sync_database_tasks_for_model_#{model}", options_to_run_database_sync_in_own_cycle do
-        reload_events_from_database sync_task_id, model, &block
+      every options[:every], "sync_database_tasks_for_model_#{options[:model]}" do
+        sync_performer.sync
       end
     end
 
+    private
 
-    protected
-
-    # sync_task_id's are used to group the database events from a particular sync_database_tasks call
-    # This method hands out the ids, incrementing the id to keep them unique.
-    def get_sync_task_id
-      current_sync_task_id = @next_sync_database_tasks_identifier
-      @next_sync_database_tasks_identifier += 1
-      current_sync_task_id
-    end
-
-    def reload_events_from_database(sync_task_id, model, &block)
-      @events_from_database[sync_task_id] = []
-
-      model.all.each do |db_task|
-        options = { from_database: true, :sync_task_id => sync_task_id }
-        options[:at] = db_task.at.split(',') unless db_task.at.blank?
-
-        # If database tasks can be scheduled in same clock cycle that database syncs occur
-        # then previous copy of database sync task will be stored and set to run (in #tick events variable)
-        # *before* we then delete all database tasks. This causes the task to be run at HH:00 (previous copy)
-        # and at HH:01 (newly fetched copy).
-        option_to_prevent_database_tasks_running_in_same_cycle_as_sync = { :if => lambda{|t| t.sec != SECOND_TO_RUN_DATABASE_SYNC_AT } }
-        every db_task.frequency,
-        db_task.name,
-        options.merge(option_to_prevent_database_tasks_running_in_same_cycle_as_sync),
-        &block
-      end
+    def events_from_database_as_array
+      @database_event_sync_performers.collect{|performer| performer.events}.flatten
     end
 
-    private
-
     def events_to_run(t)
-      (@events + @events_from_database.flatten).select{|event| event.run_now?(t) }
+      (@events + events_from_database_as_array).select{|event| event.run_now?(t) }
     end
 
     def register(period, job, block, options)
-      event = Event.new(self, period, job, block || handler, options)
-      if options[:from_database]
-        @events_from_database[options[:sync_task_id]] << event
-      else
-        @events << event
+      Event.new(self, period, job, block || handler, options).tap do |e|
+        if options[:from_database]
+          options[:performer].add_event(e, options[:db_task_id])
+        else
+          @events << e
+        end
       end
-      event
     end
   end
 end

data/test/manager_with_database_tasks_test.rb

@@ -56,135 +56,160 @@ class ManagerWithDatabaseTasksTest < Test::Unit::TestCase
       end
     end
 
-    setup do
-      @tasks_run = []
-      @scheduled_task1 = stub(:frequency => 10, :name => 'ScheduledTask:1', :at => nil)
-      @scheduled_task2 = stub(:frequency => 10, :name => 'ScheduledTask:2', :at => nil)
-      @scheduled_task1_modified = stub(:frequency => 5, :name => 'ScheduledTaskModified:1', :at => nil)
-      ScheduledTask.stubs(:all).returns([@scheduled_task1])
+    context "when database reload frequency is greater than task frequency period" do
+      setup do
+        @tasks_run = []
+        @scheduled_task1 = stub(:frequency => 10, :name => 'ScheduledTask:1', :at => nil, :id => 1)
+        @scheduled_task2 = stub(:frequency => 10, :name => 'ScheduledTask:2', :at => nil, :id => 2)
+        @scheduled_task1_modified = stub(:frequency => 5, :name => 'ScheduledTaskModified:1', :at => nil, :id => 3)
+        ScheduledTask.stubs(:all).returns([@scheduled_task1])
 
-      @database_reload_frequency = 1.minute
+        @database_reload_frequency = 1.minute
 
-      @now = Time.now
-      @next_minute = next_minute(@now) # database sync task only happens on minute boundary
+        @now = Time.now
 
-      # setup the database sync
-      @manager.sync_database_tasks model: ScheduledTask, every: @database_reload_frequency do |job_name|
-        @tasks_run << job_name
+        # setup the database sync
+        @manager.sync_database_tasks model: ScheduledTask, every: @database_reload_frequency do |job_name|
+          @tasks_run << job_name
+        end
       end
-    end
 
-    def test_does_not_fetch_database_tasks_until_next_minute
-      seconds_upto_and_including_next_minute = (@next_minute - @now).seconds.to_i + 1
-      tick_at(@now, :and_every_second_for => seconds_upto_and_including_next_minute)
-      assert_equal [], @tasks_run
-    end
+      def test_fetches_and_registers_database_task
+        tick_at(@now, :and_every_second_for => 1.second)
+        assert_equal ["ScheduledTask:1"], @tasks_run
+      end
 
-    def test_fetches_and_registers_database_task
-      tick_at(@next_minute, :and_every_second_for => 1.second)
-      assert_equal ["ScheduledTask:1"], @tasks_run
-    end
+      def test_multiple_database_tasks_can_be_registered
+        ScheduledTask.stubs(:all).returns([@scheduled_task1, @scheduled_task2])
+        tick_at(@now, :and_every_second_for => 1.second)
+        assert_equal ["ScheduledTask:1", "ScheduledTask:2"], @tasks_run
+      end
 
-    def test_multiple_database_tasks_can_be_registered
-      ScheduledTask.stubs(:all).returns([@scheduled_task1, @scheduled_task2])
-      tick_at(@next_minute, :and_every_second_for => 1.second)
-      assert_equal ["ScheduledTask:1", "ScheduledTask:2"], @tasks_run
-    end
+      def test_database_task_does_not_run_again_before_frequency_specified_in_database
+        tick_at(@now, :and_every_second_for => @scheduled_task1.frequency - 1.second) # runs at 1
+        assert_equal 1, @tasks_run.length
+      end
 
-    def test_database_task_does_not_run_again_before_frequency_specified_in_database
-      tick_at(@next_minute, :and_every_second_for => 9.seconds) # runs at 1
-      assert_equal 1, @tasks_run.length
-    end
+      def test_database_task_runs_repeatedly_with_frequency_specified_in_database
+        tick_at(@now, :and_every_second_for => (2 * @scheduled_task1.frequency) + 1.second) # runs at 1, 11, and 21
+        assert_equal 3, @tasks_run.length
+      end
 
-    def test_database_task_runs_repeatedly_with_frequency_specified_in_database
-      tick_at(@next_minute, :and_every_second_for => 21.seconds) # runs at 1, 11, and 21
-      assert_equal 3, @tasks_run.length
-    end
+      def test_reloads_tasks_from_database
+        ScheduledTask.stubs(:all).returns([@scheduled_task1], [@scheduled_task2])
+        tick_at(@now, :and_every_second_for => @database_reload_frequency.seconds)
+        @manager.tick # @scheduled_task2 should run immediately on next tick (then every 10 seconds)
+
+        assert_equal [
+          "ScheduledTask:1",
+          "ScheduledTask:1",
+          "ScheduledTask:1",
+          "ScheduledTask:1",
+          "ScheduledTask:1",
+          "ScheduledTask:1",
+          "ScheduledTask:2"], @tasks_run
+      end
 
-    def test_reloads_tasks_from_database
-      ScheduledTask.stubs(:all).returns([@scheduled_task1], [@scheduled_task2])
-      tick_at(@next_minute, :and_every_second_for => @database_reload_frequency.seconds)
-      @manager.tick # @scheduled_task2 should run immediately on next tick (then every 10 seconds)
+      def test_reloaded_tasks_run_repeatedly
+        ScheduledTask.stubs(:all).returns([@scheduled_task1], [@scheduled_task2])
+        tick_at(@now, :and_every_second_for => @database_reload_frequency.seconds + 11.seconds)
+        assert_equal ["ScheduledTask:2", "ScheduledTask:2"], @tasks_run[-2..-1]
+      end
 
-      assert_equal "ScheduledTask:2", @tasks_run.last
-    end
+      def test_reloading_task_with_modified_frequency_will_run_with_new_frequency
+        ScheduledTask.stubs(:all).returns([@scheduled_task1], [@scheduled_task1_modified])
 
-    def test_reloaded_tasks_run_repeatedly
-      ScheduledTask.stubs(:all).returns([@scheduled_task1], [@scheduled_task2])
-      tick_at(@next_minute, :and_every_second_for => @database_reload_frequency.seconds + 11.seconds)
-      assert_equal ["ScheduledTask:2", "ScheduledTask:2"], @tasks_run[-2..-1]
-    end
+        tick_at(@now, :and_every_second_for => 66.seconds)
 
-    def test_stops_running_deleted_database_task
-      ScheduledTask.stubs(:all).returns([@scheduled_task1], [])
-      tick_at(@next_minute, :and_every_second_for => @database_reload_frequency.seconds)
-      before = @tasks_run.dup
+        # task1 runs at: 1, 11, 21, 31, 41, 51 (6 runs)
+        # database tasks are reloaded at: 60
+        # task1_modified runs at: 61 (next tick after reload) and then 66 (2 runs)
+        assert_equal 8, @tasks_run.length
+      end
 
-      # tick through reload, and run for enough ticks that previous task would have run
-      tick_at(@next_minute + @database_reload_frequency.seconds + 20.seconds)
-      after = @tasks_run
+      def test_stops_running_deleted_database_task
+        ScheduledTask.stubs(:all).returns([@scheduled_task1], [])
+        tick_at(@now, :and_every_second_for => @database_reload_frequency.seconds)
+        before = @tasks_run.dup
 
-      assert_equal before, after
-    end
+        # tick through reload, and run for enough ticks that previous task would have run
+        tick_at(@now + @database_reload_frequency.seconds + 20.seconds)
+        after = @tasks_run
 
-    def test_reloading_task_with_modified_frequency_will_run_with_new_frequency
-      ScheduledTask.stubs(:all).returns([@scheduled_task1], [@scheduled_task1_modified])
+        assert_equal before, after
+      end
 
-      tick_at(@next_minute, :and_every_second_for => 66.seconds)
+      def test_edited_tasks_switch_to_new_settings
+        tick_at @now, :and_every_second_for => @database_reload_frequency.seconds - 1.second
+        modified_task_1 = stub(:frequency => 30, :name => 'ScheduledTask:1_modified', :at => nil, :id => 1)
+        ScheduledTask.stubs(:all).returns([modified_task_1])
+        tick_at @now + @database_reload_frequency.seconds, :and_every_second_for => @database_reload_frequency.seconds - 1.seconds
+        assert_equal [
+          "ScheduledTask:1", 
+          "ScheduledTask:1", 
+          "ScheduledTask:1",
+          "ScheduledTask:1",
+          "ScheduledTask:1",
+          "ScheduledTask:1",
+          "ScheduledTask:1_modified",
+          "ScheduledTask:1_modified"
+          ], @tasks_run
+      end
 
-      # task1 runs at: 1, 11, 21, 31, 41, 51 (6 runs)
-      # database tasks are reloaded at: 60
-      # task1_modified runs at: 61 (next tick after reload) and then 66 (2 runs)
-      assert_equal 8, @tasks_run.length
-    end
+      def test_daily_task_with_at_should_only_run_once
+        next_minute = next_minute(@now)
+        at = next_minute.strftime('%H:%M')
+        @scheduled_task_with_at = stub(:frequency => 1.day, :name => 'ScheduledTaskWithAt:1', :at => at, :id => 5)
+        ScheduledTask.stubs(:all).returns([@scheduled_task_with_at])
 
-    # Catch a bug caused by allowing database tasks to be run in the same clock cycle that the database
-    # sync occurs. When this happens, a previously scheduled database task will be scheduled to run,
-    # we then fetch the same task afresh (wiping out the @events_from_database object), but the
-    # previously scheduled task still runs because #task `events` variable already stored it *before*
-    # we wiped out the @events_from_database objects.
-    #
-    # We have a situation like this:
-    #
-    # 12:31:00    #tick loops through events to run
-    #               sync_database_tasks_for_model_ task is run
-    #                 fetches database task 1 with :at => 12:32, and schedules it to run (object task 1')
-    #
-    # ...
-    #
-    # 12:32:00    #tick loops through events that should be run, of which task 1' is included
-    #               sync_database_tasks_for_model_ task is run
-    #                 fetches database task 1 with :at => 12:32, and schedules it to run (object task 1'')
-    #               task 1' is run
-    #
-    # 12:32:01    #tick loops through events that should be run, of which task 1'' is included
-    #               task 1'' is run
-    def test_daily_task_with_at_should_not_run_twice_when_already_scheduled
-      minute_after_next = next_minute(@next_minute)
-      at = minute_after_next.strftime('%H:%M')
-      @scheduled_task_with_at = stub(:frequency => 1.day, :name => 'ScheduledTaskWithAt:1', :at => at)
-      ScheduledTask.stubs(:all).returns([@scheduled_task_with_at])
-
-      # tick from now, though specified :at time
-      tick_at(@now, :and_every_second_for => (2 * @database_reload_frequency.seconds) + 1.second)
-
-      assert_equal 1, @tasks_run.length
-    end
+        # tick from now, though specified :at time
+        tick_at(@now, :and_every_second_for => (2 * @database_reload_frequency.seconds) + 1.second)
+
+        assert_equal 1, @tasks_run.length
+      end
+
+      def test_having_multiple_sync_database_tasks_will_work
+        ScheduledTask.stubs(:all).returns([@scheduled_task1])
+
+        # setup 2nd database sync
+        @scheduled_task_type2 = stub(:frequency => 10, :name => 'ScheduledTaskType2:1', :at => nil, :id => 6)
 
-    def test_having_multiple_sync_database_tasks_will_work
-      ScheduledTask.stubs(:all).returns([@scheduled_task1])
+        ScheduledTaskType2.stubs(:all).returns([@scheduled_task_type2])
+        @manager.sync_database_tasks model: ScheduledTaskType2, every: @database_reload_frequency do |job_name|
+          @tasks_run << job_name
+        end
 
-      # setup 2nd database sync
-      @scheduled_task_type2 = stub(:frequency => 10, :name => 'ScheduledTaskType2:1', :at => nil)
+        tick_at(@now, :and_every_second_for => 1.second)
 
-      ScheduledTaskType2.stubs(:all).returns([@scheduled_task_type2])
-      @manager.sync_database_tasks model: ScheduledTaskType2, every: @database_reload_frequency do |job_name|
-        @tasks_run << job_name
+        assert_equal ["ScheduledTask:1", "ScheduledTaskType2:1"], @tasks_run
       end
+    end
+
+    context "when database reload frequency is less than task frequency period" do
+      setup do
+        @tasks_run = []
+        @scheduled_task1 = stub(:frequency => 5.minutes, :name => 'ScheduledTask:1', :at => nil, :id => 1)
+        @scheduled_task2 = stub(:frequency => 10, :name => 'ScheduledTask:2', :at => nil, :id => 2)
+        @scheduled_task1_modified = stub(:frequency => 5, :name => 'ScheduledTaskModified:1', :at => nil)
+        ScheduledTask.stubs(:all).returns([@scheduled_task1])
+
+        @database_reload_frequency = 1.minute
 
-      tick_at(@next_minute, :and_every_second_for => 1.second)
+        @now = Time.now
+        @next_minute = next_minute(@now) # database sync task only happens on minute boundary
 
-      assert_equal ["ScheduledTask:1", "ScheduledTaskType2:1"], @tasks_run
+        # setup the database sync
+        @manager.sync_database_tasks model: ScheduledTask, every: @database_reload_frequency do |job_name|
+          @tasks_run << job_name
+        end
+      end
+
+      # For example: if the manager updates every minute, but the task specifies 5 minutes, 
+      # the task will still run every minute.
+      def test_it_only_runs_the_task_once_within_the_task_frequency_period
+        tick_at(@now, :and_every_second_for => 5.minutes)
+        assert_equal 1, @tasks_run.length
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: clockwork
 version: !ruby/object:Gem::Version
-  version: 0.7.3
+  version: 0.7.4
 platform: ruby
 authors:
 - Adam Wiggins
@@ -9,104 +9,104 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-20 00:00:00.000000000 Z
+date: 2014-04-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tzinfo
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: daemons
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: contest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: mocha
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: A scheduler process to replace cron, using a more flexible Ruby syntax
@@ -121,8 +121,8 @@ extensions: []
 extra_rdoc_files:
 - README.md
 files:
-- .gitignore
-- .travis.yml
+- ".gitignore"
+- ".travis.yml"
 - Gemfile
 - README.md
 - Rakefile
@@ -152,17 +152,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.2.0
 signing_key: 
 specification_version: 4
 summary: A scheduler process to replace cron.