thread-task 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 716712aca5f16f5f7cce6e2dd080b2bc8977ab6b52cc1a450ff26daa03490e75
+  data.tar.gz: 5426b3d682dcba73903471e2920cc37758dd76a6526a2f32c579a6907075d1a0
+SHA512:
+  metadata.gz: e120a53671fea648459b54cb97616291515c7bdd27ceb9849e2010ba5e5f4da6f48d81cf922f45d25d9db0b7d619c83cd33ad92366216da2437d697fe2926ba2
+  data.tar.gz: 666026187d04520ef1a388db270a912e4a6b49f341549a719c1e4aa94a10960c68908c317879f0c158018355fa333558a92ed09e939348c69f3077f65c25ecaa

data/.gitignore

@@ -0,0 +1,22 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/.rspec_status
+/vendor/
+/var/
+/log/
+/Gemfile.*
+*.bundle
+*.so
+*.o
+*.a
+*.pid
+*.swp
+*.log
+*.log.*
+

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,73 @@
+
+AllCops:
+  Exclude:
+    - '.*'
+    - '*'
+    - '*.gemspec'
+    - 'Gemfile*'
+    - 'bin/**'
+    - 'exe/**'
+    - 'config/**/*'
+    - 'spec/**/*'
+    - 'tmp/**/*'
+    - 'vendor/**/*'
+  TargetRubyVersion: 2.7
+
+Layout/ExtraSpacing:
+  Enabled: false
+
+Layout/SpaceAroundOperators:
+  Enabled: false
+
+Layout/SpaceBeforeFirstArg:
+  Enabled: false
+
+Layout/SpaceInsideParens:
+  Enabled: false
+
+Layout/SpaceInsideArrayLiteralBrackets:
+  Enabled: false
+ 
+Layout/SpaceInsideRangeLiteral:
+  Enabled: false
+
+Layout/SpaceInsideReferenceBrackets:
+  Enabled: false
+
+Layout/SpaceInsideStringInterpolation:
+  Enabled: false
+
+Lint/AmbiguousBlockAssociation:
+  Enabled: false
+
+Lint/EmptyWhen:
+  Enabled: false
+
+Lint/ReturnInVoidContext:
+  Enabled: false
+
+Lint/UselessAssignment:
+  Enabled: false
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/LineLength:
+  Enabled: false
+  Max: 120
+
+Metrics/MethodLength:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: true
+
+Style/FrozenStringLiteralComment:
+  Enabled: false
+
+Style/NumericPredicate:
+  Enabled: false
+
+Style/StringLiterals:
+  Enabled: false
+

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in thread-task.gemspec
+gemspec

data/README.adoc

