orchestrated 0.0.6 → 0.0.7

data/lib/orchestrated/base.rb

@@ -6,7 +6,7 @@ module Orchestrated
       @target       = target
     end
     def method_missing(sym, *args)
-      raise 'cannot orchestrate with blocks because they are not portable across processes' if block_given?
+      raise ArgumentError.new('cannot orchestrate with blocks because they are not portable across processes') if block_given?
       Orchestration.create( @target, sym, args, @prerequisite)
     end
   end
@@ -25,8 +25,8 @@ module Orchestrated
       unless clazz.method_defined?(method_name)
         clazz.class_eval "
           def #{method_name}(prerequisite=Complete.new)
-            raise 'orchestrate does not take a block' if block_given?
-            raise %[cannot use \#{prerequisite.class.name} as a prerequisite] unless
+            raise ArgumentError.new('orchestrate does not take a block') if block_given?
+            raise ArgumentError.new(%[cannot use \#{prerequisite.class.name} as a prerequisite]) unless
               prerequisite.kind_of?(CompletionExpression)
             Proxy.new(prerequisite, self)
           end"

data/lib/orchestrated/dependency.rb

@@ -6,7 +6,6 @@ module Orchestrated
     attr_accessible :prerequisite_id
     belongs_to :prerequisite, :class_name => 'CompletionExpression'
     belongs_to :dependent, :class_name => 'CompletionExpression'
-
     before_validation :constrain
 
     state_machine :initial => :incomplete, :action => :save_avoiding_recursion do
@@ -35,23 +34,11 @@ module Orchestrated
     end
     def _constrain
       if prerequisite.present?
-        if prerequisite_id_changed? || new_record?
-          # this may be our first prerequisite, or our prerequisite may
-          # have changed—either way we must initialize our state
-
-          # This method can be called more than once in general since it is called
-          # as part of validation. Rather than loosening the state machine (to allow
-          # e.g. complete=>complete) we explicitly avoid re-submitting events here.
-          prerequisite_completed if prerequisite.complete? && can_prerequisite_completed?
-          prerequisite_canceled if prerequisite.canceled? && can_prerequisite_canceled?
-        else
-          # prerequisite has not changed so our state is already correct
-          if dependent_id_changed?
-            # dependent has been set for the first time—propigate state
-            call_dependent{|d| d.prerequisite_complete} if prerequisite.complete?
-            call_dependent{|d| d.prerequisite_canceled} if prerequisite.canceled?
-          end
-        end
+        # This method can be called more than once in general since it is called
+        # as part of validation. Rather than loosening the state machine (to allow
+        # e.g. complete=>complete) we explicitly avoid re-submitting events here.
+        prerequisite_completed if prerequisite.complete? && can_prerequisite_completed?
+        prerequisite_canceled if prerequisite.canceled? && can_prerequisite_canceled?
       end
       true
     end

data/lib/orchestrated/message_delivery.rb

@@ -3,7 +3,7 @@ module Orchestrated
     attr_accessor :orchestrated, :method_name, :args, :orchestration_id
 
     def initialize(orchestrated, method_name, args, orchestration_id)
-      raise 'all arguments to MessageDelivery constructor are required' unless
+      raise ArgumentError.new('all arguments to MessageDelivery constructor are required') unless
         orchestrated and method_name and args and orchestration_id
       self.orchestrated = orchestrated
       self.method_name  = method_name

data/lib/orchestrated/orchestration.rb

@@ -55,11 +55,12 @@ module Orchestrated
         transition [:waiting, :ready] => :canceled
       end
 
-      after_transition any => :ready do |orchestration, transition|
+      # a before (rather than an after) so that if we change state it'll be saved (piggybacked)
+      before_transition any => :ready do |orchestration, transition|
         orchestration.enqueue
       end
 
-      after_transition :ready => :canceled do |orchestration, transition|
+      before_transition :ready => :canceled do |orchestration, transition|
         orchestration.dequeue
       end
 
@@ -76,7 +77,7 @@ module Orchestrated
     # Actually creates a completion (wrapper). Not _exactly_ an orchestration—ssh…
     def self.create( value, sym, args, prerequisite)
       # wee! static analysis FTW!
-      raise 'prerequisite can never be complete' if prerequisite.never_complete?
+      raise ArgumentError.new('prerequisite can never be complete') if prerequisite.never_complete?
       prerequisite.save!
       OrchestrationCompletion.new.tap do |completion|
         completion.orchestration = new.tap do |orchestration|
@@ -87,6 +88,8 @@ module Orchestrated
             interest.orchestration = orchestration
             interest.save!
           end # interest
+          # interest linkage can often change orchestration state so we have to reload here
+          orchestration.reload
         end # orchestration
         completion.save!
       end # completion
@@ -97,7 +100,7 @@ module Orchestrated
     end
 
     def dequeue
-      delayed_job.destroy# if DelayedJob.exists?(delayed_job_id)
+      self.delayed_job.destroy
     end
 
   end

data/lib/orchestrated/version.rb

@@ -1,3 +1,3 @@
 module Orchestrated
-  VERSION = "0.0.6"
+  VERSION = "0.0.7"
 end

data/spec/unit/cancellation_spec.rb

@@ -36,9 +36,15 @@ describe 'cancellation' do
     before(:each) do
       @first_prerequisite = @dependent = First.new.orchestrated.do_first_thing(1)
     end
+    it 'should be ready' do
+      expect(@dependent.orchestration.state).to eq('ready')
+    end
     context 'that is ready' do
       include_context 'cancelling first prerequisite'
       it_should_behave_like 'cancellation:'
+      it 'should have no work queued' do
+        expect(DJ.job_count).to eq(0)
+      end
       it 'should never subsequently deliver the orchestrated message' do
         First.any_instance.should_not_receive(:do_first_thing)
         DJ.work(1)

data/spec/unit/completion_spec.rb

@@ -25,7 +25,7 @@ describe Orchestrated::CompletionExpression do
   end
   context 'Incomplete' do
     it 'should immediately raise an error' do
-      expect{First.new.orchestrated(Orchestrated::Incomplete.new).do_first_thing(12)}.to raise_error
+      expect{First.new.orchestrated(Orchestrated::Incomplete.new).do_first_thing(12)}.to raise_error(ArgumentError)
     end
   end
   context 'OrchestrationCompletion' do

data/spec/unit/delayed_job_spec.rb

@@ -21,9 +21,9 @@ class TestJob < Struct.new(:name)
   def enqueue(job)
   end
 
-  def perform
-    self.class.called[:perform] += 1
-  end
+  # def perform
+  #   self.class.called[:perform] += 1
+  # end
 
   def before(job)
   end

data/spec/unit/orchestrated_spec.rb

@@ -84,6 +84,9 @@ describe Orchestrated do
       it 'should return an Orchestration object' do
         expect(@result).to be_kind_of(Orchestrated::CompletionExpression)
       end
+      it 'should be ready' do
+        expect(@result.orchestration.state).to eq('ready')
+      end
     end
   end
   context 'invocation' do

data/spec/unit/rspec_spec.rb

@@ -1,6 +1,5 @@
 class Foo
   def bump(x)
-    x+1
   end
 end
 

data/spec/unit/static_analysis_spec.rb

@@ -8,13 +8,13 @@ describe 'performing static analysis' do
     context 'that is empty' do
       # chose this behavior to align with Ruby Enumerable#any?
       it 'should raise an error since it can never be complete' do
-        expect{Second.new.orchestrated(completion).do_second_thing(5)}.to raise_error
+        expect{Second.new.orchestrated(completion).do_second_thing(5)}.to raise_error(ArgumentError)
       end
     end
     context 'that contains only (static) Incompletes' do
       before(:each){completion<<Orchestrated::Incomplete.new}
       it 'should raise an error since it can never be complete' do
-        expect{Second.new.orchestrated(completion).do_second_thing(5)}.to raise_error
+        expect{Second.new.orchestrated(completion).do_second_thing(5)}.to raise_error(ArgumentError)
       end
     end
     context 'that directly containins a (static) Complete' do
@@ -41,7 +41,7 @@ describe 'performing static analysis' do
     context 'that directly contains a (static) Incomplete' do
       before(:each){completion<<Orchestrated::Incomplete.new}
       it 'should raise an error since it can never be complete' do
-        expect{Second.new.orchestrated(completion).do_second_thing(5)}.to raise_error
+        expect{Second.new.orchestrated(completion).do_second_thing(5)}.to raise_error(ArgumentError)
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: orchestrated
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
   prerelease: 
 platform: ruby
 authors: