timeout-interrupt 0.2.0 → 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5392e2634dba25bda8fc76725212aa44a15d2f4162beb60e10a17ee82e655b11
+  data.tar.gz: 07efedfea6f6aa995f6b239b2960d8da07d1845769580ed3853fa60397ea1842
+SHA512:
+  metadata.gz: 734548b8dc8e64227e1efa5dfdbe4b9b95cb86ae47dd0d1aad87ec50575f5706319d50df2c57e362c2517efc35c17797379a37cc4ab283cf8a43ecf3569e65e0
+  data.tar.gz: 6b2f7432900414d2b19276251deb5932ade594adb8b39cabba62c17017e49f1052119efff231b625fd5d6c711982ae805fde0812c61163c7c18ead8e62e34836

data/.gitignore

@@ -0,0 +1,18 @@
+coverage
+coverage.data
+rdoc
+doc
+.yardoc
+.bundle
+Gemfile.lock
+pkg
+.DS_Store
+*.tmproj
+tmtags
+*~
+\#*
+.\#*
+*.sw[p-n]
+.redcar
+*.rbc
+.document

data/Gemfile

@@ -1,14 +1,2 @@
-source "http://rubygems.org"
-
-gem 'ffi-libc'
-
-# Add dependencies to develop your gem here.
-# Include everything needed to run rake, tests, features, etc.
-group :development do
-  gem "shoulda"
-  gem "yard"
-  gem "rdoc"
-  gem "bundler"
-  gem "jeweler"
-  gem "simplecov"
-end
+source "https://rubygems.org"
+gemspec

data/README.md

@@ -67,4 +67,4 @@ And same problem you have with ruby's `Timeout.timeout`.
 Copyleft
 =========
 
-Copyright (c) 2013 Denis Knauf. See LICENSE.txt for further details.
+Copyright (c) 2021 Denis Knauf. See LICENSE.txt for further details.

data/Rakefile

@@ -1,46 +1,9 @@
-# encoding: utf-8
-
-require 'rubygems'
-require 'bundler'
-begin
-  Bundler.setup(:default, :development)
-rescue Bundler::BundlerError => e
-  $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
-  exit e.status_code
-end
-require 'rake'
-
-require 'jeweler'
-Jeweler::Tasks.new do |gem|
-  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
-  gem.name = "timeout-interrupt"
-  gem.homepage = "http://github.com/DenisKnauf/ruby-timeout-interrupt"
-  gem.license = "AGPLv3"
-  gem.summary = %Q{"Interrupts systemcalls too."}
-  gem.description = %Q{Timeout-lib, which interrupts everything, also systemcalls. It uses libc-alarm.}
-  gem.email = "Denis.Knauf@gmail.com"
-  gem.authors = ["Denis Knauf"]
-  # dependencies defined in Gemfile
-end
-Jeweler::RubygemsDotOrgTasks.new
+require "bundler/gem_tasks"
+task :default => :spec
 
 require 'rake/testtask'
-Rake::TestTask.new(:test) do |test|
+Rake::TestTask.new :test do |test|
   test.libs << 'lib' << 'test'
   test.pattern = 'test/**/test_*.rb'
   test.verbose = true
 end
-
-#require 'simplecov'
-#Rcov::RcovTask.new do |test|
-  #test.libs << 'test'
-  #test.pattern = 'test/**/test_*.rb'
-  #test.verbose = true
-  #test.rcov_opts << '--exclude "gems/*"'
-#end
-
-task :default => :test
-
-require 'yard'
-YARD::Rake::YardocTask.new

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.3.0

data/lib/timeout_interrupt.rb

@@ -1,40 +1,93 @@
 require 'ffi/libc'
 require 'timeout'
 
-module FFI
-	module LibC
-		attach_function :alarm, [:uint], :uint  unless FFI::LibC.respond_to? :alarm
-	end
-end
-
+# Helper module for `TimeoutInterrupt`
+# @see TimeoutInterrupt
 module TimeoutInterruptSingleton
 	class <<self
