clockwork 1.0.0 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7deeb150ded639846749af6efb04b31157dc430f
-  data.tar.gz: d97f85b001f54997b6c5fd5f2c160da31c8d0a73
+  metadata.gz: 4da3864c6de51bceab841eca257ffbc2926525a3
+  data.tar.gz: ff3ff9e0e1bef436a100785f818e57253bcc6f1c
 SHA512:
-  metadata.gz: b6d0b9c662b085d8243aaa23e00fc1c4549810ec3d346ce0b789eef518f7c839ea830d9c8ec7b785d33cdce81a3587e13b097673cd5ca3e133e40f8133007edb
-  data.tar.gz: b162bd32440586badc9156aa06738bda2ad581474d23bf7daf946d8c8a6aa7e55d6e63129ebd9776dc100bc02a2bfae02b21b06f31d3510968c0410f1c724f53
+  metadata.gz: 0bbbb9668d0b1aa9526217188e50d6d5e44b493c25c7be369f98371038667434bbcd392a615ba73ec120001da0f0a89bb3faaf395245228484566029bdb6def5
+  data.tar.gz: dc8a6b4a47b174293f92e91066fb74d7c4ab1ad1310eb5c6c11d6706e381f8e435095e9b8d4f5ebbe8c9ed85bc7617f87b695c7153172a5f219c920e0997b91b

data/.ruby-version

@@ -0,0 +1 @@
+2.1.0

data/README.md