@@ -0,0 +1,224 @@
+= Thread::Task
+
+A wrapper library of Thread class for easily describing parallel processing.
+
+== Features
+
+* Thread::Task is a configuration that allows you to briefly describe the configuration often used in parallel processing.
+* Thread::Task::Pool limits the number of parallel executions of Thread::Task.
+* Runs only once within the specified timelimit.
+
+== Installation
+
+Add this line to your application's Gemfile:
+
+[source,ruby]
+----
+gem 'thread-task'
+----
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install thread-task
+    or
+    $ gem install -l thread-task-x.x.x.gem
+
+== Usage
+
+::Thread::Task has alias ::Task.
+
+=== Start parallel execution, wait for completion and get result.
+
+[source,ruby]
+----
+require  "thread/task"
+
+task  =  Task.new do
+  sleep  2
+  Time.now
+end
+p task.value
+----
+
+=== Limit the max count of parallel executions.
+
+[source,ruby]
+----
+require  "thread/task"
+
+tasks  =  (0...10).map do |i|
+  p [i]
+  Task.new( i, count: 3 ) do |j|
+    p [" ->", j]
+    sleep( rand * 2 )
+    p ["<- ", j]
+  end
+end
+
+tasks.each(&:join)
+----
+
+=== Limit the max count of parallel executions with a Task::Pool.
+
+[source,ruby]
+----
+require  "thread/task"
+
+pool  =  Task::Pool.new(3)
+
+tasks1  =  (0...4).map do |i|
+  p [i]
+  Task.new( i, pool: pool ) do |j|
+    p [" ->", j]
+    sleep( rand * 2 )
+    p ["<- ", j]
+  end
+end
+tasks2  =  (4...8).map do |i|
+  p [i]
+  Task.new( i, pool: pool ) do |j|
+    p [" ->", j]
+    sleep( rand * 2 )
+    p ["<- ", j]
+  end
+end
+
+tasks1.each(&:join)
+tasks2.each(&:join)
+----
+
+=== Invoke the block only once at the beginning, and ignoring recalls within the time limit.
+
+[source,ruby]
+----
+require "thread/task"
+
+tasks = (1..10).map do |i|
+  sleep  0.1
+  Task.once( i, guard:3 ) do |j|
+    p j
+  end
+end
+
+tasks.each(&:join)
+----
+
+=== When there is no recall within the time limit, invoke the block only once at the end.
+
+[source,ruby]
+----
+require "thread/task"
+
+tasks = (1..10).map do |i|
+  sleep  0.1
+  Task.once( i, delay:3 ) do |j|
+    p j
+  end
+end
+
+tasks.each(&:join)
+----
+
+== Reference
+
+=== Create a new Thread::Task.
+
+[source,ruby]
+----
+Thread::Task.new( *args, pool: nil, count: nil, &block )
+----
+
+* Result:
+  ** Thread::Task object.
+
+* Parameter:
+  ** args: Pass args as is to the block.
+  ** pool: Thread::Task::Pool object. (default: nil)
+  ** count: Max count of parallel executions. (default: nil)
+  ** block: callback action.
+
+* Block Parameter:
+  ** args: Treat args as local variables specific to that thread.
+
+=== Wait for thread stop. Ignore thread exceptions.
+
+[source,ruby]
+----
+Thread::Task#join
+----
+
+* Result:
+  ** nil
+
+* Parameter:
+  ** none.
+
+=== Wait for the thread to stop and get the result. Detect the thread exception.
+
+[source,ruby]
+----
+Thread::Task#value
+----
+
+* Result:
+  ** The execution result of the block.
+
+* Parameter:
+  ** none.
+
+=== Cancel the execution of the thread.
+
+[source,ruby]
+----
+Thread::Task#cancel
+----
+
+* Result:
+  ** nil.
+
+* Parameter:
+  ** none.
+
+=== Create a new Thread::Pool.
+
+[source,ruby]
+----
+Thread::Task.once( *args, delay: nil, guard: nil, &block )
+----
+
+* Result:
+  ** Thread::Task object.
+
+* Parameter:
+  ** args: Pass args as is to the block.
+  ** delay: Wait for delay second before call block. (default: nil)
+  ** guard: Wait for guard second after call block. (default: nil)
+  ** ident: Task identifier. (default: nil )
+  ** block: callback action.
+
+=== Create a new Thread::Pool.
+
+[source,ruby]
+----
+Thread::Pool.new( count )
+----
+
+* Result:
+  ** Thread::Pool object.
+
+* Parameter:
+  ** count: Max count of parallel executions.
+
+== Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/yorihara/thread-task.
+
+== License
+
+The gem is available as open source under the terms of the http://opensource.org/licenses/MIT[MIT License].
+
+Copyright (c) yorihara <orihara.yasumi@gmail.com>

data/README.ja.adoc