+		# Stores all timeouts.
+		#
+		# @param thread [nil] must be nil! Do not use it yet!
+		# @return [Hash< key(Integer): [at(Time), backtrace(Array<String>), exception(Exception)] >]
 		def timeouts thread = nil
-			@timeouts ||= Hash.new {|h,k| h[k] = [] }
-			thread = Thread.current  if thread.kind_of? Thread
+			@timeouts ||= Hash.new {|h,k| h[k] = {} }
+			thread = Thread.current  unless thread.kind_of? Thread
 			thread ? @timeouts[thread] : @timeouts
 		end
 
+		# If there's a timed out timeout, it will raise its exception.
+		# Can be used for handling ALRM-signal.
+		# It will prepare the next timeout, too.
+		#
+		# The timeout will not removed from timeouts, because it is timed out, yet.
+		# First, if timeout-scope will be exit, it will be removed.
+		#
+		# @return [nil]
 		def alarm_trap sig
-			key, (at, bt, exception) = self.timeouts.min_by {|key,(at,bt,ex)| at }
+			raise_if_sb_timed_out
+			setup
+		end
+
+		# There is a timed out timeout? It will raise it!
+		# You need not to check it yourself, it will do it for you.
+		#
+		# @return [nil]
+		def raise_if_sb_timed_out
+			return  if self.timeouts.empty?
+			_key, (at, bt, exception) = self.timeouts.min_by {|_key,(at,_bt,_ex)| at }
 			return  if Time.now < at
 			raise exception, 'execution expired', bt
 		end
 
+		# Prepares the next timeout. Sets the trap and the shortest timeout as alarm.
+		#
+		# @return [nil]
 		def setup
 			if timeouts.empty?
 				Signal.trap( 'ALRM') {}
 				FFI::LibC.alarm 0
 			else
-				key, (at, bt) = timeouts.min_by {|key,(at,bt)| at }
-				secs = (at - Time.now)
-				alarm_trap 14  if 0 > secs
+				raise_if_sb_timed_out
 				Signal.trap 'ALRM', &method( :alarm_trap)
-				FFI::LibC.alarm secs.to_i+1
+				_key, (at, _bt) = timeouts.min_by {|_key,(at,_bt)| at }
+				FFI::LibC.alarm (at - Time.now).to_i + 1
 			end
+			nil
 		end
 
-		def timeout seconds = nil, exception = nil
+		# Creates a timeout and calls your block, which has to finish before timeout occurs.
+		#
+		# @param seconds [0]           No timeout, so block can take any time.
+		# @param seconds [Integer]     In `seconds` Seconds, it should raise a timeout, if not finished.
+		# @param seconds [nil]         If this and no block given, it will call {setup} for checking and
+		#                              preparing _next_ known timeout.
+		# @param exception [exception] which exception will be raised if timed out?
+		# @param exception [nil]       `TimeoutInterrupt::Error` will be used to raise.
+		# @param block [Proc]          Will be called and should finish its work before it timed out.
+		# @param block [nil]           Nothing will happen, instead it will return a Proc,
+		#                              which can be called with a block to use the timeout.
+		# @return If block given, the returned value of your block.
+		#         Or if not, it will return a Proc, which will expect a Proc if called.
+		#         This Proc has no arguments and will prepare a timeout, like if you had given a block.
+		#
+		# You can rescue `Timeout::Error`, instead `TimeoutInterrupt::Error`,
+		# it is a subclass of `Timeout::Error`.
+		#
+		# It will call your given block, which has `seconds` seconds to end.
+		# If you want to prepare a timeout, which should be used many times,
+		# without giving `seconds` and `exception`, you can omit the block,
+		# so, `TimeoutInterruptSingleton#timeout` will return a `Proc`, which want to have the block.
+		#
+		# There is a problem with scoped timeouts. If you rescue a timeout in an other timeout,
+		# it's possible, that the other timeout will never timeout, because both are timed out at once.
+		# Than you need to call `TimeoutInterruptSingleton#timeout` without arguments.
+		# It will prepare the next timeout or it will raise it directy, if timed out.
+		#
+		# @see TimeoutInterrupt.timeout
+		# @see TimeoutInterrupt#timeout
+		# @raise exception
+		def timeout seconds = nil, exception = nil, &block
+			return yield( seconds)  if seconds.nil? || 0 == seconds  if block_given?
 			return setup  if seconds.nil?
 			seconds = seconds.to_i
 			exception ||= TimeoutInterrupt::Error
