promise_pool 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ba178cdd8145f5c65340a8599ffc9dbd4775ccef
+  data.tar.gz: a978b9d5072e8038f9cb2e6884432bc9e4f0a6ac
+SHA512:
+  metadata.gz: d531803ba5e8d28b438da3d152e8315ba7ce0de796ee781bcf0f0c2de23f7bf598bed2e9693d548ed05414cd8bd623b34f754588b1cb4ac3ac2bdf4dc898848e
+  data.tar.gz: 406aa62fec4d02adf8eaf0088a0ed8ac7e08a70cf147d01c8ab7d41cbc588541385ff4a1633d18fb3c6e848860a4cb7f9f28c9b8c361f358006071c0954b0257

data/.gitignore

@@ -0,0 +1,2 @@
+/pkg/
+/coverage/

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "task"]
+	path = task
+	url = git://github.com/godfat/gemgem

data/.travis.yml

@@ -0,0 +1,15 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.1
+  - 2.2
+  - 2.3.0
+  - rbx
+  - jruby-9
+
+before_install:
+  - rvm get head
+  - rvm reload
+  - rvm use --install $TRAVIS_RUBY_VERSION --binary --latest
+install: 'bundle install --retry=3'
+script: 'ruby -vr bundler/setup -S rake test'

data/Gemfile

@@ -0,0 +1,15 @@
+
+source 'https://rubygems.org/'
+
+gemspec
+
+gem 'rake'
+gem 'pork'
+gem 'muack'
+
+gem 'simplecov', :require => false if ENV['COV']
+gem 'coveralls', :require => false if ENV['CI']
+
+platforms :rbx do
+  gem 'rubysl-singleton'  # used in rake
+end

data/README.md

