internal actor events now support payload & minor improvements

Author: pitr-ch

doc/actor/define.in.rb

@@ -1,5 +1,3 @@
-require 'concurrent'
-
 Message = Struct.new :action, :value #
 
 class AnActor < Concurrent::Actor::RestartingContext

doc/actor/define.out.rb

@@ -1,5 +1,3 @@
-require 'concurrent'                               # => true
-
 Message = Struct.new :action, :value 
 
 class AnActor < Concurrent::Actor::RestartingContext
@@ -35,5 +33,5 @@ def on_event(event)
 an_actor << :boo << Message.new(:add, 1) 
 an_actor.ask!(Message.new(:value, nil))            # => 1
 an_actor << :terminate!
-    # => #<Concurrent::Actor::Reference:0x7fd6451f78e0 /an_actor (AnActor)>
+    # => #<Concurrent::Actor::Reference:0x7fb6fc9165d0 /an_actor (AnActor)>
 

doc/actor/format.rb

@@ -3,16 +3,17 @@
 require 'pry'
 require 'pp'
 
+root        = File.dirname(File.expand_path(Process.argv0))
 input_paths = if ARGV.empty?
-                Dir.glob("#{File.dirname(__FILE__)}/*.in.rb")
+                Dir.glob("#{root}/*.in.rb")
               else
                 ARGV
               end.map { |p| File.expand_path p }
 
 input_paths.each_with_index do |input_path, i|
 
   pid = fork do
-    require_relative 'init.rb'
+    require File.join(root, 'init.rb')
 
     begin
       output_path = input_path.gsub /\.in\.rb$/, '.out.rb'

doc/actor/init.rb

@@ -1 +1,2 @@
-require 'concurrent/actor'
+require 'concurrent'
+require 'concurrent-edge'

doc/actor/io.in.rb

@@ -23,8 +23,8 @@ def default_executor
 class IOWorker < Concurrent::Actor::Utils::AbstractWorker
   def work(io_job)
     # do IO work
-    sleep 1
-    puts "#{path} second:#{Time.now.to_i} message:#{io_job}"
+    sleep 0.1
+    puts "#{path} second:#{(Time.now.to_f*100).floor} message:#{io_job}"
   end
 
   def default_executor
@@ -46,4 +46,4 @@ def default_executor
 # /pool/worker-0 second:1414677668 message:5
 # /pool/worker-1 second:1414677668 message:6
 
-sleep 4
+sleep 1

doc/actor/io.out.rb

@@ -1,4 +1,4 @@
-require 'concurrent'                               # => true
+require 'concurrent'                               # => false
 
 # logger = Logger.new(STDOUT)
 # Concurrent.configuration.logger = logger.method(:add)
@@ -16,7 +16,7 @@ def default_executor
 end 
 
 actor_doing_io = ActorDoingIO.spawn :actor_doing_io
-    # => #<Concurrent::Actor::Reference:0x7fd6451fff40 /actor_doing_io (ActorDoingIO)>
+    # => #<Concurrent::Actor::Reference:0x7fb6fc906068 /actor_doing_io (ActorDoingIO)>
 actor_doing_io.executor == Concurrent.configuration.global_operation_pool
     # => true
 
@@ -25,8 +25,8 @@ def default_executor
 class IOWorker < Concurrent::Actor::Utils::AbstractWorker
   def work(io_job)
     # do IO work
-    sleep 1
-    puts "#{path} second:#{Time.now.to_i} message:#{io_job}"
+    sleep 0.1
+    puts "#{path} second:#{(Time.now.to_f*100).floor} message:#{io_job}"
   end
 
   def default_executor
@@ -37,10 +37,10 @@ def default_executor
 pool = Concurrent::Actor::Utils::Pool.spawn('pool', 2) do |balancer, index|
   IOWorker.spawn(name: "worker-#{index}", args: [balancer])
 end
-    # => #<Concurrent::Actor::Reference:0x7fd6451ecaf8 /pool (Concurrent::Actor::Utils::Pool)>
+    # => #<Concurrent::Actor::Reference:0x7fb6fc964190 /pool (Concurrent::Actor::Utils::Pool)>
 
 pool << 1 << 2 << 3 << 4 << 5 << 6