@@ -50,7 +103,7 @@ module TimeoutInterruptSingleton
 			begin
 				self.timeouts[key] = [at, bt, exception]
 				setup
-				yield
+				yield seconds
 			ensure
 				self.timeouts.delete key
 				setup
@@ -59,15 +112,84 @@ module TimeoutInterruptSingleton
 	end
 end
 
+# Can be included, or used directly.
+# In both cases, it provides {#timeout}.
+#
+# @see TimeoutInterruptSingleton
 module TimeoutInterrupt
+	# The {TimeoutInterrupt::Error} is the default exception, which will be raised,
+	# if something will time out.
+	# Its base-class is {Timeout::Error}, so you can replace {Timeout} by {TimeoutInterrupt} without
+	# replacing your `rescue Timeout::Error`, but you can.
 	class Error < Timeout::Error
 	end
 
-	def self.timeout seconds = nil, exception = nil, &e
-		TimeoutInterruptSingleton.timeout seconds, exception, &e
+	# Creates a timeout and calls your block, which has to finish before timeout occurs.
+	#
+	# @param seconds [0]           No timeout, so block can take any time.
+	# @param seconds [Integer]     In `seconds` Seconds, it should raise a timeout, if not finished.
+	# @param seconds [nil]         If also no block given, everything will be ignored and
+	#                              it will call {setup} for checking and preparing next known timeout.
+	# @param exception [Exception] which will be raised if timed out.
+	# @param exception [nil]       `TimeoutInterrupt::Error` will be used to raise.
+	# @param block [Proc]          Will be called and should finish its work before it timed out.
+	# @param block [nil]           Nothing will happen, instead it will return a Proc,
+	#                              which can be called with a block to use the timeout.
+	# @return If block given, the returned value of your block.
+	#         Or if not, it will return a Proc, which will expect a Proc if called.
+	#         This Proc has no arguments and will prepare a timeout, like if you had given a block.
+	#
+	# You can rescue `Timeout::Error`, instead `TimeoutInterrupt::Error`, it will work too.
+	#
+	# It will call your given block, which has `seconds` seconds to end.
+	# If you want to prepare a timeout, which should be used many times,
+	# without giving `seconds` and `exception`, you can omit the block,
+	# so, `TimeoutInterruptSingleton#timeout` will return a `Proc`, which want to have the block.
+	#
+	# There is a problem with scoped timeouts. If you rescue a timeout in an other timeout,
+	# it's possible, that the other timeout will never timeout, because both are timed out at once.
+	# Than you need to call `TimeoutInterruptSingleton#timeout` without arguments.
+	# It will prepare the next timeout or it will raise it directy, if timed out.
+	#
+	# @see TimeoutInterrupt#timeout
+	# @see TimeoutInterruptSingleton.timeout
+	# @raise exception
+	def self.timeout seconds = nil, exception = nil, &block
+		TimeoutInterruptSingleton.timeout seconds, exception, &block
 	end
 
