clockwork 1.2.1 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c0e853cc4ad85d5e3814beac451289db63f3cfdf
-  data.tar.gz: 4d5b4f49d461f7a2b9e6670d122cc74c3d3ee1dc
+  metadata.gz: 7fbf625509799141df225a803d47a38486923c26
+  data.tar.gz: 9e4f834dd23c3fa8d73b65a22643566be36dbef8
 SHA512:
-  metadata.gz: cdc0a27e31a8c45dc07aeedf1cb5c80e0983bb25dfee570568d91147a6b54d8524efc5d7ccc580f9a9ae09e0dd4126f562951a997864d142617ca44b3d4a3c2b
-  data.tar.gz: 68a028033d71834bd0c1904de8dfeaab9624593f1211cb9254483835c71489c7936ec9ffecef30fc70f5dd62884752b35b4c58575ab89dbbe5338eb8db4e77a4
+  metadata.gz: 5875887345a81b5d7c8202b6f6d4d5fc7a2b1fa968611a7ebb914d949e951fa25b63585e7b60d0e64e115866a2ee04172b08268037c2d95f0142cf78d43cd377
+  data.tar.gz: ac4cdfbb58324b6faa106556c3339df3aefae1c8701b860ecab04402660475eb399e659caf516a486c54e68e6b43e98b9f84b1647e848063d22c2d84d8207347

data/clockwork.gemspec

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

data/lib/clockwork/database_events.rb

@@ -1,6 +1,6 @@
 require_relative 'database_events/event'
-require_relative 'database_events/sync_performer'
-require_relative 'database_events/registry'
+require_relative 'database_events/synchronizer'
+require_relative 'database_events/event_store'
 require_relative 'database_events/manager'
 
 # TERMINOLOGY
@@ -15,7 +15,7 @@ module Clockwork
 
   module Methods
     def sync_database_events(options={}, &block)
-      DatabaseEvents::SyncPerformer.setup(options, &block)
+      DatabaseEvents::Synchronizer.setup(options, &block)
     end
   end
 
@@ -23,4 +23,4 @@ module Clockwork
 
   module DatabaseEvents
   end
-end
+end

data/lib/clockwork/database_events/event.rb

@@ -4,35 +4,30 @@ module Clockwork
 
     class Event < Clockwork::Event
 
-      attr_accessor :sync_performer, :at
+      attr_accessor :event_store, :at
 
-      def initialize(manager, period, job, block, sync_performer, options={})
+      def initialize(manager, period, job, block, event_store, options={})
         super(manager, period, job, block, options)
-        @sync_performer = sync_performer
-        @sync_performer.register(self, job)
+        @event_store = event_store
+        @event_store.register(self, job)
       end
 
       def name
-        (job.respond_to?(:name) && job.name) ? job.name : "#{job.class}:#{job.id}"
+        (job_has_name? && job.name) ? job.name : "#{job.class}:#{job.id}"
       end
 
-      def to_s
-        name
-      end
-
-      def name_or_frequency_has_changed?(model)
-        name_has_changed?(model) || frequency_has_changed?(model)
+      def job_has_name?
+        job.respond_to?(:name)
       end
 
-      private
-      def name_has_changed?(model)
-        job.respond_to?(:name) && job.name != model.name
+      def to_s
+        name
       end
 
-      def frequency_has_changed?(model)
-        @period != model.frequency
+      def frequency
+        @period
       end
     end
 
   end
-end
+end

data/lib/clockwork/database_events/event_collection.rb

@@ -0,0 +1,59 @@
+module Clockwork
+  module DatabaseEvents
+    class EventCollection
+
+      def initialize(manager=Clockwork.manager)
+        @events = []
+        @manager = manager
+      end
+
+      def add(event)
+        @events << event
+      end
+
+      def has_changed?(model)
+        return true if event.nil?
+
+        (has_name? && name != model.name) ||
+          frequency != model.frequency ||
+            ats != model_ats(model)
+      end
+
+      def unregister
+        events.each{|e| manager.unregister(e) }
+      end
+
+      private
+
+      attr_reader :events, :manager
+
+      def event
+        events.first
+      end
+
+      def has_name?
+        event.job_has_name?
+      end
+
+      def name
+        event.name
+      end
+
+      def frequency
+        event.frequency
+      end
+
+      def ats
+        events.collect(&:at).compact
+      end
+
+      def model_ats(model)
+        at_strings_for(model).collect{|at| At.parse(at) }
+      end
+
+      def at_strings_for(model)
+        model.at.to_s.split(',').map(&:strip)
+      end
+    end
+  end
+end

