concurrent-ruby 0.8.0 → 0.9.0.pre2

data/lib/concurrent/actor/errors.rb

@@ -1,27 +0,0 @@
-module Concurrent
-  module Actor
-    Error = Class.new(StandardError)
-
-    class ActorTerminated < Error
-      include TypeCheck
-
-      attr_reader :reference
-
-      def initialize(reference)
-        @reference = Type! reference, Reference
-        super reference.path
-      end
-    end
-
-    class UnknownMessage < Error
-      include TypeCheck
-
-      attr_reader :envelope
-
-      def initialize(envelope)
-        @envelope = Type! envelope, Envelope
-        super envelope.message.inspect
-      end
-    end
-  end
-end

data/lib/concurrent/actor/internal_delegations.rb

@@ -1,49 +0,0 @@
-module Concurrent
-  module Actor
-    module InternalDelegations
-      include PublicDelegations
-
-      # @see Core#children
-      def children
-        core.children
-      end
-
-      # @see Core#terminate!
-      def terminate!
-        behaviour!(Behaviour::Termination).terminate!
-      end
-
-      # delegates to core.log
-      # @see Logging#log
-      def log(level, message = nil, &block)
-        core.log(level, message, &block)
-      end
-
-      # @see AbstractContext#dead_letter_routing
-      def dead_letter_routing
-        context.dead_letter_routing
-      end
-
-      def redirect(reference, envelope = self.envelope)
-        reference.message(envelope.message, envelope.ivar)
-        Behaviour::MESSAGE_PROCESSED
-      end
-
-      # @return [AbstractContext]
-      def context
-        core.context
-      end
-
-      # see Core#behaviour
-      def behaviour(behaviour_class)
-        core.behaviour(behaviour_class)
-      end
-
-      # see Core#behaviour!
-      def behaviour!(behaviour_class)
-        core.behaviour!(behaviour_class)
-      end
-
-    end
-  end
-end

data/lib/concurrent/actor/public_delegations.rb

@@ -1,40 +0,0 @@
-module Concurrent
-  module Actor
-
-    # Provides publicly expose-able methods from {Core}.
-    module PublicDelegations
-      # @see Core#name
-      def name
-        core.name
-      end
-
-      # @see Core#path
-      def path
-        core.path
-      end
-
-      # @see Core#parent
-      def parent
-        core.parent
-      end
-
-      # @see Core#reference
-      def reference
-        core.reference
-      end
-
-      # @see Core#executor
-      def executor
-        core.executor
-      end
-
-      # @see Core#context_class
-      def context_class
-        core.context_class
-      end
-
-      alias_method :ref, :reference
-      alias_method :actor_class, :context_class
-    end
-  end
-end

data/lib/concurrent/actor/reference.rb

@@ -1,81 +0,0 @@
-module Concurrent
-  module Actor
-
-    # Reference is public interface of Actor instances. It is used for sending messages and can
-    # be freely passed around the program. It also provides some basic information about the actor,
-    # see {PublicDelegations}.
-    class Reference
-      include TypeCheck
-      include PublicDelegations
-
-      attr_reader :core
-      private :core
-
-      # @!visibility private
-      def initialize(core)
-        @core = Type! core, Core
-      end
-
-      # tells message to the actor, returns immediately
-      # @param [Object] message
-      # @return [Reference] self
-      def tell(message)
-        message message, nil
-      end
-
-      alias_method :<<, :tell
-
-      # @note it's a good practice to use tell whenever possible. Ask should be used only for
-      # testing and when it returns very shortly. It can lead to deadlock if all threads in
-      # global_task_pool will block on while asking. It's fine to use it form outside of actors and
-      # global_task_pool.
-      #
-      # sends message to the actor and asks for the result of its processing, returns immediately
-      # @param [Object] message
-      # @param [Ivar] ivar to be fulfilled be message's processing result
-      # @return [IVar] supplied ivar
-      def ask(message, ivar = IVar.new)
-        message message, ivar
-      end
-
-      # @note it's a good practice to use tell whenever possible. Ask should be used only for
-      # testing and when it returns very shortly. It can lead to deadlock if all threads in
-      # global_task_pool will block on while asking. It's fine to use it form outside of actors and
-      # global_task_pool.
-      #
-      # sends message to the actor and asks for the result of its processing, blocks
-      # @param [Object] message
-      # @param [Ivar] ivar to be fulfilled be message's processing result
-      # @return [Object] message's processing result
-      # @raise [Exception] ivar.reason if ivar is #rejected?
-      def ask!(message, ivar = IVar.new)
-        ask(message, ivar).value!
-      end
-
-      # behaves as {#tell} when no ivar and as {#ask} when ivar
-      def message(message, ivar = nil)
-        core.on_envelope Envelope.new(message, ivar, Actor.current || Thread.current, self)
-        return ivar || self
-      end
-
-      # @see AbstractContext#dead_letter_routing
-      def dead_letter_routing
-        core.dead_letter_routing
-      end
-
-      def to_s
-        "#<#{self.class} #{path} (#{actor_class})>"
-      end
-
-      alias_method :inspect, :to_s
-
-      def ==(other)
-        Type? other, self.class and other.send(:core) == core
-      end
-
-      # to avoid confusion with Kernel.spawn
-      undef_method :spawn
-    end
-
-  end
-end