-	def timeout seconds = nil, exception = nil, &e
-		TimeoutInterruptSingleton.timeout seconds, exception, &e
+	# Creates a timeout and calls your block, which has to finish before timeout occurs.
+	#
+	# @param seconds [0]           No timeout, so block can take any time.
+	# @param seconds [Integer]     In `seconds` Seconds, it should raise a timeout, if not finished.
+	# @param seconds [nil]         If also no block given, everything will be ignored and
+	#                              it will call {setup} for checking and preparing next known timeout.
+	# @param exception [Exception] which will be raised if timed out.
+	# @param exception [nil]       `TimeoutInterrupt::Error` will be used to raise.
+	# @param block [Proc]          Will be called and should finish its work before it timed out.
+	# @param block [nil]           Nothing will happen, instead it will return a Proc,
+	#                              which can be called with a block to use the timeout.
+	# @return If block given, the returned value of your block.
+	#         Or if not, it will return a Proc, which will expect a Proc if called.
+	#         This Proc has no arguments and will prepare a timeout, like if you had given a block.
+	#
+	# You can rescue `Timeout::Error`, instead `TimeoutInterrupt::Error`, it will work too.
+	#
+	# It will call your given block, which has `seconds` seconds to end.
+	# If you want to prepare a timeout, which should be used many times,
+	# without giving `seconds` and `exception`, you can omit the block,
+	# so, `TimeoutInterruptSingleton#timeout` will return a `Proc`, which want to have the block.
+	#
+	# There is a problem with scoped timeouts. If you rescue a timeout in an other timeout,
+	# it's possible, that the other timeout will never timeout, because both are timed out at once.
+	# Than you need to call `TimeoutInterruptSingleton#timeout` without arguments.
+	# It will prepare the next timeout or it will raise it directy, if timed out.
+	#
+	# @note This method is useful, if you `include TimeoutInterrupt`. You can call it directly.
+	# @see TimeoutInterrupt.timeout
+	# @see TimeoutInterruptSingleton.timeout
+	# @raise exception
+	def timeout seconds = nil, exception = nil, &block
+		TimeoutInterruptSingleton.timeout seconds, exception, &block
 	end
 end

data/timeout-interrupt.gemspec

@@ -1,68 +1,33 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
-# -*- encoding: utf-8 -*-
+Gem::Specification.new do |spec|
+	spec.name = "timeout-interrupt"
+	spec.version = "0.4.0"
 
-Gem::Specification.new do |s|
-  s.name = "timeout-interrupt"
-  s.version = "0.2.0"
+	spec.authors = ["Denis Knauf"]
+	spec.description = "Timeout-lib, which interrupts everything, also systemcalls. It uses libc-alarm."
+	spec.email = ["git+timeout-interrupt@denkn.at"]
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Denis Knauf"]
-  s.date = "2013-03-07"
-  s.description = "Timeout-lib, which interrupts everything, also systemcalls. It uses libc-alarm."
-  s.email = "Denis.Knauf@gmail.com"
-  s.extra_rdoc_files = [
-    "LICENSE.txt",
-    "README.md"
-  ]
-  s.files = [
-    ".document",
-    "Gemfile",
-    "Gemfile.lock",
-    "LICENSE.txt",
-    "README.md",
-    "Rakefile",
-    "VERSION",
-    "lib/timeout_interrupt.rb",
-    "test/helper.rb",
-    "test/test_ruby-timeout-interrupt.rb",
-    "timeout-interrupt.gemspec"
-  ]
-  s.homepage = "http://github.com/DenisKnauf/ruby-timeout-interrupt"
-  s.licenses = ["AGPLv3"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.11"
-  s.summary = "\"Interrupts systemcalls too.\""
+	spec.summary = "\"Interrupts systemcalls too.\""
+	spec.licenses = ["LGPLv3"]
 
-  if s.respond_to? :specification_version then
-    s.specification_version = 3
+	spec.homepage = "https://git.denkn.at/deac/ruby-timeout-interrupt"
+	spec.required_ruby_version = Gem::Requirement.new(">= 2.1.0")
 
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<ffi-libc>, [">= 0"])
-      s.add_development_dependency(%q<shoulda>, [">= 0"])
-      s.add_development_dependency(%q<yard>, [">= 0"])
-      s.add_development_dependency(%q<rdoc>, [">= 0"])
-      s.add_development_dependency(%q<bundler>, [">= 0"])
-      s.add_development_dependency(%q<jeweler>, [">= 0"])
-      s.add_development_dependency(%q<simplecov>, [">= 0"])
-    else
-      s.add_dependency(%q<ffi-libc>, [">= 0"])
-      s.add_dependency(%q<shoulda>, [">= 0"])
-      s.add_dependency(%q<yard>, [">= 0"])
-      s.add_dependency(%q<rdoc>, [">= 0"])
-      s.add_dependency(%q<bundler>, [">= 0"])
-      s.add_dependency(%q<jeweler>, [">= 0"])
-      s.add_dependency(%q<simplecov>, [">= 0"])
-    end
-  else
-    s.add_dependency(%q<ffi-libc>, [">= 0"])
-    s.add_dependency(%q<shoulda>, [">= 0"])
-    s.add_dependency(%q<yard>, [">= 0"])
-    s.add_dependency(%q<rdoc>, [">= 0"])
-    s.add_dependency(%q<bundler>, [">= 0"])
-    s.add_dependency(%q<jeweler>, [">= 0"])
-    s.add_dependency(%q<simplecov>, [">= 0"])
-  end
-end
+	spec.metadata["homepage_uri"]    = spec.homepage
+	spec.metadata["source_code_uri"] = spec.homepage
+	spec.metadata["changelog_uri"]   = spec.homepage
+
+	# Specify which files should be added to the gem when it is released.
+	# The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+	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        = "bin"
+	spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+	spec.require_paths = ["lib"]
 