data/lib/clockwork/database_events/event_store.rb

@@ -0,0 +1,129 @@
+# How EventStore and Clockwork manager events are kept in sync...
+#
+# The normal Clockwork::Manager is responsible for keeping track of
+# Clockwork events, and ensuring they are scheduled at the correct time.
+# It has an @events array for this purpose.
+
+# For keeping track of Database-backed events though, we need to keep
+# track of more information about the events, e.g. the block which should
+# be triggered when they are run, which model the event comes from, the
+# model ID it relates to etc. Therefore, we devised a separate mechanism
+# for keeping track of these database-backed events: the per-model EventStore.
+
+# Having two classes responsible for keeping track of events though leads to
+# a slight quirk, in that these two have to be kept in sync. The way this is
+# done is by letting the EventStore largely defer to the Clockwork Manager.
+
+# 1. When the EventStore wishes to recreate events:
+#   - it asks the Clockwork.manager to do this for it
+#   - by calling Clockwork.manager.every
+
+# 2. When the DatabaseEvents::Manager creates events (via its #register)
+#   - it creates a new DatabaseEvents::Event
+#   - DatabaseEvents::Event#initialize registers it with the EventStore
+module Clockwork
+
+  module DatabaseEvents
+
+    class EventStore
+
+      def initialize(block_to_perform_on_event_trigger)
+        @related_events = {}
+        @block_to_perform_on_event_trigger = block_to_perform_on_event_trigger
+      end
+
+      # DatabaseEvents::Manager#register creates a new DatabaseEvents::Event, whose
+      # #initialize method registers the new database event with the EventStore by
+      # calling this method.
+      def register(event, model)
+        related_events_for(model.id).add(event)
+      end
+
+      def update(current_model_objects)
+        unregister_all_except(current_model_objects)
+        update_registered_models(current_model_objects)
+        register_new_models(current_model_objects)
+      end
+
+      def unregister_all_except(model_objects)
+        ids = model_objects.collect(&:id)
+        (@related_events.keys - ids).each{|id| unregister(id) }
+      end
+
+      def update_registered_models(model_objects)
+        registered_models(model_objects).each do |model|
+          if has_changed?(model)
+            unregister(model.id)
+            register_with_manager(model)
+          end
+        end
+      end
+
+      def register_new_models(model_objects)
+        unregistered_models(model_objects).each do |new_model_object|
+          register_with_manager(new_model_object)
+        end
+      end
+
+      private
+
+      attr_reader :related_events
+
+      def registered?(model)
+        related_events_for(model.id) != nil
+      end
+
+      def has_changed?(model)
+        related_events_for(model.id).has_changed?(model)
+      end
+
+      def related_events_for(id)
+        related_events[id] ||= EventCollection.new
+      end
+
+      def registered_models(model_objects)
+        model_objects.select{|m| registered?(m) }
+      end
+
+      def unregistered_models(model_objects)
+        model_objects.select{|m| !registered?(m) }
+      end
+
+      def unregister(id)
+        related_events_for(id).unregister
+        related_events.delete(id)
+      end
+
+      # When re-creating events, the Clockwork.manager must be used to
+      # create them, as it is ultimately responsible for ensuring that
+      # the events actually get run when they should. We call its #every
+      # method, which will result in DatabaseEvent::Manager#register being
+      # called, which creates a new DatabaseEvent::Event, which will be
+      # registered with the EventStore on #initialize.
+      def register_with_manager(model)
+        Clockwork.manager.
+          every(model.frequency, model, options(model),
+                &@block_to_perform_on_event_trigger)
+      end
+
+      def options(model)
+        options = {
+          :from_database => true,
+          :synchronizer => self,
+          :at => at_strings_for(model)
+        }
+
+        options[:tz] = model.tz if model.respond_to?(:tz)
+
+        options
+      end
+
+      def at_strings_for(model)
+        return nil if model.at.to_s.empty?
+
+        model.at.split(',').map(&:strip)
+      end
+    end
+
+  end
+end

data/lib/clockwork/database_events/manager.rb