data/lib/concurrent/actor/root.rb

@@ -1,37 +0,0 @@
-module Concurrent
-  module Actor
-    # implements the root actor
-    class Root < AbstractContext
-
-      def initialize
-        # noinspection RubyArgCount
-        @dead_letter_router = Core.new(parent:    reference,
-                                       class:     DefaultDeadLetterHandler,
-                                       supervise: true,
-                                       name:      :default_dead_letter_handler).reference
-      end
-
-      # to allow spawning of new actors, spawn needs to be called inside the parent Actor
-      def on_message(message)
-        case
-        when message.is_a?(Array) && message.first == :spawn
-          Actor.spawn message[1], &message[2]
-        when message == :dead_letter_routing
-          @dead_letter_router
-        else
-          # ignore
-        end
-      end
-
-      def dead_letter_routing
-        @dead_letter_router
-      end
-
-      def behaviour_definition
-        [*Behaviour.base,
-         [Behaviour::Supervising, [:reset!, :one_for_one]],
-         *Behaviour.user_messages(:just_log)]
-      end
-    end
-  end
-end

data/lib/concurrent/actor/type_check.rb

@@ -1,48 +0,0 @@
-module Concurrent
-  module Actor
-
-    # taken from Algebrick
-    # supplies type-checking helpers whenever included
-    module TypeCheck
-
-      def Type?(value, *types)
-        types.any? { |t| value.is_a? t }
-      end
-
-      def Type!(value, *types)
-        Type?(value, *types) or
-            TypeCheck.error(value, 'is not', types)
-        value
-      end
-
-      def Match?(value, *types)
-        types.any? { |t| t === value }
-      end
-
-      def Match!(value, *types)
-        Match?(value, *types) or
-            TypeCheck.error(value, 'is not matching', types)
-        value
-      end
-
-      def Child?(value, *types)
-        Type?(value, Class) &&
-            types.any? { |t| value <= t }
-      end
-
-      def Child!(value, *types)
-        Child?(value, *types) or
-            TypeCheck.error(value, 'is not child', types)
-        value
-      end
-
-      private
-
-      def self.error(value, message, types)
-        raise TypeError,
-              "Value (#{value.class}) '#{value}' #{message} any of: #{types.join('; ')}."
-      end
-    end
-  end
-end
-

data/lib/concurrent/actor/utils.rb

@@ -1,10 +0,0 @@
-module Concurrent
-  module Actor
-    module Utils
-      require 'concurrent/actor/utils/ad_hoc'
-      require 'concurrent/actor/utils/broadcast'
-      require 'concurrent/actor/utils/balancer'
-      require 'concurrent/actor/utils/pool'
-    end
-  end
-end

data/lib/concurrent/actor/utils/ad_hoc.rb

@@ -1,21 +0,0 @@
-module Concurrent
-  module Actor
-    module Utils
-      # Allows quick creation of actors with behaviour defined by blocks.
-      # @example ping
-      #   AdHoc.spawn :forward, an_actor do |where|
-      #     # this block has to return proc defining #on_message behaviour
-      #     -> message { where.tell message  }
-      #   end
-      class AdHoc < Context
-        def initialize(*args, &initializer)
-          @on_message = Type! initializer.call(*args), Proc
-        end
-
-        def on_message(message)
-          instance_exec message, &@on_message
-        end
-      end
-    end
-  end
-end