+	spec.add_runtime_dependency 'ffi-libc', '>= 0.1.1'
+	spec.add_development_dependency 'test-unit'
+	spec.add_development_dependency 'shoulda'
+	spec.add_development_dependency 'rake'
+	spec.add_development_dependency 'bundler'
+end

metadata

@@ -1,138 +1,124 @@
 --- !ruby/object:Gem::Specification
 name: timeout-interrupt
 version: !ruby/object:Gem::Version
-  version: 0.2.0
-  prerelease: 
+  version: 0.4.0
 platform: ruby
 authors:
 - Denis Knauf
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-07 00:00:00.000000000 Z
+date: 2021-12-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi-libc
-  requirement: &79897400 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.1.1
   type: :runtime
   prerelease: false
-  version_requirements: *79897400
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.1
 - !ruby/object:Gem::Dependency
-  name: shoulda
-  requirement: &79918180 !ruby/object:Gem::Requirement
-    none: false
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *79918180
-- !ruby/object:Gem::Dependency
-  name: yard
-  requirement: &79914220 !ruby/object:Gem::Requirement
-    none: false
+  version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: *79914220
 - !ruby/object:Gem::Dependency
-  name: rdoc
-  requirement: &79910520 !ruby/object:Gem::Requirement
-    none: false
+  name: shoulda
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *79910520
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: &79907200 !ruby/object:Gem::Requirement
-    none: false
+  version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: *79907200
 - !ruby/object:Gem::Dependency
-  name: jeweler
-  requirement: &79905270 !ruby/object:Gem::Requirement
-    none: false
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *79905270
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: simplecov
-  requirement: &79904230 !ruby/object:Gem::Requirement
-    none: false
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *79904230
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Timeout-lib, which interrupts everything, also systemcalls. It uses libc-alarm.
-email: Denis.Knauf@gmail.com
+email:
+- git+timeout-interrupt@denkn.at
 executables: []
 extensions: []
-extra_rdoc_files:
-- LICENSE.txt
-- README.md
+extra_rdoc_files: []
 files:
-- .document
+- ".gitignore"
 - Gemfile
-- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
 - VERSION
 - lib/timeout_interrupt.rb
-- test/helper.rb
-- test/test_ruby-timeout-interrupt.rb
 - timeout-interrupt.gemspec
-homepage: http://github.com/DenisKnauf/ruby-timeout-interrupt
+homepage: https://git.denkn.at/deac/ruby-timeout-interrupt
 licenses:
-- AGPLv3
+- LGPLv3
+metadata:
+  homepage_uri: https://git.denkn.at/deac/ruby-timeout-interrupt
+  source_code_uri: https://git.denkn.at/deac/ruby-timeout-interrupt
+  changelog_uri: https://git.denkn.at/deac/ruby-timeout-interrupt
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
-      segments:
-      - 0
-      hash: -567688307
+      version: 2.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 1.8.11
+rubygems_version: 3.1.2
 signing_key: 
