Remove supervised behavior

Linking is enough,
Supervised was just making things complicated.

Author: pitr-ch

doc/actor/define.in.rb

@@ -29,7 +29,7 @@ def on_event(event)
   end
 end #
 
-an_actor = AnActor.spawn name: 'an_actor', args: 10, supervise: true #
+an_actor = AnActor.spawn name: 'an_actor', args: 10 #
 an_actor << Message.new(:add, 1) << Message.new(:subtract, 2) #
 an_actor.ask!(Message.new(:value, nil))
 an_actor << :boo << Message.new(:add, 1) #

doc/actor/define.out.rb

@@ -29,7 +29,7 @@ def on_event(event)
   end
 end 
 
-an_actor = AnActor.spawn name: 'an_actor', args: 10, supervise: true 
+an_actor = AnActor.spawn name: 'an_actor', args: 10 
 an_actor << Message.new(:add, 1) << Message.new(:subtract, 2) 
 an_actor.ask!(Message.new(:value, nil))            # => 9
 an_actor << :boo << Message.new(:add, 1) 

doc/actor/init.rb

@@ -1,2 +1 @@
 require 'concurrent/actor'
-Concurrent::Actor.i_know_it_is_experimental!

doc/actor/io.in.rb

@@ -33,7 +33,7 @@ def default_executor
 end #
 
 pool = Concurrent::Actor::Utils::Pool.spawn('pool', 2) do |balancer, index|
-  IOWorker.spawn(name: "worker-#{index}", supervise: true, args: [balancer])
+  IOWorker.spawn(name: "worker-#{index}", args: [balancer])
 end
 
 pool << 1 << 2 << 3 << 4 << 5 << 6

doc/actor/io.out.rb

@@ -35,7 +35,7 @@ def default_executor
 end 
 
 pool = Concurrent::Actor::Utils::Pool.spawn('pool', 2) do |balancer, index|
-  IOWorker.spawn(name: "worker-#{index}", supervise: true, args: [balancer])
+  IOWorker.spawn(name: "worker-#{index}", args: [balancer])
 end
     # => #<Concurrent::Actor::Reference:0x7fd6451ecaf8 /pool (Concurrent::Actor::Utils::Pool)>
 

doc/actor/messaging.out.rb

@@ -25,8 +25,8 @@ def on_message(message)
 end 
 
 calculator = Calculator.spawn('calculator')
-    # => #<Concurrent::Actor::Reference:0x7fd646110700 /calculator (Calculator)>
+    # => #<Concurrent::Actor::Reference:0x7fb94a2565d8 /calculator (Calculator)>
 calculator.ask! Add[1, 2]                          # => 3
 calculator.ask! Subtract[1, 0.5]                   # => 0.5
 calculator << :terminate!
-    # => #<Concurrent::Actor::Reference:0x7fd646110700 /calculator (Calculator)>
+    # => #<Concurrent::Actor::Reference:0x7fb94a2565d8 /calculator (Calculator)>

doc/actor/quick.in.rb

@@ -14,12 +14,13 @@ def on_message(message)
   end
 end #
 
-# `supervise: true` makes the actor supervised by root actor
-adder = Adder.spawn(name: :adder, supervise: true, args: [1])
+# `link: true` makes the actor linked to root actor and supervised
+# which is default behavior
+adder = Adder.spawn(name: :adder, link: true, args: [1])
 adder.parent
 
 # tell and forget
-adder.tell(:add) << :add
+adder.tell(:add).tell(:add)
 # ask to get result
 adder.ask!(:add)
 # fail the actor

doc/actor/quick.out.rb

@@ -14,15 +14,16 @@ def on_message(message)
   end
 end 
 
-# `supervise: true` makes the actor supervised by root actor
-adder = Adder.spawn(name: :adder, supervise: true, args: [1])
-    # => #<Concurrent::Actor::Reference:0x7fd64420ac48 /adder (Adder)>
+# `link: true` makes the actor linked to root actor and supervised
+# which is default behavior
+adder = Adder.spawn(name: :adder, link: true, args: [1])
+    # => #<Concurrent::Actor::Reference:0x7fb94bb30040 /adder (Adder)>
 adder.parent
     # => #<Concurrent::Actor::Reference:0x7fd644229008 / (Concurrent::Actor::Root)>
 
 # tell and forget
-adder.tell(:add) << :add
-    # => #<Concurrent::Actor::Reference:0x7fd64420ac48 /adder (Adder)>
+adder.tell(:add).tell(:add)
+    # => #<Concurrent::Actor::Reference:0x7fb94bb30040 /adder (Adder)>
 # ask to get result
 adder.ask!(:add)                                   # => 4
 # fail the actor

lib/concurrent/actor/behaviour.rb

@@ -64,7 +64,6 @@ module Behaviour
       require 'concurrent/actor/behaviour/pausing'
       require 'concurrent/actor/behaviour/removes_child'
       require 'concurrent/actor/behaviour/sets_results'
-      require 'concurrent/actor/behaviour/supervised'
       require 'concurrent/actor/behaviour/supervising'
       require 'concurrent/actor/behaviour/termination'
       require 'concurrent/actor/behaviour/terminates_children'