@@ -0,0 +1,224 @@
+= Thread::Task
+
+並列処理を簡単に記述するための Thread クラスのラッパーライブラリ.
+
+== 特徴
+
+* Thread::Task は並列処理でよく使う構成を簡潔に記述できるようにしたもの.
+* Thread::Task::Pool は Thread::Task の並列実行数を制限する.
+* 指定された制限時間内に一度だけ実行する.
+
+== 導入
+
+アプリの Gemfile にこの行を追加
+
+[source,ruby]
+----
+gem 'thread-task'
+----
+
+それから実行
+
+    $ bundle install
+
+または次のように手動で導入
+
+    $ gem install thread-task
+    or
+    $ gem install -l thread-task-x.x.x.gem
+
+== 使い方
+
+::Thread::Task は ::Task の別名をもつ.
+
+=== 並列実行を開始して完了を待って結果を得る.
+
+[source,ruby]
+----
+require  "thread/task"
+
+task  =  Task.new do
+  sleep  2
+  Time.now
+end
+p task.value
+----
+
+=== 並列実行の最大数を制限する.
+
+[source,ruby]
+----
+require  "thread/task"
+
+tasks  =  (0...10).map do |i|
+  p [i]
+  Task.new( i, count: 3 ) do |j|
+    p [" ->", j]
+    sleep( rand * 2 )
+    p ["<- ", j]
+  end
+end
+
+tasks.each(&:join)
+----
+
+=== ひとつのプールで並列実行の最大数を制限する.
+
+[source,ruby]
+----
+require  "thread/task"
+
+pool  =  Task::Pool.new(3)
+
+tasks1  =  (0...4).map do |i|
+  p [i]
+  Task.new( i, pool: pool ) do |j|
+    p [" ->", j]
+    sleep( rand * 2 )
+    p ["<- ", j]
+  end
+end
+tasks2  =  (4...8).map do |i|
+  p [i]
+  Task.new( i, pool: pool ) do |j|
+    p [" ->", j]
+    sleep( rand * 2 )
+    p ["<- ", j]
+  end
+end
+
+tasks1.each(&:join)
+tasks2.each(&:join)
+----
+
+=== 最初に一度だけブロックを呼び出して、制限時間内の再呼び出しは無視する.
+
+[source,ruby]
+----
+require "thread/task"
+
+tasks = (1..10).map do |i|
+  sleep  0.1
+  Task.once( i, guard:3 ) do |j|
+    p j
+  end
+end
+
+tasks.each(&:join)
+----
+
+=== 制限時間内に再呼び出しがないとき、最後に一度だけブロックを呼び出す.
+
+[source,ruby]
+----
+require "thread/task"
+
+tasks = (1..10).map do |i|
+  sleep  0.1
+  Task.once( i, delay:3 ) do |j|
+    p j
+  end
+end
+
+tasks.each(&:join)
+----
+
+== リファレンス
+
+=== 新たな Thread::Task を作成する.
+
+[source,ruby]
+----
+Thread::Task.new( *args, pool: nil, count: nil, &block )
+----
+
+* Result:
+  ** Thread::Task オブジェクト.
+
+* Parameter:
+  ** args: args はそのままブロックに渡す.
+  ** pool: Thread::Task::Pool オブジェクト. (default: nil)
+  ** count: 並列実行の最大数. (default: nil)
+  ** block: コールバック動作.
+
+* Block Parameter:
+  ** args: args をそのスレッド固有のローカル変数として扱う.
+
+=== スレッド停止を待つ. スレッドの例外を無視する.
+
+[source,ruby]
+----
+Thread::Task#join
+----
+
+* Result:
+  ** nil
+
+* Parameter:
+  ** なし.
+
+=== スレッド停止を待って結果を得る. スレッドの例外を検出する.
+
+[source,ruby]
+----
+Thread::Task#value
+----
+
+* Result:
+  ** ブロックの実行結果.
+
+* Parameter:
+  ** なし.
+
+=== スレッドの実行を取り消す.
+
+[source,ruby]
+----
+Thread::Task#cancel
+----
+
+* Result:
+  ** nil.
+
+* Parameter:
+  ** なし.
+
+=== 短時間のうちに同じ行が再び呼び出された際に、一度だけ実行する.
+
+[source,ruby]
+----
+Thread::Task.once( *args, delay: nil, guard: nil, ident: nil, &block )
+----
+
+* Result:
+  ** Thread::Task オブジェクト.
+
+* Parameter:
+  ** args: args はそのままブロックに渡す.
+  ** delay: 実行前に待機する秒数. (default: nil)
+  ** guard: 実行後に保護する秒数. (default: nil)
+  ** ident: タスク識別子. (default: nil )
+  ** block: コールバック動作.
+
+=== 新たな Thread::Pool を作成する.
+
+[source,ruby]
+----
+Thread::Pool.new( count )
+----
+
+* Result:
+  ** Thread::Pool オブジェクト.
+
+* Parameter:
+  ** count: 並列実行の最大数.
+
+== 貢献
+
+不具合報告とプルリクエストは GitHub https://github.com/yorihara/thread-task まで. 
+
+== ライセンス
+
+この Gem は、 http://opensource.org/licenses/MIT[MITライセンス] の条件に基づいてオープンソースとして入手できる.
+
+Copyright (c) yorihara <orihara.yasumi@gmail.com>

