delayer-deferred 1.1.1 → 2.0.0

data/lib/delayer/deferred/deferredable/trigger.rb

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+require "delayer/deferred/deferredable/chainable"
+require "delayer/deferred/deferredable/node_sequence"
+require "delayer/deferred/response"
+
+module Delayer::Deferred::Deferredable
+=begin rdoc
+Promiseなど、親を持たず、自身がWorkerを作成できるもの。
+=end
+  module Trigger
+    include NodeSequence
+    include Chainable
+
+    # Deferredを直ちに実行する。
+    # このメソッドはスレッドセーフです。
+    def call(value = nil)
+      execute(Delayer::Deferred::Response::Ok.new(value))
+    end
+
+    # Deferredを直ちに失敗させる。
+    # このメソッドはスレッドセーフです。
+    def fail(exception = nil)
+      execute(Delayer::Deferred::Response::Ng.new(exception))
+    end
+
+    private
+
+    def execute(value)
+      worker = Delayer::Deferred::Worker.new(delayer: self.class.delayer,
+                                             initial: value)
+      worker.push(self)
+    end
+  end
+end

data/lib/delayer/deferred/enumerator.rb

@@ -5,12 +5,10 @@ require "delayer/deferred/deferred"
 class Enumerator
   def deach(delayer=Delayer, &proc)
     delayer.Deferred.new.next do
-      begin
-        loop do
-          proc.call(self.next())
-          if delayer.expire?
-            break deach(delayer, &proc) end end
-      rescue StopIteration
-        nil end end
+      self.each do |node|
+        delayer.Deferred.pass
+        proc.(node)
+      end
+    end
   end
 end

data/lib/delayer/deferred/error.rb

@@ -10,4 +10,13 @@ module Delayer::Deferred
       @process = process
     end
   end
+
+  SequenceError = Class.new(Error) do
+    attr_accessor :deferred
+    def initialize(message, deferred: nil)
+      super(message)
+      @deferred = deferred
+    end
+  end
+  MultipleAssignmentError = Class.new(SequenceError)
 end

data/lib/delayer/deferred/promise.rb

@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+require "delayer/deferred/tools"
+require "delayer/deferred/deferredable/trigger"
+
+module Delayer::Deferred
+  class Promise
+    extend Delayer::Deferred::Tools
+    include Deferredable::Trigger
+
+    class << self
+      def new(stop=false, name: caller_locations(1,1).first.to_s,  &block)
+        result = promise = super(name: name)
+        result = promise.next(&block) if block_given?
+        promise.call(true) unless stop
+        result
+      end
+
+      def Thread
+        @thread_class ||= gen_thread_class end
+
+      def Promise
+        self
+      end
+
+      def delayer
+        ::Delayer
+      end
+
+      def to_s
+        "#{self.delayer}.Promise"
+      end
+
+      private
+
+      def gen_thread_class
+        the_delayer = delayer
+        Class.new(Thread) do
+          define_singleton_method(:delayer) do
+            the_delayer
+          end
+        end
+      end
+    end
+
+    def initialize(name:)
+      super()
+      @name = name
+    end
+
+    def activate(response)
+      change_sequence(:activate)
+      change_sequence(:complete)
+      response
+    end
+
+    def inspect
+      "#<#{self.class} seq:#{sequence.name}>"
+    end
+
+    def ancestor
+      self
+    end
+
+    def parent=(chainable)
+      fail Error, "#{self.class} can't has parent."
+    end
+
+    private
+
+    def graph_shape
+      'egg'.freeze
+    end
+
+    def node_name
+      @name.to_s
+    end
+  end
+end

data/lib/delayer/deferred/request.rb

@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*-
+
+# -*- coding: utf-8 -*-
+
+module Delayer::Deferred::Request
+  class Base
+    attr_reader :value
+    def initialize(value)
+      @value = value
+    end
+  end
+
+=begin rdoc
+Fiberが次のWorkerを要求している時に返す値。
+新たなインスタンスは作らず、 _NEXT_WORKER_ にあるインスタンスを使うこと。
+=end
+  class NextWorker < Base
+    # _deferred_ に渡された次のChainableに、 _deferred_ の戻り値を渡す要求を出す。
+    # ==== Args
+    # [deferred] 実行が完了したDeferred 。次のDeferredとして _deferred.child_ を呼び出す
+    # [worker] このDeferredチェインを実行しているWorker
+    def accept_request(worker:, deferred:)
+      if deferred.has_child?
+        worker.push(deferred.child)
+      else
+        deferred.add_child_observer(worker)
+      end
+    end
+  end
+
+=begin rdoc
+Chainable#+@ が呼ばれた時に、一旦そこで処理を止めるためのリクエスト。
+_value_ には、実行完了を待つDeferredが入っている。
+==== わかりやすい！
+  accept_requestメソッドの引数のdeferred {
+    +value
+  }
+=end
+  class Await < Base
+    alias_method :foreign_deferred, :value
+    def accept_request(worker:, deferred:)
+      deferred.enter_await
+      foreign_deferred.add_child(Delayer::Deferred::Chain::Await.new(worker: worker, deferred: deferred))
+    end
+  end
+
+=begin rdoc
+一旦処理を中断して、Delayerキューに並び直すためのリクエスト。
+Tools#pass から利用される。
+新たなインスタンスは作らず、 _PASS_ にあるインスタンスを使うこと。
+=end
+  class Pass < Base
+    def accept_request(worker:, deferred:)
+      deferred.enter_pass
+      worker.resume_pass(deferred)
+    end
+  end
+
+  NEXT_WORKER = NextWorker.new(nil).freeze
+  PASS = Pass.new(nil).freeze
+end