@@ -126,8 +125,7 @@ def self.linking
 
       # @see '' its source code
       def self.supervised
-        [[Supervised, []],
-         [Pausing, []]]
+        [[Pausing, []]]
       end
 
       # @see '' its source code

lib/concurrent/actor/behaviour/linking.rb

@@ -1,6 +1,8 @@
 module Concurrent
   module Actor
     module Behaviour
+      # TODO track what is linked, clean when :terminated
+      #   send :linked/:unlinked messages back to build the array of linked actors
 
       # Links the actor to other actors and sends actor's events to them,
       # like: `:terminated`, `:paused`, `:resumed`, errors, etc.
@@ -41,11 +43,11 @@ class Linking < Abstract
         def initialize(core, subsequent, core_options)
           super core, subsequent, core_options
           @linked = Set.new
-          if core_options[:link] != false || core_options[:supervise] != false
-            @linked.add Actor.current
-          end
+          @linked.add Actor.current if core_options[:link] != false
         end
 
+        # TODO also handle :linked_actors returning array
+
         def on_envelope(envelope)
           case envelope.message
           when :link

lib/concurrent/actor/behaviour/supervised.rb

@@ -37,7 +37,6 @@ class Core
       # @option opts [Array<Object>] args arguments for actor_class instantiation
       # @option opts [Executor] executor, default is `Concurrent.configuration.global_task_pool`
       # @option opts [true, false] link, atomically link the actor to its parent (default: true)
-      # @option opts [true, false] supervise, atomically supervise the actor by its parent (default: true)
       # @option opts [Class] reference a custom descendant of {Reference} to use
       # @option opts [Array<Array(Behavior::Abstract, Array<Object>)>] behaviour_definition, array of pairs
       #   where each pair is behaviour class and its args, see {Behaviour.basic_behaviour_definition}

lib/concurrent/actor/core.rb

@@ -280,7 +280,7 @@ def on_message(message)
       end
 
       describe 'pausing' do
-        it 'pauses on error' do
+        it 'pauses on error and resumes' do
           queue              = Queue.new
           resuming_behaviour = Behaviour.restarting_behaviour_definition(:resume!)
 
@@ -291,30 +291,32 @@ def on_message(message)
               -> m { m == :add ? 1 : pass }
             end
 
-            actor << :supervise
-            queue << actor.ask!(:supervisor)
+            actor << :link
+            queue << actor.ask!(:linked?)
             actor << nil
             queue << actor.ask(:add)
 
             -> m { queue << m }
           end
 
           expect(queue.pop).to eq :init
-          expect(queue.pop).to eq test
+          expect(queue.pop).to eq true
           expect(queue.pop.value).to eq 1
           expect(queue.pop).to eq :resumed
           terminate_actors test
+        end
 
+        it 'pauses on error and resets' do
+          queue              = Queue.new
           test = AdHoc.spawn name:                 :tester,
                              behaviour_definition: Behaviour.restarting_behaviour_definition do
             actor = AdHoc.spawn name:                 :pausing,
-                                supervise:            true,
                                 behaviour_definition: Behaviour.restarting_behaviour_definition do
               queue << :init
               -> m { m == :object_id ? self.object_id : pass }
             end
 
-            queue << actor.ask!(:supervisor)
+            queue << actor.ask!(:linked?)
             queue << actor.ask!(:object_id)
             actor << nil
             queue << actor.ask(:object_id)
@@ -325,14 +327,16 @@ def on_message(message)
           end
 
           expect(queue.pop).to eq :init
-          expect(queue.pop).to eq test
+          expect(queue.pop).to eq true
           first_id  = queue.pop
           second_id = queue.pop.value
           expect(first_id).not_to eq second_id # context already reset
           expect(queue.pop).to eq :init # rebuilds context
           expect(queue.pop).to eq :reset
           terminate_actors test
+        end
 
+        it 'pauses on error and restarts' do
           queue              = Queue.new
           resuming_behaviour = Behaviour.restarting_behaviour_definition.map do |c, args|
             if Behaviour::Supervising == c
@@ -349,8 +353,8 @@ def on_message(message)
               -> m { m == :add ? 1 : pass }
             end
 
-            actor << :supervise
-            queue << actor.ask!(:supervisor)
+            actor << :link
+            queue << actor.ask!(:linked?)
             actor << nil
             queue << actor.ask(:add)
 
@@ -360,7 +364,7 @@ def on_message(message)
           end
 
           expect(queue.pop).to eq :init
-          expect(queue.pop).to eq test
+          expect(queue.pop).to eq true
           expect(queue.pop.wait.reason).to be_a_kind_of(ActorTerminated)
           expect(queue.pop).to eq :init
           expect(queue.pop).to eq :restarted
@@ -378,7 +382,7 @@ def work(message)
           end
 
           pool = Concurrent::Actor::Utils::Pool.spawn! 'pool', 5 do |balancer, index|
-            worker.spawn name: "worker-#{index}", supervise: true, args: [balancer]
+            worker.spawn name: "worker-#{index}", args: [balancer]
           end
 
           expect(pool.ask!(5)).to eq 10