data/lib/concurrent/actor/utils/balancer.rb

@@ -1,42 +0,0 @@
-module Concurrent
-  module Actor
-    module Utils
-
-      # Distributes messages between subscribed actors. Each actor'll get only one message then
-      # it's unsubscribed. The actor needs to resubscribe when it's ready to receive next message.
-      # It will buffer the messages if there is no worker registered.
-      # @see Pool
-      class Balancer < RestartingContext
-
-        def initialize
-          @receivers = []
-          @buffer    = []
-        end
-
-        def on_message(message)
-          case message
-          when :subscribe
-            @receivers << envelope.sender
-            distribute
-            true
-          when :unsubscribe
-            @receivers.delete envelope.sender
-            true
-          when :subscribed?
-            @receivers.include? envelope.sender
-          else
-            @buffer << envelope
-            distribute
-            Behaviour::MESSAGE_PROCESSED
-          end
-        end
-
-        def distribute
-          while !@receivers.empty? && !@buffer.empty?
-            redirect @receivers.shift, @buffer.shift
-          end
-        end
-      end
-    end
-  end
-end

data/lib/concurrent/actor/utils/broadcast.rb

@@ -1,52 +0,0 @@
-require 'set'
-
-module Concurrent
-  module Actor
-    module Utils
-
-      # Allows to build pub/sub easily.
-      # @example news
-      #   news_channel = Concurrent::Actor::Utils::Broadcast.spawn :news
-      #
-      #   2.times do |i|
-      #     Concurrent::Actor::Utils::AdHoc.spawn "listener-#{i}" do
-      #       news_channel << :subscribe
-      #       -> message { puts message }
-      #     end
-      #   end
-      #
-      #   news_channel << 'Ruby rocks!'
-      #   # prints: 'Ruby rocks!' twice
-      class Broadcast < RestartingContext
-
-        def initialize
-          @receivers = Set.new
-        end
-
-        def on_message(message)
-          case message
-          when :subscribe
-            if envelope.sender.is_a? Reference
-              @receivers.add envelope.sender
-              true
-            else
-              false
-            end
-          when :unsubscribe
-            !!@receivers.delete(envelope.sender)
-          when :subscribed?
-            @receivers.include? envelope.sender
-          else
-            filtered_receivers.each { |r| r << message }
-          end
-        end
-
-        # override to define different behaviour, filtering etc
-        def filtered_receivers
-          @receivers
-        end
-      end
-
-    end
-  end
-end

data/lib/concurrent/actor/utils/pool.rb

@@ -1,59 +0,0 @@
-require 'concurrent/actor/utils/balancer'
-
-module Concurrent
-  module Actor
-    module Utils
-
-      # Allows to create a pool of workers and distribute work between them
-      # @param [Integer] size number of workers
-      # @yield [balancer, index] a block spawning an worker instance. called +size+ times.
-      #   The worker should be descendant of AbstractWorker and supervised, see example.
-      # @yieldparam [Balancer] balancer to pass to the worker
-      # @yieldparam [Integer] index of the worker, usually used in its name
-      # @yieldreturn [Reference] the reference of newly created worker
-      # @example
-      #     class Worker < Concurrent::Actor::Utils::AbstractWorker
-      #       def work(message)
-      #         p message * 5
-      #       end
-      #     end
-      #
-      #     pool = Concurrent::Actor::Utils::Pool.spawn! 'pool', 5 do |balancer, index|
-      #       Worker.spawn name: "worker-#{index}", supervise: true, args: [balancer]
-      #     end
-      #
-      #     pool << 'asd' << 2
-      #     # prints:
-      #     # "asdasdasdasdasd"
-      #     # 10
-      class Pool < RestartingContext
-        def initialize(size, &worker_initializer)
-          @balancer = Balancer.spawn name: :balancer, supervise: true
-          @workers  = Array.new(size, &worker_initializer.curry[@balancer])
-          @workers.each { |w| Type! w, Reference }
-        end
-
-        def on_message(message)
-          redirect @balancer
-        end
-      end
-
-      class AbstractWorker < RestartingContext
-        def initialize(balancer)
-          @balancer = balancer
-          @balancer << :subscribe
-        end
-
-        def on_message(message)
-          work message
-        ensure
-          @balancer << :subscribe
-        end
-
-        def work(message)
-          raise NotImplementedError
-        end
-      end
-    end
-  end
-end