All messages should have same priority

It's now possible to send actor << job1 << job2 <<:terminate! and be sure that
both jobs are processed first.

Author: pitr-ch

lib/concurrent/actor/behaviour.rb

@@ -33,35 +33,43 @@ module Behaviour
       require 'concurrent/actor/behaviour/terminates_children'
 
       def self.basic_behaviour_definition
-        [*base,
-         *user_messages(:terminate!)]
+        [*base(:terminate!),
+         *linking,
+         *user_messages]
       end
 
-      def self.restarting_behaviour_definition
-        [*base,
+      def self.restarting_behaviour_definition(handle = :reset!, strategy = :one_for_one)
+        [*base(:pause!),
+         *linking,
          *supervised,
-         [Behaviour::Supervising, [:reset!, :one_for_one]],
-         *user_messages(:pause!)]
+         *supervising(handle, strategy),
+         *user_messages]
       end
 
-      def self.base
-        [[SetResults, [:terminate!]],
+      def self.base(on_error)
+        [[SetResults, [on_error]],
          # has to be before Termination to be able to remove children form terminated actor
          [RemovesChild, []],
          [Termination, []],
-         [TerminatesChildren, []],
-         [Linking, []]]
+         [TerminatesChildren, []]]
+      end
+
+      # @see '' its source code
+      def self.linking
+        [[Linking, []]]
       end
 
       def self.supervised
         [[Supervised, []],
          [Pausing, []]]
       end
 
-      def self.user_messages(on_error)
-        [[Buffer, []],
-         [SetResults, [on_error]],
-         [Awaits, []],
+      def self.supervising(handle = :reset!, strategy = :one_for_one)
+        [[Behaviour::Supervising, [handle, strategy]]]
+      end
+
+      def self.user_messages
+        [[Awaits, []],
          [ExecutesContext, []],
          [ErrorsOnUnknownMessage, []]]
       end

lib/concurrent/actor/behaviour/pausing.rb

@@ -66,7 +66,7 @@ def on_event(event)
             @buffer.each { |envelope| reject_envelope envelope }
             @buffer.clear
           when :resumed, :reset
-            @buffer.each { |envelope| core.schedule_execution { pass envelope } }
+            @buffer.each { |envelope| core.schedule_execution { core.process_envelope envelope } }
             @buffer.clear
           end
           super event

lib/concurrent/actor/root.rb

@@ -28,9 +28,9 @@ def dead_letter_routing
       end
 
       def behaviour_definition
-        [*Behaviour.base,
-         [Behaviour::Supervising, [:reset!, :one_for_one]],
-         *Behaviour.user_messages(:just_log)]
+        [*Behaviour.base(:just_log),
+         *Behaviour.supervising,
+         *Behaviour.user_messages]
       end
     end
   end

spec/concurrent/actor_spec.rb

@@ -282,13 +282,7 @@ def on_message(message)
       describe 'pausing' do
         it 'pauses on error' do
           queue              = Queue.new
-          resuming_behaviour = Behaviour.restarting_behaviour_definition.map do |c, args|
-            if Behaviour::Supervising == c
-              [c, [:resume!, :one_for_one]]
-            else
-              [c, args]
-            end
-          end
+          resuming_behaviour = Behaviour.restarting_behaviour_definition(:resume!)
 
           test = AdHoc.spawn name: :tester, behaviour_definition: resuming_behaviour do
             actor = AdHoc.spawn name:                 :pausing,
@@ -302,9 +296,7 @@ def on_message(message)
             actor << nil
             queue << actor.ask(:add)
 
-            -> m do
-              queue << m
-            end
+            -> m { queue << m }
           end
 
           expect(queue.pop).to eq :init