data/Rakefile

@@ -0,0 +1,96 @@
+require "bundler/gem_helper"
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+class Bundler::GemHelper
+
+  def git_archive( dir = "../zip" )
+    FileUtils.mkdir_p  dir
+    dest_path  =  File.join(dir, "#{name}-#{version}.zip")
+    cmnd  =  "git archive --format zip --prefix=#{name}/ HEAD > #{dest_path}"
+
+    out, code = sh_with_status( cmnd )
+    raise "Couldn't archive gem,"  unless  code == 0
+
+    Bundler.ui.confirm "#{name} #{version} archived to #{dest_path}."
+  end
+
+  def git_push
+    ver  =  version.to_s
+
+    cmnd  =  "git push origin  #{ver} "
+    out, code = sh_with_status( cmnd )
+    raise "Couldn't git push origin."  unless  code == 0
+
+    cmnd  =  "git push "
+    out, code = sh_with_status( cmnd )
+    raise "Couldn't git push."         unless  code == 0
+
+    Bundler.ui.confirm "Git Push #{ver}."
+  end
+
+  def update_version( new_version )
+    version_filename  =  %x[ find . -type f -name "version.rb" | grep -v vendor | head -1 ].chomp
+    version_pathname  =  File.expand_path( version_filename )
+    lines  =  File.open( version_pathname ).read
+    lines  =  lines.gsub( /VERSION\s*=\s*\"\d+\.\d+\.\d+\"/, "VERSION = \"#{new_version}\"" )
+    File.open( version_pathname, "w" ) do |file|
+      file.write( lines )
+    end
+
+    cmnd  =  "git add  #{version_pathname} "
+    out, code = sh_with_status( cmnd )
+    raise "Couldn't git add,"  unless  code == 0
+
+    cmnd  =  "git commit -m  '#{new_version}' "
+    out, code = sh_with_status( cmnd )
+    raise "Couldn't git commit."  unless  code == 0
+
+    cmnd  =  "git tag        #{new_version} "
+    out, code = sh_with_status( cmnd )
+    raise "Couldn't git tag."          unless  code == 0
+
+    Bundler.ui.confirm "Update Tags to #{new_version}."
+  end
+
+end
+
+Bundler::GemHelper.new(Dir.pwd).instance_eval do
+
+  desc "Archive #{name}-#{version}.zip from repository"
+  task 'zip' do
+    git_archive
+  end
+
+  desc "Git Push"
+  task 'push' do
+    git_push
+  end
+
+  desc "Update Version Tiny"
+  task 'tiny' do
+    major, minor, tiny  =  version.to_s.split('.')
+    new_version  =  [major, minor, tiny.to_i + 1].join('.')
+    update_version( new_version )
+  end
+
+  desc "Update Version Minor"
+  task 'minor' do
+    major, minor, tiny  =  version.to_s.split('.')
+    new_version  =  [major, minor.to_i + 1, 0].join('.')
+    update_version( new_version )
+  end
+
+  desc "Update Version Major"
+  task 'major' do
+    major, minor, tiny  =  version.to_s.split('.')
+    new_version  =  [major.to_i + 1, 0, 0].join('.')
+    update_version( new_version )
+  end
+
+end
+

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "thread/task"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/thread/task.rb

@@ -0,0 +1,5 @@
+require "thread/task/version"
+require "thread/task/base"
+
+::Task = ::Thread::Task  unless defined?(::Task)
+

data/lib/thread/task/base.rb