-    # => #<Concurrent::Actor::Reference:0x7fd6451ecaf8 /pool (Concurrent::Actor::Utils::Pool)>
+    # => #<Concurrent::Actor::Reference:0x7fb6fc964190 /pool (Concurrent::Actor::Utils::Pool)>
 
 # prints two lines each second
 # /pool/worker-0 second:1414677666 message:1
@@ -50,4 +50,4 @@ def default_executor
 # /pool/worker-0 second:1414677668 message:5
 # /pool/worker-1 second:1414677668 message:6
 
-sleep 4                                            # => 4
+sleep 1                                            # => 1

doc/actor/main.md

@@ -161,6 +161,10 @@ Any existing behavior can be subclassed
 By subclassing {Behaviour::Pausing} and overriding {Behaviour::Pausing#restart!}. Implementing 
 {AbstractContext#on_event} could be also considered.
 
+_We'll be happy to answer any other questions, 
+just [open an Issue](https://github.com/ruby-concurrency/concurrent-ruby/issues/new) or find us on 
+https://gitter.im/ruby-concurrency/concurrent-ruby._
+
 ## Speed
 
 Simple benchmark Actor vs Celluloid, the numbers are looking good

doc/actor/messaging.in.rb

@@ -1,4 +1,3 @@
-require 'concurrent'
 require 'algebrick'
 
 # Actor message protocol definition with Algebrick
@@ -17,14 +16,17 @@ def on_message(message)
           (on Add.(~any, ~any) do |a, b|
             a + b
           end),
-          # or use multi-assignment
+          # or using multi-assignment
           (on ~Subtract do |(a, b)|
             a - b
           end)
   end
 end #
 
 calculator = Calculator.spawn('calculator')
-calculator.ask! Add[1, 2]
-calculator.ask! Subtract[1, 0.5]
-calculator << :terminate!
+addition = calculator.ask Add[1, 2]
+substraction = calculator.ask Subtract[1, 0.5]
+results = (addition & substraction)
+results.value!
+
+calculator.ask! :terminate!

doc/actor/messaging.out.rb

@@ -1,5 +1,4 @@
-require 'concurrent'                               # => true
-require 'algebrick'                                # => true
+require 'algebrick'                                # => false
 
 # Actor message protocol definition with Algebrick
 Protocol = Algebrick.type do
@@ -17,16 +16,21 @@ def on_message(message)
           (on Add.(~any, ~any) do |a, b|
             a + b
           end),
-          # or use multi-assignment
+          # or using multi-assignment
           (on ~Subtract do |(a, b)|
             a - b
           end)
   end
 end 
 
 calculator = Calculator.spawn('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:0x7fb94a2565d8 /calculator (Calculator)>
+    # => #<Concurrent::Actor::Reference:0x7fb6fc915ec8 /calculator (Calculator)>
+addition = calculator.ask Add[1, 2]
+    # => <#Concurrent::Edge::Future:0x7fb6fc937190 pending blocks:[]>
+substraction = calculator.ask Subtract[1, 0.5]
+    # => <#Concurrent::Edge::Future:0x7fb6fc935598 pending blocks:[]>
+results = (addition & substraction)
+    # => <#Concurrent::Edge::ArrayFuture:0x7fb6fc967ea8 pending blocks:[]>
+results.value!                                     # => [3, 0.5]
+
+calculator.ask! :terminate!                        # => true

doc/actor/quick.out.rb

@@ -17,13 +17,13 @@ def on_message(message)
 # `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)>
+    # => #<Concurrent::Actor::Reference:0x7fb6fc88ff58 /adder (Adder)>
 adder.parent
-    # => #<Concurrent::Actor::Reference:0x7fd644229008 / (Concurrent::Actor::Root)>
+    # => #<Concurrent::Actor::Reference:0x7fb6fe0f5db8 / (Concurrent::Actor::Root)>
 
 # tell and forget
 adder.tell(:add).tell(:add)
-    # => #<Concurrent::Actor::Reference:0x7fb94bb30040 /adder (Adder)>
+    # => #<Concurrent::Actor::Reference:0x7fb6fc88ff58 /adder (Adder)>
 # ask to get result
 adder.ask!(:add)                                   # => 4
 # fail the actor