data/lib/delayer/deferred/response.rb

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+
+module Delayer::Deferred::Response
+  class Base
+    attr_reader :value
+    def initialize(value)
+      @value = value
+    end
+
+    def ng?
+      !ok?
+    end
+  end
+
+  class Ok < Base
+    def ok?
+      true
+    end
+  end
+
+  class Ng < Base
+    def ok?
+      false
+    end
+  end
+end

data/lib/delayer/deferred/thread.rb

@@ -1,26 +1,40 @@
 # -*- coding: utf-8 -*-
 require "delayer"
-require "delayer/deferred/deferredable"
+require "delayer/deferred/deferredable/awaitable"
 
 class Thread
-  include ::Delayer::Deferred::Deferredable
+  include ::Delayer::Deferred::Deferredable::Awaitable
 
   def self.delayer
     Delayer
   end
 
-  def next(*rest, &block)
-    __gen_promise.next(*rest, &block)
+  # このDeferredが成功した場合の処理を追加する。
+  # 新しいDeferredのインスタンスを返す。
+  # このメソッドはスレッドセーフです。
+  # TODO: procが空のとき例外を発生させる
+  def next(name: caller_locations(1,1).first.to_s, &proc)
+    add_child(Delayer::Deferred::Chain::Next.new(&proc), name: name)
   end
+  alias deferred next
+
+  # このDeferredが失敗した場合の処理を追加する。
+  # 新しいDeferredのインスタンスを返す。
+  # このメソッドはスレッドセーフです。
+  # TODO: procが空のとき例外を発生させる
+  def trap(name: caller_locations(1,1).first.to_s, &proc)
+    add_child(Delayer::Deferred::Chain::Trap.new(&proc), name: name)
+  end
+  alias error trap
 
-  def trap(*rest, &block)
-    __gen_promise.trap(*rest, &block)
+  def add_child(chainable, name: caller_locations(1,1).first.to_s)
+    __gen_promise(name).add_child(chainable)
   end
 
   private
 
-  def __gen_promise
-    promise = delayer.Deferred.new(true)
+  def __gen_promise(name)
+    promise = self.class.delayer.Promise.new(true, name: name)
     Thread.new(self) do |tt|
       __promise_callback(tt, promise)
     end
@@ -28,15 +42,16 @@ class Thread
   end
 
   def __promise_callback(tt, promise)
-    failed = catch(:__deferredable_fail) do
-      begin
-        promise.call(tt.value)
-      rescue Exception => err
+    begin
+      result = tt.value
+      self.class.delayer.new do
+        promise.call(result)
+      end
+    rescue Exception => err
+      self.class.delayer.new do
         promise.fail(err)
       end
-      return
     end
-    promise.fail(failed)
   end
 
 end

data/lib/delayer/deferred/tools.rb

@@ -18,6 +18,12 @@ module Delayer::Deferred
     def fail(value)
       throw(:__deferredable_fail, value) end
 
+    # 実行中のDeferredを、Delayerのタイムリミットが来ている場合に限り一旦中断する。
+    # 長期に渡る可能性のある処理で、必要に応じて他のタスクを先に実行してもよい場合に呼び出す。
+    def pass
+      Fiber.yield(Request::PASS) if delayer.expire?
+    end
+
     # 複数のdeferredを引数に取って、それら全ての実行が終了したら、
     # その結果を引数の順番通りに格納したArrayを引数に呼ばれるDeferredを返す。
     # 引数のDeferredが一つでも失敗するとこのメソッドの返すDeferredも失敗する。
@@ -27,16 +33,20 @@ module Delayer::Deferred
     # Deferred
     def when(*args)
       return self.next{[]} if args.empty?