@@ -0,0 +1,139 @@
+require "monitor"
+
+class ::Thread
+  class Task
+
+    class Pool
+      attr_reader  :rest
+
+      def initialize( size )
+        @rest  =  size
+        @monitor  =  Monitor.new
+        @lock_cond  =  @monitor.new_cond
+      end
+
+      def acquire
+        @monitor.synchronize do
+          @lock_cond.wait_while{ @rest == 0 }
+          @rest  -=  1
+        end
+      end
+
+      def release
+        @monitor.synchronize do
+          @rest  +=  1
+          @lock_cond.signal
+        end
+      end
+    end
+
+    @@pool = ::Hash.new
+
+    def initialize( *args, pool: nil, count: nil, report_on_exception: false, &block )
+      raise  ::ArgumentError, "block required."    if block.nil?
+
+      if  pool.nil? and count.nil?
+        @thread  =  ::Thread.start( args ) do |args_|
+          ::Thread.current.report_on_exception  =  report_on_exception
+          block.call( *args_ )
+        end
+
+      elsif  pool  and pool.is_a?(::Thread::Task::Pool)
+        @thread  =  ::Thread.start( args ) do |args_|
+          ::Thread.current.report_on_exception  =  report_on_exception
+          pool.acquire
+          begin
+            block.call( *args_ )
+          ensure
+            pool.release
+          end
+        end
+
+      elsif  count  and  count.is_a? ::Integer  and  count > 0
+        key  =  caller[1]
+        unless ( pool = @@pool[key] )
+          pool  =  ::Thread::Task::Pool.new( count )
+          @@pool[key]  =  pool
+        end
+
+        @thread  =  ::Thread.start( args ) do |args_|
+          ::Thread.current.report_on_exception  =  report_on_exception
+          pool.acquire
+          begin
+            block.call( *args_ )
+          ensure
+            pool.release
+          end
+        end
+
+      else
+        raise  ::ArgumentError, "Nil or size of Thread::Task::Pool object expected."
+
+      end
+    end
+
+    def join
+      @thread.join
+    end
+
+    def value
+      @thread.value
+    end
+
+    def cancel
+      @thread.kill
+      nil
+    end
+
+    class Counter
+      def initialize
+        @count  =  0
+        @mutex  =  Mutex.new
+      end
+
+      def incr
+        @mutex.synchronize do
+          @count  +=  1
+        end
+      end
+
+      def decr
+        @mutex.synchronize do
+          @count  -=  1    if  @count > 0
+          @count
+        end
+      end
+
+      def reset
+        @mutex.synchronize do
+          @count  =  0
+        end
+      end
+    end
+
+    @@counter = ::Hash.new{|h,k| h[k] = Counter.new }
+
+    def Task.once( *args, delay: nil, guard: nil, ident: nil, &block )
+      key  =  ( ident || caller[0] ).to_s
+      if  delay  and  delay.is_a? ::Numeric  and  delay > 0
+        @@counter[key].incr
+        ::Thread::Task.new( key ) do |key_|
+          ::Kernel.sleep  delay
+          count  =  @@counter[key_].decr
+          block.call( *args )    if count == 0
+        end
+      elsif  guard  and  guard.is_a? ::Numeric  and  guard > 0
+        count  =  @@counter[key].incr
+        block.call( *args )    if count == 1
+        ::Thread::Task.new( key ) do |key_|
+          ::Kernel.sleep  guard
+          @@counter[key_].decr
+        end
+      else
+        raise  ::ArgumentError, "delay or guard time expected."
+      end
+    end
+
+  end
+end
+

data/lib/thread/task/version.rb

@@ -0,0 +1,5 @@
+class ::Thread
+  class Task
+    VERSION = "2.0.0"
+  end
+end

data/sample/base_1.rb

@@ -0,0 +1,8 @@
+require "thread/task"
+
+task  =  Task.new do
+  sleep  2
+  Time.now
+end
+p task.value
+

data/sample/base_pool_1.rb

@@ -0,0 +1,12 @@
+require "thread/task"
+
+tasks  =  (0...8).map do |i|
+  Task.new( i, count:3 ) do |j|
+    p [" ->", j]
+    sleep  rand*2
+    p ["<- ", j]
+  end
+end
+
+tasks.each(&:join)
+

data/sample/base_pool_2.rb

@@ -0,0 +1,22 @@
+require "thread/task"
+
+pool  =  Task::Pool.new( 3 )
+
+tasks1  =  (0...4).map do |i|
+  Task.new( i, pool: pool ) do |j|
+    p [" ->", j]
+    sleep(rand*2)
+    p ["<- ", j]
+  end
+end
+tasks2  =  (4...8).map do |i|
+  Task.new( i, pool: pool ) do |j|
+    p [" ->", j]
+    sleep(rand*2)
+    p ["<- ", j]
+  end
+end
+
+tasks1.each(&:join)
+tasks2.each(&:join)
+

