updater 0.10.0 → 0.10.1

data/VERSION

@@ -1 +1 @@
-0.10.0
+0.10.1

data/lib/updater/chained.rb

@@ -0,0 +1,43 @@
+module Updater
+  class Chained
+    class << self
+      def jobs(name)
+        name = name.to_s
+        @jobs ||= Hash.new {|_,n| find_or_create(n)}
+        @jobs[name]
+      end
+      
+      def reschedule(job,options)
+        new_time = options[:at] || Update.time.now + options[:in]
+        Update.at(
+          new_time,job.target,job.method,job.method_args,
+          :finder=>job.finder,
+          :finder_args=>job.finder_args,
+          :name=>job.name,
+          :success=>job.success - [jobs(:reschedule)],
+          :failure=>job.failure - [jobs(:reschedule)],
+          :ensure=>job.ensure - [jobs(:reschedule)]
+        )
+      end
+      
+      def __reset
+        @jobs = nil
+        @args_for == {}
+      end
+      
+      private
+      
+      def find_or_create(name)
+        Update.for(self,name) || create(name)
+      end
+      
+      def create(name)
+        Update.chain(self,name,args_for[name]||[:__job__,:__params__],:name=>name)
+      end
+      
+      def args_for
+        @args_for ||= {}
+      end
+    end # class << self
+  end # class Chained
+end # module Update

data/lib/updater/target.rb

@@ -0,0 +1,57 @@
+module Updater
+
+  # By including this module in a client's classes, it is possible to schedule jobs with the 
+  #  inlcuded methods.  This saves typing `Updater::Update.[in|at|immidate] `repeatedly.
+  #  The class also allows you to set special finder and ID methods on a per class basis.
+  module Target
+    def self.included(model)
+      model.class_eval do
+        class << self
+          
+          # This will overide the default finder for Update and the chosen ORM. Set
+          # it the symbol of a class method that can find/instantiate instances of the class.
+          # It will be passed the value returned from the ID method called on an 
+          # instance.  The ID method can be overridden as well.  See +updater_id_method+
+          attr_accessor :updater_finder_method
+          
+          # This will overide the ID method set in both with Update and the chosen ORM.
+          # Set it to the symbol of an instance method.  The value of this method will be given
+          # to the finder method in order to recreate the instance for the worker.  The finder
+          # method can be overridden as well.  See +updater_finder_method+
+          attr_accessor :updater_id_method
+        end
+      end
+      
+      super
+    end
+
+    # Finds all the jobs whose target is this instance.  If a name is given, it will
+    # return only the job with that name set.  There can be only one job with a
+    # given name per unique target.  Also note that jobs that have their finder
+    # or finder_args set on creation cannot be named and will not be found by
+    # this method.  See aslo Update#for
+    def jobs_for(name = nil)
+      Update.for(self, name)
+    end
+    
+    alias job_for jobs_for
+    
+    # Place a job on the queue for immidiate execution. This method is aliased
+    # to `send_later` for compatibility with delayed_job. See Also Update#immidiate
+    def enqueue(*args)
+      Update.immidiate(self,*args)
+    end
+    
+    alias send_later enqueue
+    
+    #Put a job on the queue to run at a spesified time. See Also Update#at
+    def send_at(time, *args)
+      Update.at(time,self,*args)
+    end
+    
+    #Put a job on the queue to run after a spesified duration (in seconds). See Also Update#in
+    def send_in(delta_seconds,*args)
+      Update.in(delta_seconds,self,*args)
+    end
+  end
+end

data/lib/updater/update.rb

@@ -47,14 +47,22 @@ module Updater
       @orm.send(method,*args)
     end
     
+    def method
+      @orm.method
+    end
+    
     # Determins and if necessary find/creates the target for this instance.
     # 
     # Warning: This value is intentionally NOT memoized.  For instance type targets, it will result in a call to the datastore 
     # (or the recreation of an object) on EACH invocation.  Methods that need to refer to the target more then once should
     # take care to store this value locally after initial retreavel.
     def target