@@ -116,7 +116,7 @@ Here we're using an `ActiveRecord` model called `ClockworkDatabaseEvent` to stor
 
 ```ruby
 require 'clockwork'
-require 'clockwork/manager_with_database_events'
+require 'clockwork/database_events'
 require_relative './config/boot'
 require_relative './config/environment'
 

data/clockwork.gemspec

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

data/lib/clockwork.rb

@@ -53,22 +53,3 @@ module Clockwork
 
   extend Methods
 end
-
-unless 1.respond_to?(:seconds)
-  class Numeric
-    def seconds; self; end
-    alias :second :seconds
-
-    def minutes; self * 60; end
-    alias :minute :minutes
-
-    def hours; self * 3600; end
-    alias :hour :hours
-
-    def days; self * 86400; end
-    alias :day :days
-
-    def weeks; self * 604800; end
-    alias :week :weeks
-  end
-end

data/lib/clockwork/database_events/event.rb

@@ -26,7 +26,7 @@ module Clockwork
 
       private
       def name_has_changed?(model)
-        !job.respond_to?(:name) || job.name != model.name
+        job.respond_to?(:name) && job.name != model.name
       end
 
       def frequency_has_changed?(model)

data/test/database_events/support/active_record_fake.rb

@@ -0,0 +1,66 @@
+module ActiveRecordFake
+
+  def self.included(base)
+    base.instance_variable_set(:@items, [])
+    base.instance_variable_set(:@next_id, 1)    
+    base.extend(ClassMethods)
+  end
+
+
+  attr_accessor :id
+
+  def initialize options={}
+    @id = options.fetch(:id) { self.class.get_next_id }
+    set_attribute_values_from_options options.reject{|key, value| key == :id }
+    self.class.add self
+  end
+
+  def delete!
+    self.class.remove(self)
+  end
+
+  def update options={}
+    set_attribute_values_from_options options
+  end
+
+  module ClassMethods
+    def create *args
+      new *args
+    end
+    
+    def delete_all
+      @items.clear
+      reset_id
+      true
+    end
+
+    def all
+      @items.dup
+    end
+    
+    
+    def add instance
+      @items << instance
+    end
+
+    def remove instance
+      @items.delete(instance)
+    end
+
+    def get_next_id
+      id = @next_id
+      @next_id += 1
+      id
+    end
+
+    def reset_id
+      @next_id = 1
+    end
+  end
+
+  private
+
+    def set_attribute_values_from_options options
+      options.each{|attr, value| self.send("#{attr}=".to_sym, value) }
+    end
+end

data/test/database_events/sync_performer_test.rb

@@ -13,8 +13,8 @@ module DatabaseEvents
 
     setup do
       @now = Time.now
-      DatabaseEventModelClass.delete_all
-      DatabaseEventModelClass2.delete_all
+      DatabaseEventModel.delete_all
+      DatabaseEventModel2.delete_all
 
       Clockwork.manager = @manager = Clockwork::DatabaseEvents::Manager.new
       class << @manager
@@ -29,7 +29,7 @@ module DatabaseEvents
 
       describe "arguments" do
         def test_does_not_raise_error_with_valid_arguments
-          @subject.setup(model: DatabaseEventModelClass, every: 1.minute) {}
+          @subject.setup(model: DatabaseEventModel, every: 1.minute) {}
         end
 
         def test_raises_argument_error_if_model_is_not_set
@@ -41,7 +41,7 @@ module DatabaseEvents
 
         def test_raises_argument_error_if_every_is_not_set
           error = assert_raises KeyError do
-            @subject.setup(model: DatabaseEventModelClass) {}
+            @subject.setup(model: DatabaseEventModel) {}
           end
           assert_equal error.message, ":every must be set to the database sync frequency"
         end
@@ -54,35 +54,35 @@ module DatabaseEvents
         end
 
         def test_fetches_and_registers_event_from_database
-          DatabaseEventModelClass.create(:frequency => 10)
-          setup_sync(model: DatabaseEventModelClass, :every => @sync_frequency, :events_run => @events_run)
+          DatabaseEventModel.create(:frequency => 10)
+          setup_sync(model: DatabaseEventModel, :every => @sync_frequency, :events_run => @events_run)
 
           tick_at(@now, :and_every_second_for => 1.second)
           
-          assert_equal ["DatabaseEventModelClass:1"], @events_run
+          assert_equal ["DatabaseEventModel:1"], @events_run
         end
 
         def test_multiple_events_from_database_can_be_registered
-          DatabaseEventModelClass.create(:frequency => 10)
-          DatabaseEventModelClass.create(:frequency => 10)
-          setup_sync(model: DatabaseEventModelClass, :every => @sync_frequency, :events_run => @events_run)
+          DatabaseEventModel.create(:frequency => 10)
+          DatabaseEventModel.create(:frequency => 10)
+          setup_sync(model: DatabaseEventModel, :every => @sync_frequency, :events_run => @events_run)
 
           tick_at(@now, :and_every_second_for => 1.second)
 
-          assert_equal ["DatabaseEventModelClass:1", "DatabaseEventModelClass:2"], @events_run
+          assert_equal ["DatabaseEventModel:1", "DatabaseEventModel:2"], @events_run
         end
 
         def test_event_from_database_does_not_run_again_before_frequency_specified_in_database
-          model = DatabaseEventModelClass.create(:frequency => 10)
-          setup_sync(model: DatabaseEventModelClass, :every => @sync_frequency, :events_run => @events_run)
+          model = DatabaseEventModel.create(:frequency => 10)
+          setup_sync(model: DatabaseEventModel, :every => @sync_frequency, :events_run => @events_run)
 
           tick_at(@now, :and_every_second_for => model.frequency - 1.second)
           assert_equal 1, @events_run.length
         end
 
         def test_event_from_database_runs_repeatedly_with_frequency_specified_in_database
-          model = DatabaseEventModelClass.create(:frequency => 10)
-          setup_sync(model: DatabaseEventModelClass, :every => @sync_frequency, :events_run => @events_run)
+          model = DatabaseEventModel.create(:frequency => 10)
+          setup_sync(model: DatabaseEventModel, :every => @sync_frequency, :events_run => @events_run)
 
           tick_at(@now, :and_every_second_for => (2 * model.frequency) + 1.second)
 
@@ -90,21 +90,19 @@ module DatabaseEvents
         end
 
         def test_reloaded_events_from_database_run_repeatedly
-          model = DatabaseEventModelClass.create(:frequency => 10)
-          setup_sync(model: DatabaseEventModelClass, :every => @sync_frequency, :events_run => @events_run)
+          model = DatabaseEventModel.create(:frequency => 10)
+          setup_sync(model: DatabaseEventModel, :every => @sync_frequency, :events_run => @events_run)
 
           tick_at(@now, :and_every_second_for => @sync_frequency - 1)
-
-          model.update(:name => "DatabaseEventModelClass:1:Reloaded")
-
+          model.update(:name => "DatabaseEventModel:1:Reloaded")
           tick_at(@now + @sync_frequency, :and_every_second_for => model.frequency * 2)
 
-          assert_equal ["DatabaseEventModelClass:1:Reloaded", "DatabaseEventModelClass:1:Reloaded"], @events_run[-2..-1]
+          assert_equal ["DatabaseEventModel:1:Reloaded", "DatabaseEventModel:1:Reloaded"], @events_run[-2..-1]
         end
 
         def test_reloading_events_from_database_with_modified_frequency_will_run_with_new_frequency
-          model = DatabaseEventModelClass.create(:frequency => 10)
-          setup_sync(model: DatabaseEventModelClass, :every => @sync_frequency, :events_run => @events_run)
+          model = DatabaseEventModel.create(:frequency => 10)
+          setup_sync(model: DatabaseEventModel, :every => @sync_frequency, :events_run => @events_run)
 
           tick_at(@now, :and_every_second_for => @sync_frequency - 1.second)
           model.update(:frequency => 5)
@@ -117,8 +115,8 @@ module DatabaseEvents
         end
 
         def test_stops_running_deleted_events_from_database
-          model = DatabaseEventModelClass.create(:frequency => 10)
-          setup_sync(model: DatabaseEventModelClass, :every => @sync_frequency, :events_run => @events_run)
+          model = DatabaseEventModel.create(:frequency => 10)
+          setup_sync(model: DatabaseEventModel, :every => @sync_frequency, :events_run => @events_run)
 
           tick_at(@now, :and_every_second_for => (@sync_frequency - 1.second))
           before = @events_run.dup
@@ -130,20 +128,20 @@ module DatabaseEvents
         end
 
         def test_event_from_database_with_edited_name_switches_to_new_name
-          model = DatabaseEventModelClass.create(:frequency => 10.seconds)
-          setup_sync(model: DatabaseEventModelClass, :every => @sync_frequency, :events_run => @events_run)
+          model = DatabaseEventModel.create(:frequency => 10.seconds)
+          setup_sync(model: DatabaseEventModel, :every => @sync_frequency, :events_run => @events_run)
 
           tick_at @now, :and_every_second_for => @sync_frequency - 1.second
           @events_run.clear
-          model.update(:name => "DatabaseEventModelClass:1_modified")
+          model.update(:name => "DatabaseEventModel:1_modified")
           tick_at @now + @sync_frequency, :and_every_second_for => (model.frequency * 2)
 
-          assert_equal ["DatabaseEventModelClass:1_modified", "DatabaseEventModelClass:1_modified"], @events_run
+          assert_equal ["DatabaseEventModel:1_modified", "DatabaseEventModel:1_modified"], @events_run
         end
 
         def test_event_from_database_with_edited_frequency_switches_to_new_frequency
-          model = DatabaseEventModelClass.create(:frequency => 10)
-          setup_sync(model: DatabaseEventModelClass, :every => @sync_frequency, :events_run => @events_run)
+          model = DatabaseEventModel.create(:frequency => 10)
+          setup_sync(model: DatabaseEventModel, :every => @sync_frequency, :events_run => @events_run)
 
           tick_at @now, :and_every_second_for => @sync_frequency - 1.second
           @events_run.clear
@@ -154,8 +152,8 @@ module DatabaseEvents
         end
 
         def test_event_from_database_with_edited_at_runs_at_new_at
-          model = DatabaseEventModelClass.create(:frequency => 1.day, :at => '10:30')
-          setup_sync(model: DatabaseEventModelClass, :every => @sync_frequency, :events_run => @events_run)
+          model = DatabaseEventModel.create(:frequency => 1.day, :at => '10:30')
+          setup_sync(model: DatabaseEventModel, :every => @sync_frequency, :events_run => @events_run)
 
           assert_will_run 'jan 1 2010 10:30:00'
           assert_wont_run 'jan 1 2010 09:30:00'
@@ -167,19 +165,35 @@ module DatabaseEvents
           assert_wont_run 'jan 1 2010 10:30:00'
         end
 
-        def test_daily_event_from_database_with_at_should_only_run_once
-          DatabaseEventModelClass.create(:frequency => 1.day, :at => next_minute(@now).strftime('%H:%M'))
-          setup_sync(model: DatabaseEventModelClass, :every => @sync_frequency, :events_run => @events_run)
+        context "when #name is defined" do
+          def test_daily_event_from_database_with_at_should_only_run_once
+            DatabaseEventModel.create(:frequency => 1.day, :at => next_minute(@now).strftime('%H:%M'))
+            setup_sync(model: DatabaseEventModel, :every => @sync_frequency, :events_run => @events_run)
 
-          # tick from now, though specified :at time
-          tick_at(@now, :and_every_second_for => (2 * @sync_frequency) + 1.second)
+            # tick from now, though specified :at time
+            tick_at(@now, :and_every_second_for => (2 * @sync_frequency) + 1.second)
+
+            assert_equal 1, @events_run.length
+          end
+        end
+
+        context "when #name is not defined" do
+
+          def test_daily_event_from_database_with_at_should_only_run_once
+            DatabaseEventModelWithoutName.create(:frequency => 1.day, :at => next_minute(next_minute(@now)).strftime('%H:%M'))
+            setup_sync(model: DatabaseEventModelWithoutName, :every => @sync_frequency, :events_run => @events_run)
+
+            # tick from now, though specified :at time
+            tick_at(@now, :and_every_second_for => (2 * @sync_frequency) + 1.second)
+
+            assert_equal 1, @events_run.length
+          end
 
-          assert_equal 1, @events_run.length
         end
 
-        def test_event_from_databse_with_comma_separated_at_leads_to_multiple_event_ats
-          DatabaseEventModelClass.create(:frequency => 1.day, :at => '16:20, 18:10')
-          setup_sync(model: DatabaseEventModelClass, :every => @sync_frequency, :events_run => @events_run)
+        def test_event_from_database_with_comma_separated_at_leads_to_multiple_event_ats
+          DatabaseEventModel.create(:frequency => 1.day, :at => '16:20, 18:10')
+          setup_sync(model: DatabaseEventModel, :every => @sync_frequency, :events_run => @events_run)
 
           tick_at @now, :and_every_second_for => 1.second
 
@@ -193,15 +207,15 @@ module DatabaseEvents
         end
 
         def test_syncing_multiple_database_models_works
-          DatabaseEventModelClass.create(:frequency => 10)
-          setup_sync(model: DatabaseEventModelClass, :every => @sync_frequency, :events_run => @events_run)
+          DatabaseEventModel.create(:frequency => 10)
+          setup_sync(model: DatabaseEventModel, :every => @sync_frequency, :events_run => @events_run)
 
-          DatabaseEventModelClass2.create(:frequency => 10)
-          setup_sync(model: DatabaseEventModelClass2, :every => @sync_frequency, :events_run => @events_run)
+          DatabaseEventModel2.create(:frequency => 10)
+          setup_sync(model: DatabaseEventModel2, :every => @sync_frequency, :events_run => @events_run)
 
           tick_at(@now, :and_every_second_for => 1.second)
 
-          assert_equal ["DatabaseEventModelClass:1", "DatabaseEventModelClass2:1"], @events_run
+          assert_equal ["DatabaseEventModel:1", "DatabaseEventModel2:1"], @events_run
         end
       end
 
@@ -211,8 +225,8 @@ module DatabaseEvents
         end
 
         def test_the_event_only_runs_once_within_the_model_frequency_period
-          DatabaseEventModelClass.create(:frequency => 5.minutes)
-          setup_sync(model: DatabaseEventModelClass, :every => 1.minute, :events_run => @events_run)
+          DatabaseEventModel.create(:frequency => 5.minutes)
+          setup_sync(model: DatabaseEventModel, :every => 1.minute, :events_run => @events_run)
 
           tick_at(@now, :and_every_second_for => 5.minutes)
 
@@ -224,8 +238,8 @@ module DatabaseEvents
         setup do
           @events_run = []
 
-          DatabaseEventModelClass.create(:frequency => 10)
-          setup_sync(model: DatabaseEventModelClass, :every => 1.minute, :events_run => @events_run)
+          DatabaseEventModel.create(:frequency => 10)
+          setup_sync(model: DatabaseEventModel, :every => 1.minute, :events_run => @events_run)
         end
 
         def test_it_does_not_raise_an_error
@@ -250,8 +264,8 @@ module DatabaseEvents
           @events_run = []
           @utc_time_now = Time.now.utc
           
-          DatabaseEventModelClass.create(:frequency => 1.days, :at => @utc_time_now.strftime('%H:%M'), :tz => 'America/Montreal')
-          setup_sync(model: DatabaseEventModelClass, :every => 1.minute, :events_run => @events_run)
+          DatabaseEventModel.create(:frequency => 1.days, :at => @utc_time_now.strftime('%H:%M'), :tz => 'America/Montreal')
+          setup_sync(model: DatabaseEventModel, :every => 1.minute, :events_run => @events_run)
         end
 
         def test_it_does_not_raise_an_error

data/test/database_events/test_helpers.rb

@@ -1,10 +1,13 @@
+require_relative 'support/active_record_fake'
+
 def setup_sync(options={})
   model_class = options.fetch(:model) { raise KeyError, ":model must be set to the model class" }
   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|
-    events_run << model.name
+    name = model.respond_to?(:name) ? model.name : model.to_s
+    events_run << name
   end
 end
 
@@ -31,71 +34,25 @@ def normalize_time t
 end
 
 
-class ActiveRecordFake
-  attr_accessor :id, :name, :at, :frequency, :tz
-
-  class << self
-    def create *args
-      new *args
-    end
-
-    def add instance
-      @events << instance
-    end
-
-    def remove instance
-      @events.delete(instance)
-    end
-
-    def next_id
-      id = @next_id
-      @next_id += 1
-      id
-    end
-
-    def reset_id
-      @next_id = 1
-    end
-
-    def delete_all
-      @events.clear
-      reset_id
-    end
-
-    def all
-      @events.dup
-    end
-  end
-
-  def initialize options={}
-    @id = options.fetch(:id) { self.class.next_id }
-    @name = options.fetch(:name) { nil }
-    @at = options.fetch(:at) { nil }        
-    @frequency = options.fetch(:frequency) { raise KeyError, ":every must be supplied" }
-    @tz = options.fetch(:tz) { nil }
-
-    self.class.add self
-  end
+class DatabaseEventModel
+  include ActiveRecordFake
+  attr_accessor :name, :frequency, :at, :tz
 
   def name
     @name || "#{self.class}:#{id}"
   end
+end
 
-  def delete!
-    self.class.remove(self)
-  end
+class DatabaseEventModel2
+  include ActiveRecordFake
+  attr_accessor :name, :frequency, :at, :tz
 
-  def update options={}
-    options.each{|attr, value| self.send("#{attr}=".to_sym, value) }
+  def name
+    @name || "#{self.class}:#{id}"
   end
 end
 
-class DatabaseEventModelClass < ActiveRecordFake
-  @events = []
-  @next_id = 1
-end
-
-class DatabaseEventModelClass2 < ActiveRecordFake
-  @events = []
-  @next_id = 1
+class DatabaseEventModelWithoutName
+  include ActiveRecordFake
+  attr_accessor :frequency, :at
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: clockwork
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.2
 platform: ruby
 authors:
 - Adam Wiggins
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-03 00:00:00.000000000 Z
+date: 2014-11-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tzinfo
@@ -136,6 +136,7 @@ extra_rdoc_files:
 - README.md
 files:
 - ".gitignore"
+- ".ruby-version"
 - ".travis.yml"
 - Gemfile
 - LICENSE
@@ -159,6 +160,7 @@ files:
 - lib/clockwork/manager.rb
 - test/at_test.rb
 - test/clockwork_test.rb
+- test/database_events/support/active_record_fake.rb
 - test/database_events/sync_performer_test.rb
 - test/database_events/test_helpers.rb
 - test/event_test.rb
@@ -183,13 +185,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: A scheduler process to replace cron.
 test_files:
 - test/at_test.rb
 - test/clockwork_test.rb
+- test/database_events/support/active_record_fake.rb
 - test/database_events/sync_performer_test.rb
 - test/database_events/test_helpers.rb
 - test/event_test.rb