in_threads 0.0.4 → 1.0.0

data/.gitignore

@@ -0,0 +1,11 @@
+/pkg/
+
+/doc/
+/rdoc/
+/.yardoc/
+/coverage/
+
+Makefile
+*.o
+*.bundle
+/tmp/

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2010 Ivan Kuchin
+Copyright (c) 2010-2011 Ivan Kuchin
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.markdown

@@ -1,42 +1,35 @@
-# progress
+# in_threads
 
-http://github.com/toy/in_threads
+Easily execute ruby code in parallel.
 
-## DESCRIPTION:
+## Installation
 
-Easily execute ruby code in parallel
+    gem install in_threads
 
-## SYNOPSIS:
+## Usage
 
 By default there is maximum of 10 simultaneous threads
 
-    urls.in_threads.each do |url|
-      url.save_to_disk
-    end
-
     urls.in_threads.map do |url|
       url.fetch
     end
 
+    urls.in_threads.each do |url|
+      url.save_to_disk
+    end
+
     numbers.in_threads(2).map do |number|
-      …
       # whery long and complicated formula
       # using only 2 threads
     end
 
-You can use any Enumerable method but it is up to you if this is good
+You can use any Enumerable method, but some of them can not use threads (`inject`, `reduce`) or don't use blocks (`to_a`, `entries`, `drop`, `take`, `first`, `include?`, `member?`) or have both problems depending on usage type (`min`, `max`, `minmax`, `sort`)
 
     urls.in_threads.any?(&:ok?)
     urls.in_threads.all?(&:ok?)
-
-## REQUIREMENTS:
-
-ruby )))
-
-## INSTALL:
-
-    sudo gem install in_threads
+    urls.in_threads.none?(&:error?)
+    urls.in_threads.grep(/example\.com/, &:fetch)
 
 ## Copyright
 
-Copyright (c) 2010 Ivan Kuchin. See LICENSE.txt for details.
+Copyright (c) 2010-2011 Ivan Kuchin. See LICENSE.txt for details.

data/in_threads.gemspec

@@ -1,57 +1,19 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
-# -*- encoding: utf-8 -*-
+# encoding: UTF-8
 
 Gem::Specification.new do |s|
-  s.name = %q{in_threads}
-  s.version = "0.0.4"
+  s.name        = 'in_threads'
+  s.version     = '1.0.0'
+  s.summary     = %q{Execute ruby code in parallel}
+  s.homepage    = "http://github.com/toy/#{s.name}"
+  s.authors     = ['Ivan Kuchin']
+  s.license     = 'MIT'
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Ivan Kuchin"]
-  s.date = %q{2010-12-15}
-  s.extra_rdoc_files = [
-    "LICENSE.txt",
-    "README.markdown"
-  ]
-  s.files = [
-    ".tmignore",
-    "LICENSE.txt",
-    "README.markdown",
-    "Rakefile",
-    "VERSION",
-    "in_threads.gemspec",
-    "lib/in_threads.rb",
-    "spec/in_threads_spec.rb",
-    "spec/spec_helper.rb"
-  ]
-  s.homepage = %q{http://github.com/toy/in_threads}
-  s.licenses = ["MIT"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.7}
-  s.summary = %q{Execute ruby blocks in parallel}
-  s.test_files = [
-    "spec/in_threads_spec.rb",
-    "spec/spec_helper.rb"
-  ]
+  s.rubyforge_project = s.name
 
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = %w[lib]
 
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<jeweler>, ["~> 1.5.1"])
-      s.add_development_dependency(%q<rake-gem-ghost>, [">= 0"])
-      s.add_development_dependency(%q<rspec>, [">= 0"])
-    else
-      s.add_dependency(%q<jeweler>, ["~> 1.5.1"])
-      s.add_dependency(%q<rake-gem-ghost>, [">= 0"])
-      s.add_dependency(%q<rspec>, [">= 0"])
-    end
-  else
-    s.add_dependency(%q<jeweler>, ["~> 1.5.1"])
-    s.add_dependency(%q<rake-gem-ghost>, [">= 0"])
-    s.add_dependency(%q<rspec>, [">= 0"])
-  end
+  s.add_development_dependency 'rspec'
 end
-

data/lib/in_threads.rb