@@ -0,0 +1,67 @@
+# promise_pool [![Build Status](https://secure.travis-ci.org/godfat/promise_pool.png?branch=master)](http://travis-ci.org/godfat/promise_pool) [![Coverage Status](https://coveralls.io/repos/godfat/promise_pool/badge.png)](https://coveralls.io/r/godfat/promise_pool) [![Join the chat at https://gitter.im/godfat/promise_pool](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/godfat/promise_pool)
+
+by Lin Jen-Shin ([godfat](http://godfat.org))
+
+## LINKS:
+
+* [github](https://github.com/godfat/promise_pool)
+* [rubygems](https://rubygems.org/gems/promise_pool)
+* [rdoc](http://rdoc.info/projects/godfat/promise_pool)
+
+## DESCRIPTION:
+
+promise_pool
+
+## FEATURES:
+
+* promise_pool
+
+## WHY?
+
+promise_pool
+
+## REQUIREMENTS:
+
+* Tested with MRI (official CRuby), Rubinius and JRuby.
+* gem [timers][]
+
+[timers]: https://github.com/celluloid/timers
+
+## INSTALLATION:
+
+``` shell
+gem install promise_pool
+```
+
+Or if you want development version, put this in Gemfile:
+
+``` ruby
+gem 'promise_pool', :git => 'git://github.com/godfat/promise_pool.git',
+                    :submodules => true
+```
+
+## CHANGES:
+
+* [CHANGES](CHANGES.md)
+
+## CONTRIBUTORS:
+
+* Lin Jen-Shin (@godfat)
+
+## LICENSE:
+
+Apache License 2.0
+
+Copyright (c) 2016, Lin Jen-Shin (godfat)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   <http://www.apache.org/licenses/LICENSE-2.0>
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/Rakefile

@@ -0,0 +1,14 @@
+
+begin
+  require "#{dir = File.dirname(__FILE__)}/task/gemgem"
+rescue LoadError
+  sh 'git submodule update --init'
+  exec Gem.ruby, '-S', $PROGRAM_NAME, *ARGV
+end
+
+Gemgem.init(dir) do |s|
+  require 'promise_pool/version'
+  s.name    = 'promise_pool'
+  s.version = PromisePool::VERSION
+  s.add_runtime_dependency('timers', '>=4.0.1')
+end

data/lib/promise_pool.rb

@@ -0,0 +1,5 @@
+
+require 'promise_pool/promise'
+require 'promise_pool/promise_eager'
+require 'promise_pool/thread_pool'
+require 'promise_pool/timer'

data/lib/promise_pool/future.rb

@@ -0,0 +1,12 @@
+
+module PromisePool
+  class Future < BasicObject
+    def initialize promise
+      @promise = promise
+    end
+
+    def method_missing msg, *args, &block
+      @promise.yield.__send__(msg, *args, &block)
+    end
+  end
+end

data/lib/promise_pool/promise.rb

@@ -0,0 +1,163 @@
+
+require 'thread'
+require 'promise_pool/future'
+
+module PromisePool
+  class Promise
+    def self.claim value
+      promise = new
+      promise.fulfill(value)
+      promise
+    end
+
+    def self.backtrace
+      Thread.current[:promise_pool_backtrace] || []
+    end
+
+    # should never raise!
+    def self.set_backtrace e
+      e.set_backtrace((e.backtrace || caller) + backtrace)
+    end
+
+    def initialize timer=nil
+      self.value = self.error = self.result = nil
+      self.resolved = self.called = false
+
+      self.k     = []
+      self.timer = timer
+      self.condv = ConditionVariable.new
+      self.mutex = Mutex.new
+    end
+
+    # called in client thread
+    def defer pool=nil
+      backtrace = caller + self.class.backtrace # retain the backtrace so far
+      if pool
+        mutex.synchronize do
+          # still timing it out if the task never processed
+          timer.on_timeout{ cancel_task } if timer
+          self.task = pool.defer(mutex) do
+            Thread.current[:promise_pool_backtrace] = backtrace
+            protected_yield{ yield }
+            Thread.current[:promise_pool_backtrace] = nil
+          end
+        end
+      else
+        self.thread = Thread.new do
+          Thread.current[:promise_pool_backtrace] = backtrace
+          protected_yield{ yield }
+        end
+      end
+      self
+    end
+
+    def call
+      self.thread = Thread.current # set working thread
+      protected_yield{ yield } # avoid any exception and do the job
+    end
+
+    def future
+      Future.new(self)
+    end
+
+    # called in client thread (client.wait)
+    def wait
+      # it might be awaken by some other futures!
+      mutex.synchronize{ condv.wait(mutex) until resolved? } unless resolved?
+    end
+
+    # called in client thread (from the future (e.g. body))
+    def yield
+      wait
+      mutex.synchronize{ callback }
+    end
+
+    # called in requesting thread after the request is done
+    def fulfill value
+      mutex.synchronize{ fulfilling(value) }
+    end
+
+    # called in requesting thread if something goes wrong or timed out
+    def reject error
+      mutex.synchronize{ rejecting(error) }
+    end
+
+    # append your actions, which would be called when we're calling back
+    def then &action
+      k << action
+      self
+    end
+
+    def resolved?
+      resolved
+    end
+
+    protected
+    attr_accessor :value, :error, :result, :resolved, :called,
+                  :k, :timer, :condv, :mutex, :task, :thread
+
+    private
+    def fulfilling value
+      self.value = value
+      resolve
+    end
+
+    def rejecting error
+      self.error = error
+      resolve
+    end
+
+    def resolve
+      self.resolved = true
+      yield if block_given?
+    ensure
+      condv.broadcast # client or response might be waiting
+    end
+
+    # called in a new thread if pool_size == 0, otherwise from the pool
+    # i.e. requesting thread
+    def protected_yield
+      value = if timer
+                timeout_protected_yield{ yield }
+              else
+                yield
+              end
+      fulfill(value)
+    rescue Exception => err
+      self.class.set_backtrace(err)
+      reject(err)
+    end
+
+    def timeout_protected_yield
+      # timeout might already be set for thread_pool (pool_size > 0)
+      timer.on_timeout{ cancel_task } unless timer
+      yield
+    ensure
+      timer.cancel
+    end
+
+    # called in client thread, when yield is called
+    def callback
+      return result if called
+      self.result = k.inject(error || value){ |r, i| i.call(r) }
+    ensure
+      self.called = true
+    end
+
+    # timeout!
+    def cancel_task
+      mutex.synchronize do
+        if resolved?
+          # do nothing if it's already done
+        elsif t = thread || task.thread
+          t.raise(timer.error) # raise Timeout::Error to working thread
+        else
+          # task was queued and never started, just cancel it and
+          # fulfill the promise with Timeout::Error
+          task.cancel
+          rejecting(timer.error)
+        end
+      end
+    end
+  end
+end

data/lib/promise_pool/promise_eager.rb

@@ -0,0 +1,36 @@
+
+require 'promise_pool/promise'
+
+module PromisePool
+  class PromiseEager < Promise
+    attr_accessor :error_callback
+
+    def initialize timer=nil, &error_callback
+      super(timer)
+      self.error_callback = error_callback
+    end
+
+    def resolved?
+      super && called
+    end
+
+    private
+    def resolve
+      super{ callback } # under ASYNC callback, should call immediately
+    rescue Exception => err
+      self.class.set_backtrace(err)
+      call_error_callback(err)
+    end
+
+    # log user callback error, should never raise
+    def call_error_callback err
+      if error_callback
+        error_callback.call(err)
+      else
+        warn "#{self.class}: ERROR: #{err}\n  from #{err.backtrace.inspect}"
+      end
+    rescue Exception => e
+      Thread.main.raise(e) if !!$DEBUG
+    end
+  end
+end

data/lib/promise_pool/queue.rb

@@ -0,0 +1,36 @@
+
+require 'thread'
+
+module PromisePool
+  class Queue
+    def initialize
+      @queue = []
+      @condv = ConditionVariable.new
+    end
+
+    def size
+      @queue.size
+    end
+
+    def << task
+      queue << task
+      condv.signal
+    end
+
+    def pop mutex, timeout=60
+      if queue.empty?
+        condv.wait(mutex, timeout)
+        queue.shift || lambda{ |_| false } # shutdown idle workers
+      else
+        queue.shift
+      end
+    end
+
+    def clear
+      queue.clear
+    end
+
+    protected
+    attr_reader :queue, :condv
+  end
+end

data/lib/promise_pool/task.rb

@@ -0,0 +1,18 @@
+
+module PromisePool
+  class Task < Struct.new(:job, :mutex, :thread, :cancelled)
+    # this should never fail
+    def call working_thread
+      mutex.synchronize do
+        return if cancelled
+        self.thread = working_thread
+      end
+      job.call
+      true
+    end
+
+    def cancel
+      self.cancelled = true
+    end
+  end
+end

data/lib/promise_pool/test.rb

@@ -0,0 +1,7 @@
+
+require 'promise_pool'
+require 'pork/auto'
+require 'muack'
+
+Pork::Executor.include(Muack::API)
+include PromisePool

data/lib/promise_pool/thread_pool.rb

@@ -0,0 +1,70 @@
+
+# reference implementation: puma
+# https://github.com/puma/puma/blob/v2.7.1/lib/puma/thread_pool.rb
+
+require 'thread'
+require 'promise_pool/queue'
+require 'promise_pool/task'
+
+module PromisePool
+  class ThreadPool
+    attr_reader :workers
+    attr_accessor :idle_time, :max_size
+
+    def initialize max_size, idle_time=60
+      @max_size  = max_size
+      @idle_time = idle_time
+      @queue     = Queue.new
+      @mutex     = Mutex.new
+      @workers   = []
+      @waiting   = 0
+    end
+
+    def size
+      workers.size
+    end
+
+    def defer promise_mutex, &job
+      mutex.synchronize do
+        task = Task.new(job, promise_mutex)
+        queue << task
+        spawn_worker if waiting < queue.size && workers.size < max_size
+        task
+      end
+    end
+
+    def trim force=false
+      mutex.synchronize do
+        queue << lambda{ |_| false } if force || waiting > 0
+      end
+    end
+
+    # Block on shutting down, and should not add more jobs while shutting down
+    def shutdown
+      workers.size.times{ trim(true) }
+      workers.first.join && trim(true) until workers.empty?
+      mutex.synchronize{ queue.clear }
+    end
+
+    protected
+    attr_reader :queue, :mutex, :condv, :waiting
+
+    private
+    def spawn_worker
+      workers << Thread.new{
+        Thread.current.abort_on_exception = true
+
+        task = nil
+        begin
+          mutex.synchronize do
+            @waiting += 1
+            task = queue.pop(mutex, idle_time)
+            @waiting -= 1
+          end
+        end while task.call(Thread.current)
+
+        mutex.synchronize{ workers.delete(Thread.current) }
+      }
+    end
+  end
+end

data/lib/promise_pool/timer.rb

@@ -0,0 +1,60 @@
+
+require 'thread'
+require 'timers'
+
+module PromisePool
+  class Timer
+    @mutex = Mutex.new
+    @interval = 1
+
+    singleton_class.module_eval do
+      attr_accessor :interval
+
+      def group
+        @group ||= @mutex.synchronize{ @group ||= group_new }
+      end
+
+      private
+      def group_new
+        g = Timers::Group.new
+        g.every(interval){}
+        @thread = Thread.new do
+          begin
+            g.wait
+          rescue => e
+            warn "#{self.class}: ERROR: #{e}\n  from #{e.backtrace.inspect}"
+          end while g.count > 1
+          @group = nil
+        end
+        g
+      end
+    end
+
+    attr_accessor :timeout, :error, :timer
+    def initialize timeout, error, &block
+      self.timeout = timeout
+      self.error   = error
+      self.block   = block
+      start if block_given?
+    end
+
+    def on_timeout &block
+      self.block = block
+      start if block_given?
+    end
+
+    # should never raise!
+    def cancel
+      timer.cancel if timer
+      self.block = nil
+    end
+
+    def start
+      return if timeout.nil? || timeout.zero?
+      self.timer = self.class.group.after(timeout){ block.call if block }
+    end
+
+    protected
+    attr_accessor :block
+  end
+end

data/lib/promise_pool/version.rb

@@ -0,0 +1,4 @@
+
+module PromisePool
+  VERSION = '0.1.0'
+end

data/promise_pool.gemspec

@@ -0,0 +1,59 @@
+# -*- encoding: utf-8 -*-
+# stub: promise_pool 0.1.0 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "promise_pool"
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib"]
+  s.authors = ["Lin Jen-Shin (godfat)"]
+  s.date = "2016-01-21"
+  s.description = "promise_pool"
+  s.email = ["godfat (XD) godfat.org"]
+  s.files = [
+  ".gitignore",
+  ".gitmodules",
+  ".travis.yml",
+  "Gemfile",
+  "README.md",
+  "Rakefile",
+  "lib/promise_pool.rb",
+  "lib/promise_pool/future.rb",
+  "lib/promise_pool/promise.rb",
+  "lib/promise_pool/promise_eager.rb",
+  "lib/promise_pool/queue.rb",
+  "lib/promise_pool/task.rb",
+  "lib/promise_pool/test.rb",
+  "lib/promise_pool/thread_pool.rb",
+  "lib/promise_pool/timer.rb",
+  "lib/promise_pool/version.rb",
+  "promise_pool.gemspec",
+  "task/README.md",
+  "task/gemgem.rb",
+  "test/test_pool.rb",
+  "test/test_promise.rb",
+  "test/test_promise_eager.rb",
+  "test/test_timer.rb"]
+  s.homepage = "https://github.com/godfat/promise_pool"
+  s.licenses = ["Apache License 2.0"]
+  s.rubygems_version = "2.5.1"
+  s.summary = "promise_pool"
+  s.test_files = [
+  "test/test_pool.rb",
+  "test/test_promise.rb",
+  "test/test_promise_eager.rb",
+  "test/test_timer.rb"]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<timers>, [">= 4.0.1"])
+    else
+      s.add_dependency(%q<timers>, [">= 4.0.1"])
+    end
+  else
+    s.add_dependency(%q<timers>, [">= 4.0.1"])
+  end
+end

data/task/README.md

@@ -0,0 +1,54 @@
+# Gemgem
+
+## DESCRIPTION:
+
+Provided tasks:
+
+    rake clean        # Remove ignored files
+    rake gem:build    # Build gem
+    rake gem:install  # Install gem
+    rake gem:release  # Release gem
+    rake gem:spec     # Generate gemspec
+    rake test         # Run tests in memory
+
+## REQUIREMENTS:
+
+* Tested with MRI (official CRuby) 1.9.3, 2.0.0, Rubinius and JRuby.
+
+## INSTALLATION:
+
+    git submodule add git://github.com/godfat/gemgem.git task
+
+And in Rakefile:
+
+``` ruby
+begin
+  require "#{dir = File.dirname(__FILE__)}/task/gemgem"
+rescue LoadError
+  sh 'git submodule update --init'
+  exec Gem.ruby, '-S', $PROGRAM_NAME, *ARGV
+end
+
+Gemgem.init(dir) do |s|
+  s.name    = 'your-gem'
+  s.version = '0.1.0'
+end
+```
+
+## LICENSE:
+
+Apache License 2.0
+
+Copyright (c) 2011-2013, Lin Jen-Shin (godfat)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+<http://www.apache.org/licenses/LICENSE-2.0>
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/task/gemgem.rb

@@ -0,0 +1,316 @@
+
+module Gemgem
+  class << self
+    attr_accessor :dir, :spec, :spec_create
+  end
+
+  module_function
+  def gem_tag    ; "#{spec.name}-#{spec.version}"     ; end
+  def gem_path   ; "#{pkg_dir}/#{gem_tag}.gem"        ; end
+  def spec_path  ; "#{dir}/#{spec.name}.gemspec"      ; end
+  def pkg_dir    ; "#{dir}/pkg"                       ; end
+  def escaped_dir; @escaped_dir ||= Regexp.escape(dir); end
+
+  def init dir, &block
+    self.dir = dir
+    $LOAD_PATH.unshift("#{dir}/lib")
+    ENV['RUBYLIB'] = "#{dir}/lib:#{ENV['RUBYLIB']}"
+    ENV['PATH']    = "#{dir}/bin:#{ENV['PATH']}"
+    self.spec_create = block
+  end
+
+  def create
+    spec = Gem::Specification.new do |s|
+      s.authors     = ['Lin Jen-Shin (godfat)']
+      s.email       = ['godfat (XD) godfat.org']
+
+      s.description = description.join
+      s.summary     = description.first
+      s.license     = readme['LICENSE'].sub(/.+\n\n/, '').lines.first.strip
+
+      s.date        = Time.now.strftime('%Y-%m-%d')
+      s.files       = gem_files
+      s.test_files  = test_files
+      s.executables = bin_files
+    end
+    spec_create.call(spec)
+    spec.homepage ||= "https://github.com/godfat/#{spec.name}"
+    self.spec = spec
+  end
+
+  def gem_install
+    require 'rubygems/commands/install_command'
+    # read ~/.gemrc
+    Gem.use_paths(Gem.configuration[:gemhome], Gem.configuration[:gempath])
+    Gem::Command.extra_args = Gem.configuration[:gem]
+
+    # setup install options
+    cmd = Gem::Commands::InstallCommand.new
+    cmd.handle_options([])
+
+    # install
+    install = Gem::Installer.new(gem_path, cmd.options)
+    install.install
+    puts "\e[35mGem installed: \e[33m#{strip_path(install.gem_dir)}\e[0m"
+  end
+
+  def gem_spec
+    create
+    write
+  end
+
+  def gem_build
+    require 'fileutils'
+    require 'rubygems/package'
+    gem = nil
+    Dir.chdir(dir) do
+      gem = Gem::Package.build(Gem::Specification.load(spec_path))
+      FileUtils.mkdir_p(pkg_dir)
+      FileUtils.mv(gem, pkg_dir) # gem is relative path, but might be ok
+    end
+    puts "\e[35mGem built: \e[33m#{strip_path("#{pkg_dir}/#{gem}")}\e[0m"
+  end
+
+  def gem_release
+    sh_git('tag', gem_tag)
+    sh_git('push')
+    sh_git('push', '--tags')
+    sh_gem('push', gem_path)
+  end
+
+  def gem_check
+    unless git('status', '--porcelain').empty?
+      puts("\e[35mWorking copy is not clean.\e[0m")
+      exit(3)
+    end
+
+    ver = spec.version.to_s
+
+    if ENV['VERSION'].nil?
+      puts("\e[35mExpected "                                  \
+           "\e[33mVERSION\e[35m=\e[33m#{ver}\e[0m")
+      exit(1)
+
+    elsif ENV['VERSION'] != ver
+      puts("\e[35mExpected \e[33mVERSION\e[35m=\e[33m#{ver} " \
+           "\e[35mbut got\n         "                         \
+           "\e[33mVERSION\e[35m=\e[33m#{ENV['VERSION']}\e[0m")
+      exit(2)
+    end
+  end
+
+  def test
+    return if test_files.empty?
+
+    if ENV['COV'] || ENV['CI']
+      require 'simplecov'
+      if ENV['CI']
+        begin
+          require 'coveralls'
+          SimpleCov.formatter = Coveralls::SimpleCov::Formatter
+        rescue LoadError => e
+          puts "Cannot load coveralls, skip: #{e}"
+        end
+      end
+      SimpleCov.start do
+        add_filter('test/')
+        add_filter('test.rb')
+      end
+    end
+
+    test_files.each{ |file| require "#{dir}/#{file[0..-4]}" }
+  end
+
+  def clean
+    return if ignored_files.empty?
+
+    require 'fileutils'
+    trash = File.expand_path("~/.Trash/#{spec.name}")
+    puts "Move the following files into: \e[35m#{strip_path(trash)}\e[33m"
+
+    ignored_files.each do |file|
+      from = "#{dir}/#{file}"
+      to   = "#{trash}/#{File.dirname(file)}"
+      puts strip_path(from)
+
+      FileUtils.mkdir_p(to)
+      FileUtils.mv(from, to)
+    end
+
+    print "\e[0m"
+  end
+
+  def write
+    File.open(spec_path, 'w'){ |f| f << split_lines(spec.to_ruby) }
+  end
+
+  def split_lines ruby
+    ruby.gsub(/(.+?)\s*=\s*\[(.+?)\]/){ |s|
+      if $2.index(',')
+        "#{$1} = [\n  #{$2.split(',').map(&:strip).join(",\n  ")}]"
+      else
+        s
+      end
+    }
+  end
+
+  def strip_path path
+    strip_home_path(strip_cwd_path(path))
+  end
+
+  def strip_home_path path
+    path.sub(ENV['HOME'], '~')
+  end
+
+  def strip_cwd_path path
+    path.sub(Dir.pwd, '.')
+  end
+
+  def git *args
+    `git --git-dir=#{dir}/.git #{args.join(' ')}`
+  end
+
+  def sh_git *args
+    Rake.sh('git', "--git-dir=#{dir}/.git", *args)
+  end
+
+  def sh_gem *args
+    Rake.sh(Gem.ruby, '-S', 'gem', *args)
+  end
+
+  def glob path=dir
+    Dir.glob("#{path}/**/*", File::FNM_DOTMATCH)
+  end
+
+  def readme
+    @readme ||=
+      if (path = "#{Gemgem.dir}/README.md") && File.exist?(path)
+        ps = "##{File.read(path)}".
+             scan(/((#+)[^\n]+\n\n.+?(?=(\n\n\2[^#\n]+\n)|\Z))/m).map(&:first)
+        ps.inject('HEADER' => ps.first){ |r, s, i|
+          r[s[/\w+/]] = s
+          r
+        }
+      else
+        {}
+      end
+  end
+
+  def description
+    # JRuby String#lines is returning an enumerator
+    @description ||= (readme['DESCRIPTION']||'').sub(/.+\n\n/, '').lines.to_a
+  end
+
+  def all_files
+    @all_files ||= fold_files(glob).sort
+  end
+
+  def fold_files files
+    files.inject([]){ |r, path|
+      if File.file?(path) && path !~ %r{/\.git(/|$)}  &&
+         (rpath = path[%r{^#{escaped_dir}/(.*$)}, 1])
+        r << rpath
+      elsif File.symlink?(path) # walk into symlinks...
+        r.concat(fold_files(glob(File.expand_path(path,
+                                                  File.readlink(path)))))
+      else
+        r
+      end
+    }
+  end
+
+  def gem_files
+    @gem_files ||= all_files.reject{ |f|
+      f =~ ignored_pattern && !git_files.include?(f)
+    }
+  end
+
+  def test_files
+    @test_files ||= gem_files.grep(%r{^test/(.+?/)*test_.+?\.rb$})
+  end
+
+  def bin_files
+    @bin_files ||= gem_files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  end
+
+  def git_files
+    @git_files ||= if File.exist?("#{dir}/.git")
+                     git('ls-files').split("\n")
+                   else
+                     []
+                   end
+  end
+
+  def ignored_files
+    @ignored_files ||= all_files.grep(ignored_pattern)
+  end
+
+  def ignored_pattern
+    @ignored_pattern ||= if gitignore.empty?
+                           /^$/
+                         else
+                           Regexp.new(expand_patterns(gitignore).join('|'))
+                         end
+  end
+
+  def expand_patterns pathes
+    # http://git-scm.com/docs/gitignore
+    pathes.flat_map{ |path|
+      # we didn't implement negative pattern for now
+      Regexp.escape(path).sub(%r{^/}, '^').gsub(/\\\*/, '[^/]*')
+    }
+  end
+
+  def gitignore
+    @gitignore ||= if File.exist?(path = "#{dir}/.gitignore")
+                     File.read(path).lines.
+                       reject{ |l| l == /^\s*(#|\s+$)/ }.map(&:strip)
+                   else
+                     []
+                   end
+  end
+end
+
+namespace :gem do
+
+desc 'Install gem'
+task :install => [:build] do
+  Gemgem.gem_install
+end
+
+desc 'Build gem'
+task :build => [:spec] do
+  Gemgem.gem_build
+end
+
+desc 'Generate gemspec'
+task :spec do
+  Gemgem.gem_spec
+end
+
+desc 'Release gem'
+task :release => [:spec, :check, :build] do
+  Gemgem.gem_release
+end
+
+task :check do
+  Gemgem.gem_check
+end
+
+end # of gem namespace
+
+desc 'Run tests'
+task :test do
+  Gemgem.test
+end
+
+desc 'Trash ignored files'
+task :clean => ['gem:spec'] do
+  Gemgem.clean
+end
+
+task :default do
+  # Is there a reliable way to do this in the current process?
+  # It failed miserably before between Rake versions...
+  exec "#{Gem.ruby} -S #{$PROGRAM_NAME} -f #{Rake.application.rakefile} -T"
+end

data/test/test_pool.rb

@@ -0,0 +1,74 @@
+
+require 'promise_pool/test'
+
+describe PromisePool::ThreadPool do
+  before do
+    @pool = ThreadPool.new(3)
+    @promise = Promise.new
+  end
+
+  after do
+    @pool.shutdown
+    @pool.size.should.eq 0
+  end
+
+  would 'work, reject, yield' do
+    @pool.max_size = 1
+    flag = 0
+    @promise.defer(@pool) do
+      flag.should.eq 0
+      flag += 1
+      raise 'boom'
+    end.yield
+    flag.should.eq 1
+    @promise.send(:error).message.should.eq 'boom'
+  end
+
+  would 'work, fulfill, yield' do
+    value = 'body'
+    @pool.max_size = 2
+    flag = 0
+    @promise.defer(@pool) do
+      flag.should.eq 0
+      flag += 1
+      value
+    end
+    @promise.future.should.eq value
+    @promise.send(:value).should.eq value
+    @promise.send(:result).should.eq value
+    @promise.should.resolved?
+    flag.should.eq 1
+  end
+
+  would 'work, check body', :groups => [:only] do
+    flag = 0
+    result = @promise.defer(@pool) do
+      flag.should.eq 0
+      flag += 1
+    end.future
+    result.should.eq 1
+    flag.should.eq 1
+  end
+
+  would 'call in thread pool if pool_size > 0' do
+    @pool.max_size = 1
+    flag = 0
+    rd, wr = IO.pipe
+    @promise.defer(@pool) do
+      rd.gets
+      flag.should.eq 0
+      flag += 1
+      raise 'nnf'
+    end
+    p1 = Promise.new
+    p1.defer(@pool) do # block until promise #0 is done because max_size == 1
+      flag.should.eq 1
+      flag += 1
+      raise 'boom'
+    end
+    wr.puts  # start promise #0
+    @promise.yield
+    p1.yield # block until promise #1 is done
+    flag.should.eq 2
+  end
+end

data/test/test_promise.rb

@@ -0,0 +1,34 @@
+
+require 'promise_pool/test'
+
+describe PromisePool::Promise do
+  would 'claim' do
+    value = 'body'
+    Promise.claim(value).future.should.eq value
+  end
+
+  would 'then then then' do
+    plusone = lambda{ |r| r + 1 }
+    promise = Promise.new
+    2.times{ promise.then(&plusone).then(&plusone).then(&plusone) }
+    promise.fulfill(0)
+    promise.future.should.eq 6
+  end
+
+  after do
+    Muack.verify
+  end
+
+  would 'call in a new thread if no pool' do
+    thread = nil
+    rd, wr = IO.pipe
+    mock(Thread).new.with_any_args.peek_return do |t|
+      thread = t
+      wr.puts
+    end
+    Promise.new.defer do
+      rd.gets
+      Thread.current.should.eq thread
+    end.yield
+  end
+end

data/test/test_promise_eager.rb

@@ -0,0 +1,41 @@
+
+require 'promise_pool/test'
+
+describe PromisePool::PromiseEager do
+  would 'call error_callback on errors' do
+    errors = []
+    promise = PromiseEager.new(&errors.method(:<<))
+
+    promise.then do |err|
+      err.message.should.eq 'boom'
+      raise 'nnf'
+    end
+
+    promise.defer do
+      raise 'boom'
+    end.wait
+
+    errors.map(&:message).should.eq ['nnf']
+  end
+
+  after do
+    Muack.verify
+  end
+
+  would 'warn if there is no error_callback' do
+    promise = PromiseEager.new
+
+    mock(promise).warn(is_a(String)) do |msg|
+      msg.should.start_with?("PromisePool::PromiseEager: ERROR: nnf\n")
+    end
+
+    promise.then do |value|
+      value.should.eq 'value'
+      raise 'nnf'
+    end
+
+    promise.defer do
+      'value'
+    end.wait
+  end
+end

data/test/test_timer.rb

@@ -0,0 +1,5 @@
+
+require 'promise_pool/test'
+
+describe PromisePool::Timer do
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: promise_pool
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Lin Jen-Shin (godfat)
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-01-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: timers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.1
+description: promise_pool
+email:
+- godfat (XD) godfat.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".gitmodules"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- lib/promise_pool.rb
+- lib/promise_pool/future.rb
+- lib/promise_pool/promise.rb
+- lib/promise_pool/promise_eager.rb
+- lib/promise_pool/queue.rb
+- lib/promise_pool/task.rb
+- lib/promise_pool/test.rb
+- lib/promise_pool/thread_pool.rb
+- lib/promise_pool/timer.rb
+- lib/promise_pool/version.rb
+- promise_pool.gemspec
+- task/README.md
+- task/gemgem.rb
+- test/test_pool.rb
+- test/test_promise.rb
+- test/test_promise_eager.rb
+- test/test_timer.rb
+homepage: https://github.com/godfat/promise_pool
+licenses:
+- Apache License 2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: promise_pool
+test_files:
+- test/test_pool.rb
+- test/test_promise.rb
+- test/test_promise_eager.rb
+- test/test_timer.rb