-specification_version: 3
-summary: ! '"Interrupts systemcalls too."'
+specification_version: 4
+summary: '"Interrupts systemcalls too."'
 test_files: []

data/.document

@@ -1,5 +0,0 @@
-lib/**/*.rb
-bin/*
-- 
-features/**/*.feature
-LICENSE.txt

data/Gemfile.lock

@@ -1,50 +0,0 @@
-GEM
-  remote: http://rubygems.org/
-  specs:
-    activesupport (3.2.12)
-      i18n (~> 0.6)
-      multi_json (~> 1.0)
-    bourne (1.1.2)
-      mocha (= 0.10.5)
-    ffi (1.1.0)
-    ffi-libc (0.0.5)
-      ffi (>= 0.6.0, <= 1.1.0)
-    git (1.2.5)
-    i18n (0.6.4)
-    jeweler (1.8.4)
-      bundler (~> 1.0)
-      git (>= 1.2.5)
-      rake
-      rdoc
-    json (1.7.7)
-    metaclass (0.0.1)
-    mocha (0.10.5)
-      metaclass (~> 0.0.1)
-    multi_json (1.6.1)
-    rake (10.0.3)
-    rdoc (4.0.0)
-      json (~> 1.4)
-    shoulda (3.3.2)
-      shoulda-context (~> 1.0.1)
-      shoulda-matchers (~> 1.4.1)
-    shoulda-context (1.0.2)
-    shoulda-matchers (1.4.2)
-      activesupport (>= 3.0.0)
-      bourne (~> 1.1.2)
-    simplecov (0.7.1)
-      multi_json (~> 1.0)
-      simplecov-html (~> 0.7.1)
-    simplecov-html (0.7.1)
-    yard (0.8.5.2)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  bundler
-  ffi-libc
-  jeweler
-  rdoc
-  shoulda
-  simplecov
-  yard

data/test/helper.rb

@@ -1,23 +0,0 @@
-require 'rubygems'
-require 'bundler'
-begin
-  Bundler.setup(:default, :development)
-rescue Bundler::BundlerError => e
-  $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
-  exit e.status_code
-end
-require 'test/unit'
-require 'shoulda'
-
-require 'timeout'
-require 'benchmark'
-require 'ffi/libc'
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-
-require 'timeout_interrupt'
-
-class Test::Unit::TestCase
-end

data/test/test_ruby-timeout-interrupt.rb