-      target = @orm.finder.nil? ? @orm.target : @orm.target.send(@orm.finder,*@orm.finder_args)
-      raise TargetMissingError, "Target missing --Class:'#{@orm.target}' Finder:'#{@orm.finder}', Args:'#{@orm.finder_args.inspect}'" unless target
+      begin
+        target = @orm.finder.nil? ? @orm.target : @orm.target.send(@orm.finder,*@orm.finder_args)
+        raise TargetMissingError unless target
+      rescue
+        raise TargetMissingError, "Target missing --Class:'#{@orm.target}' Finder:'#{@orm.finder}', Args:'#{@orm.finder_args.inspect}'"
+      end
       target
     end
     
@@ -328,14 +336,6 @@ module Updater
         raise
       end
 
-      # Create a new job having the same charistics as the old, except that 'hash' will override the original.
-      def reschedule(update, hash={})
-        new_job = update.orm.dup
-        new_job.update_attributes(hash)
-        new_job.save
-        new(new_job)
-      end
-
       # like +at+ but with time as time.now.  Generally this will be used to run a long running operation in
       # asyncronously in a differen process.  See +at+ for details
       def immidiate(*args)
@@ -368,7 +368,7 @@ module Updater
         name ? ret.first : ret
       end
       
-            #The time class used by Updater.  See time= 
+      #The time class used by Updater.  See time= 
       def time
         @time ||= Time
       end
@@ -485,12 +485,20 @@ module Updater
       def target_for(inst,options = {})
         return [inst, options[:finder], options[:finder_args]] if (inst.kind_of?(Class) || inst.kind_of?(Module))
         [ inst.class, #target's class
-          options[:finder] || @finder_method || orm::FINDER, #method to call on targets class to find/create target
-          options[:finder_args] || inst.send(@finder_id || orm::ID) #value to pass to above method 
+          options[:finder] || #method to call on targets class to find/create target
+            inst.class.respond_to?(:updater_finder_method) && inst.class.updater_finder_method ||
+            @finder_method || 
+            orm::FINDER, 
+          options[:finder_args] || #value to pass to above method #TODO add test to require flattening
+            [inst.send(
+              @finder_id || 
+              inst.class.respond_to?(:updater_id_method) && inst.class.updater_id_method ||
+              orm::ID
+            )] 
         ]
       end
       
     end # class << self
   end #class Update
   
-end #Module Updater
+end #Module Updater

data/lib/updater.rb

@@ -5,4 +5,6 @@ module Updater
 end
 
 require 'updater/update.rb'
-require 'updater/setup.rb'
+require 'updater/setup.rb'
+require 'updater/chained.rb'
+require 'updater/target.rb'

data/spec/chained_class_spec.rb

@@ -0,0 +1,40 @@
+require File.join( File.dirname(__FILE__),  "spec_helper" )
+
+include Updater
+
+describe Chained do
+  before :each do
+    Chained.__reset
+    Update.clear_all
+  end
+  
+  describe "reschedule:" do
+    it "should return the job from #jobs" do
+      reschedule = Chained.jobs(:reschedule)
+      reschedule.should_not be_nil
+      reschedule.method.should == "reschedule"
+      reschedule.method_args.should == [:__job__,:__params__]
+      reschedule.name.should == "reschedule"
+    end
+    
+    it "should not schedule this job twice" do
+      reschedule = Chained.jobs(:reschedule)
+      Update.for(Chained).should == [reschedule]
+      reschedule = Chained.jobs(:reschedule)
+      Update.for(Chained).should == [reschedule]
+    end
+    
+    it "should add an identical job back to the queue in the time spesified" do
+      job = Update.immidiate(Foo,:bar,[],:name=>'testing')
+      job.destroy #pretend it has alread run to completion
+      reschedule = Chained.jobs(:reschedule)
+      reschedule.params = {:in=>10}
+      reschedule.run(job)
+      reschedule.error.should be_nil
+      new_job = Update.for(Foo, "testing")
+      new_job.should_not be_nil
+      new_job.time.should > job.time
+    end
+  end #describe "reschedule:" do
+
+end

data/spec/chained_spec.rb

@@ -2,8 +2,6 @@ require File.join( File.dirname(__FILE__),  "spec_helper" )
 
 include Updater
 
-require  File.join( File.dirname(__FILE__),  "fooclass" )
-
 describe "Chained Methods:" do
   
   before :each do

data/spec/fooclass.rb

@@ -17,6 +17,8 @@ class Foo
       storage[id]
     end
     