@@ -2,37 +2,137 @@ require 'thread'
 require 'thwait'
 
 module Enumerable
-  def in_threads(max_threads = 10)
-    InThreads.new(self, max_threads)
+  # Run enumerable method blocks in threads
+  def in_threads(thread_count = 10, &block)
+    InThreads.new(self, thread_count, &block)
   end
 end
 
+# TODO: create my own ThreadsWait with blackjack and hookers?
+# TODO: create class methods for connecting Enumerable method to runner
+# TODO: run_in_threads_inconsecutive for `all?`, `any?`, `none?` and `one?`
+# TODO: all ruby1.9.3 methods
+# TODO: better way of handling grep?
+# TODO: check method presence if Enumerable before connectin to runner
+
 class InThreads
-  def initialize(object, max_threads)
-    @threads = []
-    @object = object
-    @max_threads = max_threads
+  (
+    instance_methods.map(&:to_s) -
+    %w[__id__ __send__ class inspect instance_of? is_a? kind_of? nil? object_id respond_to? send]
+  ).each{ |name| undef_method name }
+  (private_instance_methods.map(&:to_s) - %w[initialize]).each{ |name| undef_method name }
+
+  attr_reader :enumerable, :thread_count
+  def initialize(enumerable, thread_count = 10, &block)
+    @enumerable, @thread_count = enumerable, thread_count
+    each(&block) if block
+  end
+
+  def in_threads(thread_count = 10, &block)
+    self.class.new(enumerable, thread_count, &block)
+  end
+
+  %w[
+    each
+    all? any? none? one?
+    detect find find_index drop_while take_while
+    partition find_all select reject count
+    collect map group_by max_by min_by minmax_by sort_by
+  ].each do |name|
+    class_eval <<-RUBY
+      def #{name}(*args, &block)
+        run_in_threads_consecutive(enumerable, :#{name}, *args, &block)
+      end
+    RUBY
+  end
+
+  %w[
+    reverse_each
+    each_with_index enum_with_index
+    each_cons each_slice enum_cons enum_slice
+    zip
+    cycle
+  ].each do |name|
+    class_eval <<-RUBY
+      def #{name}(*args, &block)
+        run_in_threads_block_result_irrelevant(enumerable, :#{name}, *args, &block)
+      end
+    RUBY
   end
 
-  def map(*args, &block)
-    run_in_threads(:map, *args, &block)
-    @threads.map(&:value)
+  def grep(*args, &block)
+    if block
+      run_in_threads_consecutive(enumerable.grep(*args), :map, &block)
+    else
+      enumerable.grep(*args)
+    end
   end
 
-  def method_missing(method, *args, &block)
-    run_in_threads(method, *args, &block)
+  %w[
+    inject reduce
+    max min minmax sort
+    entries to_a
+    drop take
+    first
+    include? member?
+  ].each do |name|
+    class_eval <<-RUBY
+      def #{name}(*args, &block)
+        enumerable.#{name}(*args, &block)
+      end
+    RUBY
   end
 
 private
 
-  def run_in_threads(method, *args, &block)
-    @object.send(method, *args) do |*args|
-      while @threads.count(&:alive?) >= @max_threads
-        ThreadsWait.new(*@threads).next_wait
+  def run_in_threads_block_result_irrelevant(enumerable, method, *args, &block)
+    if block
+      waiter = ThreadsWait.new
+      begin
+        enumerable.send(method, *args) do |*block_args|
+          waiter.next_wait if waiter.threads.length >= thread_count
+          waiter.join_nowait([Thread.new(*block_args, &block)])
+        end
+      ensure
+        waiter.all_waits
+      end
+    else
+      enumerable.send(method, *args)
+    end
+  end
+
+  def run_in_threads_consecutive(enumerable, method, *args, &block)
+    if block
+      begin
+        queue = Queue.new
+        runner = Thread.new(enumerable) do |enumerable|
+          threads = []
+          begin
+            enumerable.each do |object|
+              if threads.length >= thread_count
+                threads = threads.select(&:alive?)
+                if threads.length >= thread_count
+                  ThreadsWait.new(*threads).next_wait
+                end
+              end
+              break if Thread.current[:stop]
+              thread = Thread.new(object, &block)
+              threads << thread
+              queue << thread
+            end
+          ensure
+            threads.map(&:join)
+          end
+        end
+        enumerable.send(method, *args) do |*block_args|
+          queue.pop.value
+        end
+      ensure
+        runner[:stop] = true
+        runner.join
       end
-      @threads << Thread.new(*args, &block)
+    else
+      enumerable.send(method, *args)
     end
-  ensure
-    @threads.map(&:join)
   end
 end

data/spec/in_threads_spec.rb

@@ -1,57 +1,355 @@
 require File.dirname(__FILE__) + '/spec_helper.rb'
 
-describe InThreads do
-  before :each do
-    srand 1
-    @a = (1..30).map{ |i| mock(:"e#{i}", :hello => nil, :value => i, :rand => rand * 0.01) }
-    @sleepy_prock = proc{ |e| sleep(e.rand); e.hello; e.value }
-    @sleepy_prock_a = proc{ |e| sleep(e.inject{ |sum, e| e.rand }); e.hash }
+class Item
+  def initialize(i)
+    @i, @rand = i, rand
   end
 
+  class MiddleMatcher
+    def ===(item)
+      raise "#{item.inspect} is not an Item" unless item.is_a?(Item)
+      (0.25..0.75) === item.instance_variable_get(:@rand)
+    end
+  end
+
+  def work
+    sleep @rand * 0.008
+  end
+
+  def value
+    work; @rand
+  end
+
+  def check?
+    value < 0.5
+  end
+
+  def touch_n_value(*args)
+    touch(*args); value
+  end
+
+  def touch_n_check?(*args)
+    touch(*args); check?
+  end
+end
+
+class ValueItem < Item
+  def initialize(i, value)
+    super(i)
+    @value = value
+  end
+
+  def value
+    work; @value
+  end
+
+  def check?
+    !!value
+  end
+end
+
+def enum_methods(methods)
+  (Enumerable.instance_methods.map(&:to_s) & methods)
+end
+
+describe "in_threads" do
+  let(:enum){ 30.times.map{ |i| Item.new(i) } }
+  let(:speed_coef){ 0.666 } # small coefficient, should be more if sleep time coefficient is bigger
+
   def measure
     start = Time.now
     yield
     Time.now - start
   end
 
-  it "should execute block for each element" do
-    @a.each{ |e| e.should_receive(:hello) }
-    @a.in_threads.each(&:hello)
+  describe "in_threads" do
+    it "should not change existing instance" do
+      threaded = enum.in_threads(10)
+      proc{ threaded.in_threads(20) }.should_not change(threaded, :thread_count)
+    end
+
+    it "should create new instance with different title when called on WithProgress" do
+      threaded = enum.in_threads(10)
+      tthreaded = threaded.in_threads(20)
+      threaded.thread_count.should == 10
+      tthreaded.thread_count.should == 20
+      tthreaded.class.should == threaded.class
+      tthreaded.object_id.should_not == threaded.object_id
+      tthreaded.enumerable.should == threaded.enumerable
+    end
   end
 
-  it "should not run simulanteously more threads" do
-    @mutex = Mutex.new
-    @threads = 0
-    (1..100).to_a.in_threads(10).each do |i|
-      (0..10).include?(@threads).should be_true
-      @mutex.synchronize{ @threads += 1 }
-      (0..10).include?(@threads).should be_true
-      sleep 1 + rand * 1
-      (0..10).include?(@threads).should be_true
-      @mutex.synchronize{ @threads -= 1 }
-      (0..10).include?(@threads).should be_true
+  describe "each" do
+    it "should return same enum after running" do
+      enum.in_threads.each(&:value).should == enum
+    end
+
+    it "should execute block for each element" do
+      enum.each{ |o| o.should_receive(:touch).once }
+      enum.in_threads.each(&:touch)
+    end
+
+    it "should run faster with threads" do
+      measure{ enum.in_threads.each(&:work) }.should < measure{ enum.each(&:work) } * speed_coef
+    end
+
+    it "should run faster with more threads" do
+      measure{ enum.in_threads(20).each(&:work) }.should < measure{ enum.in_threads(2).each(&:work) } * speed_coef
+    end
+
+    it "should return same enum without block" do
+      enum.in_threads.each.to_a.should == enum.each.to_a
     end
   end
 
-  it "should run faster than without threads" do
-    (measure{ @a.in_threads.each(&@sleepy_prock) } * 2).should be < measure{ @a.each(&@sleepy_prock) }
+  enum_methods(%w[each_with_index enum_with_index]).each do |method|
+    describe method do
+      let(:runner){ proc{ |o, i| o.value } }
+
+      it "should return same result with threads" do
+        enum.in_threads.send(method, &runner).should == enum.send(method, &runner)
+      end
+
+      it "should fire same objects" do
+        enum.send(method){ |o, i| o.should_receive(:touch).with(i).once }
+        enum.in_threads.send(method){ |o, i| o.touch_n_value(i) }
+      end
+
+      it "should run faster with threads" do
+        measure{ enum.in_threads.send(method, &runner) }.should < measure{ enum.send(method, &runner) } * speed_coef
+      end
+
+      it "should return same enum without block" do
+        enum.in_threads.send(method).to_a.should == enum.send(method).to_a
+      end
+    end
   end
 
-  it "should run not much slower than max of block running times if ran simultaneously" do
-    measure{ (1..95).in_threads(100).each{ |i| sleep(i * 0.01) } }.should be < 1.0
+  describe "reverse_each" do
+    it "should return same result with threads" do
+      enum.in_threads.reverse_each(&:value).should == enum.reverse_each(&:value)
+    end
+
+    it "should fire same objects in reverse order" do
+      @order = mock('order', :touch => nil)
+      @order.should_receive(:touch).with(enum.last).ordered
+      @order.should_receive(:touch).with(enum[enum.length / 2]).ordered
+      @order.should_receive(:touch).with(enum.first).ordered
+      enum.reverse_each{ |o| o.should_receive(:touch).once }
+      @mutex = Mutex.new
+      enum.in_threads.reverse_each do |o|
+        @mutex.synchronize{ @order.touch(o) }
+        o.touch_n_value
+      end
+    end
+
+    it "should run faster with threads" do
+      measure{ enum.in_threads.reverse_each(&:value) }.should < measure{ enum.reverse_each(&:value) } * speed_coef
+    end
+
+    it "should return same enum without block" do
+      enum.in_threads.reverse_each.to_a.should == enum.reverse_each.to_a
+    end
   end
 
-  it "should run faster when ran with more threads" do
-    (measure{ @a.in_threads(20).each(&@sleepy_prock) } * 2).should be < measure{ @a.in_threads(2).each(&@sleepy_prock) }
+  %w[
+    all? any? none? one?
+    detect find find_index drop_while take_while
+  ].each do |method|
+    describe method do
+      let(:enum){ 100.times.map{ |i| ValueItem.new(i, i % 2 == 1) } }
+
+      it "should return same result with threads" do
+        enum.in_threads.send(method, &:check?).should == enum.send(method, &:check?)
+      end
+
+      it "should fire same objects but not all" do
+        a = []
+        enum.send(method) do |o|
+          a << o
+          o.check?
+        end
+
+        @a = []
+        @mutex = Mutex.new
+        enum.in_threads.send(method){ |o| @mutex.synchronize{ @a << o }; o.check? }
+
+        @a.length.should >= a.length
+        @a.length.should <= enum.length / 2
+      end
+
+      it "should run faster with threads" do
+        value = %w[all? drop_while take_while].include?(method)
+        enum = 30.times.map{ |i| ValueItem.new(i, value) }
+        measure{ enum.in_threads.send(method, &:check?) }.should < measure{ enum.send(method, &:check?) } * speed_coef
+      end
+    end
   end
 
-  %w(each map any? all? none?).each do |method|
-    it "should return same as without thread for #{method}" do
-      @a.in_threads.send(method, &@sleepy_prock).should == @a.send(method, &@sleepy_prock)
+  %w[partition find_all select reject count].each do |method|
+    describe method do
+      it "should return same result with threads" do
+        enum.in_threads.send(method, &:check?).should == enum.send(method, &:check?)
+      end
+
+      it "should fire same objects" do
+        enum.send(method){ |o| o.should_receive(:touch).once }
+        enum.in_threads.send(method, &:touch_n_check?)
+      end
+
+      it "should run faster with threads" do
+        measure{ enum.in_threads.send(method, &:check?) }.should < measure{ enum.send(method, &:check?) } * speed_coef
+      end
+    end
+  end
+
+  %w[collect map group_by max_by min_by minmax_by sort_by].each do |method|
+    describe method do
+      it "should return same result with threads" do
+        enum.in_threads.send(method, &:value).should == enum.send(method, &:value)
+      end
+
+      it "should fire same objects" do
+        enum.send(method){ |o| o.should_receive(:touch).once; 0 }
+        enum.in_threads.send(method, &:touch_n_value)
+      end
+
+      it "should run faster with threads" do
+        measure{ enum.in_threads.send(method, &:value) }.should < measure{ enum.send(method, &:value) } * speed_coef
+      end
+    end
+  end
+
+  enum_methods(%w[each_cons each_slice enum_slice enum_cons]).each do |method|
+    describe method do
+      let(:runner){ proc{ |a| a.each(&:value) } }
+
+      it "should fire same objects" do
+        enum.send(method, 3){ |a| a.first.should_receive(:touch).with(a).once }
+        enum.in_threads.send(method, 3){ |a| a.first.touch_n_value(a) }
+      end
+
+      it "should return same with block" do
+        enum.in_threads.send(method, 3, &runner).should == enum.send(method, 3, &runner)
+      end
+
+      it "should run faster with threads" do
+        measure{ enum.in_threads.send(method, 3, &runner) }.should < measure{ enum.send(method, 3, &runner) } * speed_coef
+      end
+
+      it "should return same without block" do
+        enum.in_threads.send(method, 3).to_a.should == enum.send(method, 3).to_a
+      end
+    end
+  end
+
+  describe "zip" do
+    let(:runner){ proc{ |a| a.each(&:value) } }
+
+    it "should fire same objects" do
+      enum.zip(enum, enum){ |a| a.first.should_receive(:touch).with(a).once }
+      enum.in_threads.zip(enum, enum){ |a| a.first.touch_n_value(a) }
+    end
+
+    it "should return same with block" do
+      enum.in_threads.zip(enum, enum, &runner).should == enum.zip(enum, enum, &runner)
+    end
+
+    it "should run faster with threads" do
+      measure{ enum.in_threads.zip(enum, enum, &runner) }.should < measure{ enum.zip(enum, enum, &runner) } * speed_coef
+    end
+
+    it "should return same without block" do
+      enum.in_threads.zip(enum, enum).should == enum.zip(enum, enum)
+    end
+  end
+
+  describe "cycle" do
+    it "should fire same objects" do
+      enum.cycle(1){ |o| o.should_receive(:touch).exactly(3).times }
+      enum.in_threads.cycle(3, &:touch_n_value)
+    end
+
+    it "should run faster with threads" do
+      measure{ enum.in_threads.cycle(3, &:work) }.should < measure{ enum.cycle(3, &:work) } * speed_coef
+    end
+
+    it "should return same enum without block" do
+      enum.in_threads.cycle(3).to_a.should == enum.cycle(3).to_a
+    end
+  end
+
+  describe "grep" do
+    let(:matcher){ Item::MiddleMatcher.new }
+
+    it "should fire same objects" do
+      enum.each{ |o| o.should_receive(:touch).exactly(matcher === o ? 1 : 0).times }
+      enum.in_threads.grep(matcher, &:touch_n_value)
+    end
+
+    it "should return same with block" do
+      enum.in_threads.grep(matcher, &:value).should == enum.grep(matcher, &:value)
+    end
+
+    it "should run faster with threads" do
+      measure{ enum.in_threads.grep(matcher, &:value) }.should < measure{ enum.grep(matcher, &:value) } * speed_coef
+    end
+
+    it "should return same without block" do
+      enum.in_threads.grep(matcher).should == enum.grep(matcher)
     end
   end
 
-  it "should return same as without thread for .each_slice" do
-    @a.in_threads.each_slice(2, &@sleepy_prock_a).should == @a.each_slice(2, &@sleepy_prock_a)
+  context "unthreaded" do
+    %w[inject reduce].each do |method|
+      describe method do
+        it "should return same result" do
+          combiner = proc{ |memo, o| memo + o.value }
+          enum.in_threads.send(method, 0, &combiner).should == enum.send(method, 0, &combiner)
+        end
+      end
+    end
+
+    %w[max min minmax sort].each do |method|
+      describe method do
+        it "should return same result" do
+          comparer = proc{ |a, b| a.value <=> b.value }
+          enum.in_threads.send(method, &comparer).should == enum.send(method, &comparer)
+        end
+      end
+    end
+
+    %w[to_a entries].each do |method|
+      describe method do
+        it "should return same result" do
+          enum.in_threads.send(method).should == enum.send(method)
+        end
+      end
+    end
+
+    %w[drop take].each do |method|
+      describe method do
+        it "should return same result" do
+          enum.in_threads.send(method, 2).should == enum.send(method, 2)
+        end
+      end
+    end
+
+    %w[first].each do |method|
+      describe method do
+        it "should return same result" do
+          enum.in_threads.send(method).should == enum.send(method)
+          enum.in_threads.send(method, 3).should == enum.send(method, 3)
+        end
+      end
+    end
+
+    %w[include? member?].each do |method|
+      describe method do
+        it "should return same result" do
+          enum.in_threads.send(method, enum[10]).should == enum.send(method, enum[10])
+        end
+      end
+    end
   end
 end

metadata

@@ -2,12 +2,12 @@
 name: in_threads
 version: !ruby/object:Gem::Version 
   hash: 23
-  prerelease: false
+  prerelease: 
   segments: 
+  - 1
   - 0
   - 0
-  - 4
-  version: 0.0.4
+  version: 1.0.0
 platform: ruby
 authors: 
 - Ivan Kuchin
@@ -15,43 +15,12 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-15 00:00:00 +03:00
-default_executable: 
+date: 2011-12-05 00:00:00 Z
 dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: jeweler
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 1
-        segments: 
-        - 1
-        - 5
-        - 1
-        version: 1.5.1
-  type: :development
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: rake-gem-ghost
-  prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :development
-  version_requirements: *id002
 - !ruby/object:Gem::Dependency 
   name: rspec
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -61,27 +30,23 @@ dependencies:
         - 0
         version: "0"
   type: :development
-  version_requirements: *id003
+  version_requirements: *id001
 description: 
 email: 
 executables: []
 
 extensions: []
 
-extra_rdoc_files: 
-- LICENSE.txt
-- README.markdown
+extra_rdoc_files: []
+
 files: 
-- .tmignore
+- .gitignore
 - LICENSE.txt
 - README.markdown
-- Rakefile
-- VERSION
 - in_threads.gemspec
 - lib/in_threads.rb
 - spec/in_threads_spec.rb
 - spec/spec_helper.rb
-has_rdoc: true
 homepage: http://github.com/toy/in_threads
 licenses: 
 - MIT
@@ -110,11 +75,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: "0"
 requirements: []
 
-rubyforge_project: 
-rubygems_version: 1.3.7
+rubyforge_project: in_threads
+rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
-summary: Execute ruby blocks in parallel
+summary: Execute ruby code in parallel
 test_files: 
 - spec/in_threads_spec.rb
 - spec/spec_helper.rb
+has_rdoc: 

data/.tmignore

@@ -1 +0,0 @@
-/*.gemspec

data/Rakefile

@@ -1,25 +0,0 @@
-require 'rake'
-require 'jeweler'
-require 'rake/gem_ghost_task'
-require 'rspec/core/rake_task'
-
-name = 'in_threads'
-
-Jeweler::Tasks.new do |gem|
-  gem.name = name
-  gem.summary = %Q{Execute ruby blocks in parallel}
-  gem.homepage = "http://github.com/toy/#{name}"
-  gem.license = 'MIT'
-  gem.authors = ['Ivan Kuchin']
-  gem.add_development_dependency 'jeweler', '~> 1.5.1'
-  gem.add_development_dependency 'rake-gem-ghost'
-  gem.add_development_dependency 'rspec'
-end
-Jeweler::RubygemsDotOrgTasks.new
-Rake::GemGhostTask.new
-
-RSpec::Core::RakeTask.new(:spec) do |spec|
-  spec.rspec_opts = ['--colour --format progress']
-  spec.pattern = 'spec/**/*_spec.rb'
-end
-task :default => :spec

data/VERSION

@@ -1 +0,0 @@
-0.0.4