-      defer, *follow = args
-      raise TypeError, "Argument of Deferred.when must be Delayer::Deferred::Deferredable" unless defer.is_a? Delayer::Deferred::Deferredable
-      if follow.empty?
-        defer.next{|res| [res] }
-      else
-        remain = self.when(*follow)
-        defer.next do |res|
-          remain.next do |follow_res|
-            follow_res.unshift(res) end end end end
-
+      args = args.flatten
+      args.each_with_index{|d, index|
+        unless d.is_a?(Deferredable::Chainable) || d.is_a?(Deferredable::Awaitable)
+          raise TypeError, "Argument #{index} of Deferred.when must be #{Deferredable::Chainable}, but given #{d.class}"
+        end
+        if d.respond_to?(:has_child?) && d.has_child?
+          raise "Already assigned child for argument #{index}"
+        end
+      }
+      defer, *follow = *args
+      defer.next{|res|
+        [res, *follow.map{|d| +d }]
+      }
+    end
     # Kernel#systemを呼び出して、コマンドが成功たら成功するDeferredを返す。
     # 失敗した場合、trap{}ブロックには $? の値(Process::Status)か、例外が発生した場合それが渡される
     # ==== Args

data/lib/delayer/deferred/version.rb

@@ -1,5 +1,5 @@
 module Delayer
   module Deferred
-    VERSION = "1.1.1"
+    VERSION = "2.0.0"
   end
 end

data/lib/delayer/deferred/worker.rb

@@ -0,0 +1,112 @@
+# -*- coding: utf-8 -*-
+require "delayer/deferred/request"
+require "delayer/deferred/response"
+
+module Delayer::Deferred
+=begin rdoc
+Deferredを実行するためのWorker。Deferredチェインを実行するFiberを
+管理する。
+
+== pushに渡すオブジェクトについて
+Worker#push に渡す引数は、activateメソッドを実装している必要がある。
+
+=== activate(response)
+==== Args
+response :: Delayer::Deferred::Response::Base Deferredに渡す値
+==== Returns
+[Delayer::Deferred::Response::Base]
+  これを返すと、値の自動変換が行われないため、意図的に失敗させたり、Deferredを次のブロックに伝搬させることができる。
+[Delayer::Deferred::Chainable]
+  戻り値のDeferredが終わるまでWorkerの処理を停止する。
+  再開された時、結果は戻り値のDeferredの結果に置き換えられる。
+[else]
+  _Delayer::Deferred::Response::Ok.new_ の引数に渡され、その結果が利用される
+=end
+  class Worker
+    def initialize(delayer:, initial:)
+      @delayer, @initial = delayer, initial
+    end
+
+    def push(deferred)
+      deferred.reserve_activate
+      @delayer.new do
+        next if deferred.spoiled?
+        begin
+          fiber.resume(deferred).accept_request(worker: self,
+                                                deferred: deferred)
+        rescue Delayer::Deferred::SequenceError => err
+          err.deferred = deferred
+          raise
+        end
+      end
+      nil
+    end
+
+    # Awaitから復帰した時に呼ばれる。
+    # ==== Args
+    # [response] Awaitの結果(Delayer::Deferred::Response::Base)
+    # [deferred] 現在実行中のDeferred
+    def give_response(response, deferred)
+      @delayer.new do
+        next if deferred.spoiled?
+        deferred.exit_await
+        fiber.resume(response).accept_request(worker: self,
+                                              deferred: deferred)
+      end
+      nil
+    end
+
+    # Tools#pass から復帰した時に呼ばれる。
+    # ==== Args
+    # [deferred] 現在実行中のDeferred
+    def resume_pass(deferred)
+      deferred.exit_pass
+      @delayer.new do
+        next if deferred.spoiled?
+        fiber.resume(nil).accept_request(worker: self,
+                                         deferred: deferred)
+      end
+    end
+
+    private
+
+    def fiber
+      @fiber ||= Fiber.new{|response|
+        loop do
+          response = wait_and_activate(response)
+          case response.value
+          when Delayer::Deferred::SequenceError
+            raise response.value
+          end
+        end
+      }.tap{|f| f.resume(@initial); @initial = nil }
+    end
+
+    def wait_and_activate(argument)
+      response = catch(:success) do
+        failed = catch(:__deferredable_fail) do
+          begin
+            if argument.value.is_a? Deferredable::Awaitable
+              throw :success, +argument.value
+            else
+              defer = Fiber.yield(Request::NEXT_WORKER)
+              res = defer.activate(argument)
+              if res.is_a? Delayer::Deferred::Deferredable::Awaitable
+                defer.add_awaited(res)
+              end
+            end
+            throw :success, res
+          rescue Exception => err
+            throw :__deferredable_fail, err
+          end
+        end
+        Response::Ng.new(failed)
+      end
+      if response.is_a?(Response::Base)
+        response
+      else
+        Response::Ok.new(response)
+      end
+    end
+  end
+end