+    alias special_foo_finder find
+    
     def reset
       @storage = {}
     end
@@ -33,6 +35,10 @@ class Foo
     Foo.bar(:instance,*args)
   end
   
+  def special_foo_identification
+    @id
+  end
+  
   def self.bar(*args) 
     
   end

data/spec/target_spec.rb

@@ -0,0 +1,92 @@
+require File.join( File.dirname(__FILE__),  "spec_helper" )
+
+require  File.join( File.dirname(__FILE__),  "fooclass" )
+
+class Foo
+  include Updater::Target
+end
+
+describe Updater::Target do
+  before :each do
+    @foo = Foo.create(:name=>"foo instance")
+  end
+  
+  after :each do
+    Updater::Update.clear_all
+    Foo.reset
+  end
+  
+  describe "#jobs_for" do
+    specify "should not initially be any jobs for the target" do
+      @foo.jobs_for.should be_empty
+    end
+    
+    it "should contian all jobs regardless of how they got scheduled" do
+      expected = []
+      expected <<  @foo.enqueue(:bar)
+      expected <<  @foo.send_in(600, :bar)
+      expected <<  Updater::Update.in(1200, @foo, :bar)
+      expected.each do |expectation|
+        @foo.jobs_for.should include(expectation)
+      end
+    end
+    
+    it "should find a job by name" do
+      @foo.enqueue(:bar)
+      job = @foo.enqueue(:bar,[],:name=>"baz")
+      @foo.send_in(600, :bar)
+      Updater::Update.in(1200, @foo, :bar)
+      @foo.job_for("baz").should == job
+    end
+  end
+  
+  describe "should schedual a job for the target instance" do
+    
+    specify "immidiatly with #send_later" do #compatibiltiy with delayed_job
+      job = @foo.send_later :bar
+      job.should be_a_kind_of Updater::Update
+      job.target.should == @foo
+      @foo.jobs_for.should == [job]
+    end
+    
+    specify "immidiatly with #enqueue" do
+      job = @foo.enqueue :bar
+      job.should be_a_kind_of Updater::Update
+      job.target.should == @foo
+      @foo.jobs_for.should == [job]
+    end
+    
+    specify "at a certian time with #send_at" do
+      schedule_at = Time.now + 600
+      job = @foo.send_at schedule_at , :bar
+      job.target.should == @foo
+      job.time.should == schedule_at.to_i
+      @foo.jobs_for.should == [job]
+    end
+    
+    specify "after a certian time with #send_in" do
+      Timecop.freeze do
+        job = @foo.send_in 600 , :bar
+        job.target.should == @foo
+        job.time.should == Time.now.to_i + 600
+        @foo.jobs_for.should == [job]
+      end
+    end
+  end
+  
+  describe "resetting default finder and id values: " do
+    specify "finder" do
+      Foo.updater_finder_method = :special_foo_finder
+      job = @foo.enqueue :bar
+      job.finder.should == :special_foo_finder
+    end
+    
+    specify "id" do
+      Foo.updater_id_method = :special_foo_identification
+      @foo.should_receive(:special_foo_identification).and_return("razzle-dazzle")
+      job = @foo.enqueue :bar
+      job.finder_args.should == ["razzle-dazzle"]
+    end
+  
+  end
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 10
-  - 0
-  version: 0.10.0
+  - 1
+  version: 0.10.1
 platform: ruby
 authors: 
 - John F. Miller
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-06 00:00:00 -08:00
+date: 2011-03-21 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -95,8 +95,10 @@ files:
 - lib/updater.rb
 - lib/updater/setup.rb
 - lib/updater/util.rb
+- lib/updater/chained.rb
 - lib/updater/update.rb
 - lib/updater/fork_worker.rb
+- lib/updater/target.rb
 - lib/updater/tasks.rb
 - lib/updater/thread_worker.rb
 - lib/updater/orm/orm.rb
@@ -121,7 +123,9 @@ files:
 - spec/named_request_spec.rb
 - spec/update_runner_spec.rb
 - spec/util_spec.rb
+- spec/target_spec.rb
 - spec/fork_worker_spec.rb
+- spec/chained_class_spec.rb
 - spec/errors_spec.rb
 - bin/updater
 has_rdoc: true