data/sample/once_delay_1.rb

@@ -0,0 +1,10 @@
+require "thread/task"
+
+tasks = (1...8).map do |i|
+  sleep  0.1
+  Task.once( i, delay:3 ) do |j|
+    p j
+  end
+end
+
+tasks.each(&:join)

data/sample/once_delay_2.rb

@@ -0,0 +1,20 @@
+require "thread/task"
+
+ident = "foobar"
+
+tasks1 = (1...4).map do |i|
+  sleep  0.1
+  Task.once( i, delay:3, ident: ident ) do |j|
+    p j
+  end
+end
+tasks2 = (4...8).map do |i|
+  sleep  0.1
+  Task.once( i, delay:3, ident: ident ) do |j|
+    p j
+  end
+end
+
+tasks1.each(&:join)
+tasks2.each(&:join)
+

data/sample/once_guard_1.rb

@@ -0,0 +1,10 @@
+require "thread/task"
+
+tasks = (1...8).map do |i|
+  sleep  0.1
+  Task.once( i, guard:3 ) do |j|
+    p j
+  end
+end
+
+tasks.each(&:join)

data/sample/once_guard_2.rb

@@ -0,0 +1,20 @@
+require "thread/task"
+
+ident = "foobar"
+
+tasks1 = (1...4).map do |i|
+  sleep  0.1
+  Task.once( i, guard:3, ident: ident ) do |j|
+    p j
+  end
+end
+tasks2 = (4...8).map do |i|
+  sleep  0.1
+  Task.once( i, guard:3, ident: ident ) do |j|
+    p j
+  end
+end
+
+tasks1.each(&:join)
+tasks2.each(&:join)
+

data/sample/rescue_1.rb

@@ -0,0 +1,22 @@
+
+require "thread/task"
+
+begin
+  task  =  Task.new do
+    sleep  1
+    raise  "die now"
+  end
+
+  p :wait
+  sleep  2
+
+  p :value
+  p task.value
+
+  p :do_not_reach
+
+rescue => e
+  p [e.message, e.backtrace.shift]
+
+end
+

data/sample/rescue_2.rb

@@ -0,0 +1,22 @@
+
+require "thread/task"
+
+begin
+  task  =  Task.new( count: 1 ) do
+    sleep  1
+    raise  "die now"
+  end
+
+  p :wait
+  sleep  2
+
+  p :join
+  p task.join
+
+  p :done
+
+rescue => e
+  p [e.message, e.backtrace.shift]
+
+end
+

data/thread-task.gemspec

@@ -0,0 +1,23 @@
+require_relative 'lib/thread/task/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "thread-task"
+  spec.version       = Thread::Task::VERSION
+  spec.authors       = ["yorihara"]
+  spec.email         = ["orihara.yasumi@gmail.com"]
+
+  spec.summary       = %q{ Wrapper library for Thread class for easily describing parallel processing. }
+  spec.description   = %q{ Wrapper library of Thread class. Thread::Task, Thrad::Task::Pool }
+  spec.homepage      = "https://github.com/yorihara/thread-task/"
+  spec.license       = "MIT"
+
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: thread-task
+version: !ruby/object:Gem::Version
+  version: 2.0.0
+platform: ruby
+authors:
+- yorihara
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2021-05-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: " Wrapper library of Thread class. Thread::Task, Thrad::Task::Pool "
+email:
+- orihara.yasumi@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- Gemfile
+- README.adoc
+- README.ja.adoc
+- Rakefile
+- bin/console
+- bin/setup
+- lib/thread/task.rb
+- lib/thread/task/base.rb
+- lib/thread/task/version.rb
+- sample/base_1.rb
+- sample/base_pool_1.rb
+- sample/base_pool_2.rb
+- sample/once_delay_1.rb
+- sample/once_delay_2.rb
+- sample/once_guard_1.rb
+- sample/once_guard_2.rb
+- sample/rescue_1.rb
+- sample/rescue_2.rb
+- thread-task.gemspec
+homepage: https://github.com/yorihara/thread-task/
+licenses:
+- MIT
+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: []
+rubygems_version: 3.2.15
+signing_key:
+specification_version: 4
+summary: Wrapper library for Thread class for easily describing parallel processing.
+test_files: []