@@ -10,7 +10,7 @@ module Clockwork
 
       def register(period, job, block, options)
         @events << if options[:from_database]
-          Clockwork::DatabaseEvents::Event.new(self, period, job, (block || handler), options.fetch(:sync_performer), options)
+          Clockwork::DatabaseEvents::Event.new(self, period, job, (block || handler), options.fetch(:synchronizer), options)
         else
           Clockwork::Event.new(self, period, job, block || handler, options)
         end

data/lib/clockwork/database_events/synchronizer.rb

@@ -0,0 +1,23 @@
+require_relative '../database_events'
+
+module Clockwork
+
+  module DatabaseEvents
+
+    class Synchronizer
+
+      def self.setup(options={}, &block_to_perform_on_event_trigger)
+        model_class = options.fetch(:model) { raise KeyError, ":model must be set to the model class" }
+        every = options.fetch(:every) { raise KeyError, ":every must be set to the database sync frequency" }
+
+        event_store = EventStore.new(block_to_perform_on_event_trigger)
+
+        # create event that syncs clockwork events with events coming from database-backed model
+        Clockwork.manager.every every, "sync_database_events_for_model_#{model_class}" do
+          event_store.update(model_class.all)
+        end
+      end
+    end
+
+  end
+end

data/test/database_events/event_store_test.rb

@@ -0,0 +1,24 @@
+require "minitest/autorun"
+require 'clockwork/database_events/event_store'
+require 'clockwork/database_events/event_collection'
+
+describe Clockwork::DatabaseEvents::EventStore do
+
+  described_class = Clockwork::DatabaseEvents::EventStore
+  EventCollection = Clockwork::DatabaseEvents::EventCollection
+
+  describe '#register' do
+    it 'adds the event to the event group' do
+      event_group = EventCollection.new
+      EventCollection.stubs(:new).returns(event_group)
+
+      event = OpenStruct.new
+      model = OpenStruct.new id: 1
+      subject = described_class.new(Proc.new {})
+
+      event_group.expects(:add).with(event)
+
+      subject.register(event, model)
+    end
+  end
+end

data/test/database_events/{sync_performer_test.rb → synchronizer_test.rb}

@@ -7,7 +7,7 @@ require_relative '../../lib/clockwork'
 require_relative '../../lib/clockwork/database_events'
 require_relative 'test_helpers'
 
-describe Clockwork::DatabaseEvents::SyncPerformer do
+describe Clockwork::DatabaseEvents::Synchronizer do
   before do
     @now = Time.now
     DatabaseEventModel.delete_all
@@ -25,7 +25,7 @@ describe Clockwork::DatabaseEvents::SyncPerformer do
 
   describe "setup" do
     before do
-      @subject = Clockwork::DatabaseEvents::SyncPerformer
+      @subject = Clockwork::DatabaseEvents::Synchronizer
     end
 
     describe "arguments" do

data/test/database_events/test_helpers.rb

@@ -5,7 +5,7 @@ def setup_sync(options={})
   frequency = options.fetch(:every) { raise KeyError, ":every must be set to the database sync frequency" }
   events_run = options.fetch(:events_run) { raise KeyError, ":events_run must be provided"}
 
-  Clockwork::DatabaseEvents::SyncPerformer.setup model: model_class, every: frequency do |model|
+  Clockwork::DatabaseEvents::Synchronizer.setup model: model_class, every: frequency do |model|
     name = model.respond_to?(:name) ? model.name : model.to_s
     events_run << name
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: clockwork
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.3.0
 platform: ruby
 authors:
 - Adam Wiggins
@@ -138,15 +138,17 @@ files:
 - lib/clockwork/at.rb
 - lib/clockwork/database_events.rb
 - lib/clockwork/database_events/event.rb
+- lib/clockwork/database_events/event_collection.rb
+- lib/clockwork/database_events/event_store.rb
 - lib/clockwork/database_events/manager.rb
-- lib/clockwork/database_events/registry.rb
-- lib/clockwork/database_events/sync_performer.rb
+- lib/clockwork/database_events/synchronizer.rb
 - lib/clockwork/event.rb
 - lib/clockwork/manager.rb
 - test/at_test.rb
 - test/clockwork_test.rb
+- test/database_events/event_store_test.rb
 - test/database_events/support/active_record_fake.rb