@@ -1,155 +0,0 @@
-require 'helper'
-
-class TestRubyTimeoutInterrupt < Test::Unit::TestCase
-	def blocking
-		t = FFI::LibC.fopen '/dev/ptmx', 'r'
-		b = FFI::LibC.malloc 1025
-		s = FFI::LibC.fread b, 1, 1024, t
-	ensure
-		FFI::LibC.fclose t  if t
-		FFI::LibC.free b    if b
-	end
-
-	def assert_no_defined_timeout_yet
-		assert TimeoutInterruptSingleton.timeouts.empty?, "For testing, no timeout should be defined, yet!"
-	end
-
-	def print_timeouts pre
-		puts "#{pre}: < #{TimeoutInterruptSingleton.timeouts.map {|k,(a,_b,_e)| "#{k.inspect}: #{a.strftime '%H:%M:%S'} (#{a-Time.now})" }.join ', '} >"
-	end
-
-	# For testing raising scoped Timeout.
-	class TimeoutError < Exception
-	end
-	# For testing raising scoped TimeoutInterrupt.
-	class TimeoutInterruptError < Exception
-	end
-
-	context "Long really blocking calls" do
-		should "not be interrupted by the old Timeout" do
-			time = Benchmark.realtime do
-				assert_nothing_raised TimeoutError, "Unexpected time out. Your Ruby implementation can time out with old Timeout? You need not TimeoutInterrupt. But it is ok. You can ignore this Error. :)" do
-					assert_raise TimeoutInterruptError, "Ohoh. TimeoutInterrupt should be raised." do
-						TimeoutInterrupt.timeout 5, TimeoutInterruptError do
-							Timeout.timeout 1, TimeoutError do
-								blocking
-								assert false, "Should be unreachable!"
-							end
-						end
-					end
-				end
-			end
-			assert 3 < time, "Did timeout!"
-		end
-
-		should "be interrupted by the new TimeoutInterrupt" do
-			time = Benchmark.realtime do
-				assert_raise TimeoutInterrupt::Error, "It should be timed out, why it did not raise TimeoutInterrupt::Error?" do
-					TimeoutInterrupt.timeout 1 do
-						blocking
-						assert false, "Should be unreachable!"
-					end
-				end
-			end
-			assert 3 > time, "Did not interrupt."
-		end
-	end
-
-	should "interrupt scoped timeout, but not time out the outer timeout" do
-		assert_no_defined_timeout_yet
-		assert_raise TimeoutInterruptError, "It should be timed out, why it did not raise TimeoutInterruptError?" do
-			assert_nothing_raised Timeout::Error, "Oh, outer timeout was timed out. Your machine must be slow, or there is a bug" do
-				TimeoutInterrupt.timeout 10 do
-					TimeoutInterrupt.timeout 1, TimeoutInterruptError do
-						Kernel.sleep 2
-					end
-					assert false, "Should be unreachable!"
-				end
-			end
-		end
-		assert TimeoutInterruptSingleton.timeouts.empty?, "There are timeouts defined, yet!"
-	end
-
-	should "clear timeouts, if not timed out, too." do
-		assert_no_defined_timeout_yet
-		TimeoutInterrupt.timeout(10) {}
-		assert TimeoutInterruptSingleton.timeouts.empty?, "There are timeouts defined, yet!"
-	end
-
-	class CustomException <Exception
-	end
-
-	should "raise custom exception." do
-		assert_raise CustomException, "Custom exceptions do not work." do
-			TimeoutInterrupt.timeout 1, CustomException do
-				sleep 2
-			end
-		end
-	end
-
-	context "A prepared timeout (Proc)" do
-		should "be returned by calling timeout without a block" do
-			assert_no_defined_timeout_yet
-			assert TimeoutInterrupt.timeout(10).kind_of?( Proc), "Did not return a Proc."
-		end
-
-		should "run with once given timeout" do
-			assert_no_defined_timeout_yet
-			to = TimeoutInterrupt.timeout 10
-			called = false
-			to.call { called = true }
-			assert called, "Did not called."
-		end
-
-		should "raise custom exception" do
-			assert_raise CustomException, "Custom exceptions do not work." do
-				prepared = TimeoutInterrupt.timeout 1, CustomException
-				prepared.call { sleep 2 }
-			end
-		end
-
-		should "not be scopeable, without manualy setup after rescue and 2 time outs at once" do
-			prepared = TimeoutInterrupt.timeout 1
-			assert_no_defined_timeout_yet
-			called = false
-			prepared.call do
-				assert_raise TimeoutInterrupt::Error, 'It should time out after one second, but it did not.' do
-					prepared.call { 2; sleep 2 }
-				end
-				called = true
-			end
-			assert called, "It's true, it should be called, also if not expected."
-		end
-
-		should "be scopeable, with manualy setup after rescue, also if 2 time outs at once." do
-			prepared = TimeoutInterrupt.timeout 1
-			assert_no_defined_timeout_yet
-			prepared.call do
-				assert_raise TimeoutInterrupt::Error, 'It should time out after one second, but it did not.' do
-					prepared.call { sleep 2 }
-				end
-				assert_raise TimeoutInterrupt::Error, 'Manualy called timeout setup did not raise.' do
-					TimeoutInterrupt.timeout
-				end
-				assert true, "Should never be reached."
-			end
-		end
-	end
-
-	class IncludeModuleTest
-		include TimeoutInterrupt
-		def please_timeout after
-			timeout after do
-				sleep after+10
-			end
-		end
-	end
-
-	context "Included module" do
-		should "provide timeout too" do
-			assert_raise TimeoutInterrupt::Error, "Included timeout can not be used?" do
-				IncludeModuleTest.new.please_timeout 2
-			end
-		end
-	end
-end