-- test/database_events/sync_performer_test.rb
+- test/database_events/synchronizer_test.rb
 - test/database_events/test_helpers.rb
 - test/event_test.rb
 - test/manager_test.rb
@@ -177,8 +179,9 @@ summary: A scheduler process to replace cron.
 test_files:
 - test/at_test.rb
 - test/clockwork_test.rb
+- test/database_events/event_store_test.rb
 - test/database_events/support/active_record_fake.rb
-- test/database_events/sync_performer_test.rb
+- test/database_events/synchronizer_test.rb
 - test/database_events/test_helpers.rb
 - test/event_test.rb
 - test/manager_test.rb

data/lib/clockwork/database_events/registry.rb

@@ -1,39 +0,0 @@
-module Clockwork
-
-  module DatabaseEvents
-
-    class Registry
-
-      def initialize
-        @events = Hash.new []
-      end
-
-      def register(event, model)
-        @events[model.id] = @events[model.id] + [event]
-      end
-
-      def unregister(model)
-        unregister_by_id(model.id)
-      end
-
-      def unregister_by_id(id)
-        @events[id].each{|e| Clockwork.manager.unregister(e) }
-        @events.delete(id)
-      end
-
-      def unregister_all_except(ids)
-        (@events.keys - ids).each{|id| unregister_by_id(id) }
-      end
-
-      # all events of same id will have same frequency/name, just different ats
-      def event_for(model)
-        events_for(model).first
-      end
-
-      def events_for(model)
-        @events[model.id]
-      end
-    end
-
-  end
-end

data/lib/clockwork/database_events/sync_performer.rb

@@ -1,94 +0,0 @@
-require_relative '../database_events'
-
-module Clockwork
-
-  module DatabaseEvents
-
-    class SyncPerformer
-
-      PERFORMERS = []
-
-      def self.setup(options={}, &block)
-        model_class = options.fetch(:model) { raise KeyError, ":model must be set to the model class" }
-        every = options.fetch(:every) { raise KeyError, ":every must be set to the database sync frequency" }
-
-        sync_performer = self.new(model_class, &block)
-
-        # create event that syncs clockwork events with events coming from database-backed model
-        Clockwork.manager.every every, "sync_database_events_for_model_#{model_class}" do
-          sync_performer.sync
-        end
-      end
-
-      def initialize(model_class, &proc)
-        @model_class = model_class
-        @block = proc
-        @database_event_registry = Registry.new
-
-        PERFORMERS << self
-      end
-
-      # delegates to Registry
-      def register(event, model)
-        @database_event_registry.register(event, model)
-      end
-
-      # Ensure clockwork events reflect events from database-backed model
-      # Adds any new events, modifies updated ones, and delets removed ones
-      def sync
-        model_ids_that_exist = []
-
-        @model_class.all.each do |model|
-          model_ids_that_exist << model.id
-          if are_different?(@database_event_registry.event_for(model), model)
-            create_or_recreate_event(model)
-          end
-        end
-        @database_event_registry.unregister_all_except(model_ids_that_exist)
-      end
-
-      private
-      def are_different?(event, model)
-        return true if event.nil?
-        event.name_or_frequency_has_changed?(model) || ats_have_changed?(model)
-      end
-
-      def ats_have_changed?(model)
-        model_ats = ats_array_for_event(model)
-        event_ats = ats_array_from_model(model)
-
-        model_ats != event_ats
-      end
-
-      def ats_array_for_event(model)
-        @database_event_registry.events_for(model).collect{|event| event.at }.compact
-      end
-
-      def ats_array_from_model(model)
-        (at_strings_for(model) || []).collect{|at| At.parse(at) }
-      end
-
-      def at_strings_for(model)
-        model.at.to_s.empty? ? nil : model.at.split(',').map(&:strip)
-      end
-
-      def create_or_recreate_event(model)
-        if @database_event_registry.event_for(model)
-          @database_event_registry.unregister(model)
-        end
-
-        options = {
-          :from_database => true,
-          :sync_performer => self,
-          :at => at_strings_for(model)
-        }
-
-        options[:tz] = model.tz if model.respond_to?(:tz)
-
-        # we pass actual model instance as the job, rather than just name
-        Clockwork.manager.every model.frequency, model, options, &@block
-      end
-    end
-
-  end
-end