sane_timeout 0.1

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 John Joseph Bachir
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/sane_timeout.rb

@@ -0,0 +1,110 @@
+# Timeout long-running blocks
+#
+# == Synopsis
+#
+#   require 'timeout'
+#   status = Timeout::timeout(5) {
+#     # Something that should be interrupted if it takes more than 5 seconds...
+#   }
+#
+# == Description
+#
+# Timeout provides a way to auto-terminate a potentially long-running
+# operation if it hasn't finished in a fixed amount of time.
+#
+# Previous versions didn't use a module for namespacing, however
+# #timeout is provided for backwards compatibility.  You
+# should prefer Timeout#timeout instead.
+#
+# == Copyright
+#
+# Copyright:: (C) 2000  Network Applied Communication Laboratory, Inc.
+# Copyright:: (C) 2000  Information-technology Promotion Agency, Japan
+
+module Timeout
+  # Raised by Timeout#timeout when the block times out.
+  class Error < RuntimeError
+  end
+  class ExitException < ::Exception # :nodoc:
+  end
+
+  # :stopdoc:
+  THIS_FILE = /\A#{Regexp.quote(__FILE__)}:/o
+  CALLER_OFFSET = ((c = caller[0]) && THIS_FILE =~ c) ? 1 : 0
+  # :startdoc:
+
+  # Perform an operation in a block, timing it out if it takes longer
+  # than +sec+ seconds to complete.
+  #
+  # +sec+:: Number of seconds to wait for the block to terminate. Any number
+  #         may be used, including Floats to specify fractional seconds.
+  # +klass+:: Exception Class to raise if the block fails to terminate
+  #           in +sec+ seconds.  Omitting will use the default, Timeout::Error
+  #
+  # The block will be executed on another thread and will be given one
+  # argument: +sec+.
+  #
+  # Returns the result of the block *if* the block completed before
+  # +sec+ seconds, otherwise throws an exception, based on the value of +klass+.
+  #
+  # Note that this is both a method of module Timeout, so you can <tt>include
+  # Timeout</tt> into your classes so they have a #timeout method, as well as
+  # a module method, so you can call it directly as Timeout.timeout().
+  def timeout(sec, klass = nil)   #:yield: +sec+
+    return yield(sec) if sec == nil or sec.zero?
+    exception = klass || Class.new(ExitException)
+    begin
+      begin
+        current_thread = Thread.current
+
+        x = Thread.start{ yield(sec) }
+
+        y = Thread.start {
+          begin
+            sleep sec
+          rescue => e
+            x.raise e
+          else
+            x.kill
+            # x.join
+            current_thread.raise exception, "execution expired"
+          end
+        }
+
+        x.value
+      ensure
+        if y
+          y.kill
+          y.join # make sure y is dead.
+        end
+      end
+    rescue exception => e
+      rej = /\A#{Regexp.quote(__FILE__)}:#{__LINE__-4}\z/o
+      (bt = e.backtrace).reject! {|m| rej =~ m}
+      level = -caller(CALLER_OFFSET).size
+      while THIS_FILE =~ bt[level]
+        bt.delete_at(level)
+        level += 1
+      end
+      raise if klass            # if exception class is specified, it
+                                # would be expected outside.
+      raise Error, e.message, e.backtrace
+    end
+  end
+
+  module_function :timeout
+end
+
+# Identical to:
+#
+#   Timeout::timeout(n, e, &block).
+#
+# This method is deprecated and provided only for backwards compatibility.
+# You should use Timeout#timeout instead.
+def timeout(n, e = nil, &block)
+  Timeout::timeout(n, e, &block)
+end
+
+# Another name for Timeout::Error, defined for backwards compatibility with
+# earlier versions of timeout.rb.
+TimeoutError = Timeout::Error

data/readme.md

@@ -0,0 +1,46 @@
+# SaneTimeout
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'sane_timeout'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sane_timeout
+
+## Usage
+
+TODO: Write usage instructions here
+
+
+
+## Open Questions
+* on line 69, I had tried doing x.join based on the standard lib doing the
+same thing with the y thread. I assumed that kill is not synchromous so it's
+necessary to wait for x to die. However, doing this causes many things to break.
+I haven't been able to figure out why.
+* related, is there any reason to kill y before returning x.value?
+
+## To Do
+* determine best way to install sane_timeout so that it
+  replaces Timeout. possibly offer to modes, one where
+  Timeout is overwritten, another where sane_timeout is
+  invoked in its own namespace (SaneTimeout)
+
+## Project Improvement
+* better name?
+* There is redundant code between test_timeout.rb and test_sane_timeout.rb
+because I wanted to annotate in the former and be DRY in the latter. Maybe this
+can somehow be improved.
+
+## odd design choice in standard lib:
+* same type of error is raised inside thread and outside when specified
+* when not specified, Exception is raised inside, StandardError is raised outside

data/sane_timeout.gemspec

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |gem|
+  gem.name          = "sane_timeout"
+  gem.version       = '0.1'
+  gem.authors       = ["John Joseph Bachir"]
+  gem.email         = ["john@ganxy.com"]
+  gem.description   = %q{Sane Timeout fixes Ruby standard lib Timeout}
+  gem.summary   = %q{Sane Timeout fixes Ruby standard lib Timeout}
+  gem.homepage      = "https://github.com/jjb/sane_timeout"
+
+  gem.files         = `git ls-files`.split($/)
+  # gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

data/test/test_sane_timeout.rb

@@ -0,0 +1,136 @@
+require 'test/unit'
+require '../sane-timeout'
+require 'thread'
+
+class TestTimeout < Test::Unit::TestCase
+
+  ### Tests that come with standard lib
+  def test_queue
+    q = Queue.new
+    assert_raise(Timeout::Error, "[ruby-dev:32935]") {
+      timeout(0.1) { q.pop }
+    }
+  end
+
+  def test_timeout
+    @flag = true
+    Thread.start {
+      sleep 0.1
+      @flag = false
+    }
+    assert_nothing_raised("[ruby-dev:38319]") do
+      Timeout.timeout(1) {
+        nil while @flag
+      }
+    end
+    assert !@flag, "[ruby-dev:38319]"
+  end
+
+  def test_cannot_convert_into_time_interval
+    bug3168 = '[ruby-dev:41010]'
+    def (n = Object.new).zero?; false; end
+    assert_raise(TypeError, bug3168) {Timeout.timeout(n) { sleep 0.1 }}
+  end
+
+
+
+  ### tests not included in standard lib, but which standard lib does pass
+
+  def test_non_timing_out_code_is_successful
+    assert_nothing_raised do
+      Timeout.timeout(2) {
+        true
+      }
+    end
+  end
+
+  def test_code_that_takes_too_long_is_stopped_and_raises
+    assert_raise(Timeout::Error) do
+      Timeout.timeout(0.1) {
+        sleep 10
+      }
+    end
+  end
+
+  def test_returns_block_value_when_not_timing_out
+    retval = Timeout.timeout(1){ "foobar" }
+    assert_equal "foobar", retval
+  end
+
+
+  ### Tests that sane_timeout passes
+
+  def subject(throws, catches)
+    $inner_attempted=nil
+    $inner_succeeded=nil
+    $caught_in_inner=nil
+
+    $raised_in_outer=nil
+    $not_raised_in_outer=nil
+    begin
+      Timeout.timeout(0.1, throws){
+        begin
+          $inner_attempted=true
+          sleep 10
+        rescue catches
+          $caught_in_inner=true
+        else
+          $inner_succeeded=true
+        end
+      }
+    rescue Exception
+      $raised_in_outer = true
+    else
+      $not_raised_in_outer = true
+    end
+  end
+
+  def expectations
+    assert $inner_attempted,  "Inner was not attempted"
+    assert !$inner_succeeded, "Inner did not succeed"
+    assert !$caught_in_inner, "Exception was caught in inner"
+    assert $raised_in_outer,  "Exception was not raised in outer"
+    assert !$not_raised_in_outer, "Exception was not raised in outer(2)"
+  end
+
+  puts "when an exception to raise is not specified and the inner code does not catch Exception"
+  def test_1
+    subject(nil, StandardError)
+    expectations
+  end
+
+  puts "when an exception to raise is not specified and the inner code does catch Exception"
+  def test_2
+    subject(nil, Exception)
+    expectations
+  end
+
+  puts "when an exception to raise is StandardError and the inner code does not catch Exception"
+  class MyError < StandardError; end
+  def test_3
+    subject(MyError, StandardError)
+    expectations
+  end
+
+  puts "when an exception to raise is StandardError and the inner code does catch Exception"
+  class MyError2 < StandardError; end
+  def test_4
+    subject(MyError2, Exception)
+    expectations
+  end
+
+  puts "when an exception to raise is Exception and the inner code does not catch Exception"
+  class MyError3 < Exception; end
+  def test_5
+    subject(MyError3, StandardError)
+    expectations
+  end
+
+  puts "when an exception to raise is Exception and the inner code does catch Exception"
+  class MyError4 < Exception; end
+  def test_6
+    subject(MyError4, Exception)
+    expectations
+  end
+
+end

data/test/test_timeout.rb

@@ -0,0 +1,177 @@
+require 'test/unit'
+require 'timeout'
+require 'thread'
+
+class TestTimeout < Test::Unit::TestCase
+
+  ### Tests that come with standard lib
+
+  def test_queue
+    q = Queue.new
+    assert_raise(Timeout::Error, "[ruby-dev:32935]") {
+      timeout(0.1) { q.pop }
+    }
+  end
+
+  def test_timeout
+    @flag = true
+    Thread.start {
+      sleep 0.1
+      @flag = false
+    }
+    assert_nothing_raised("[ruby-dev:38319]") do
+      Timeout.timeout(1) {
+        nil while @flag
+      }
+    end
+    assert !@flag, "[ruby-dev:38319]"
+  end
+
+  def test_cannot_convert_into_time_interval
+    bug3168 = '[ruby-dev:41010]'
+    def (n = Object.new).zero?; false; end
+    assert_raise(TypeError, bug3168) {Timeout.timeout(n) { sleep 0.1 }}
+  end
+
+
+  ### tests not included in standard lib, but which standard lib does pass
+
+  def test_non_timing_out_code_is_successful
+    assert_nothing_raised do
+      Timeout.timeout(2) {
+        true
+      }
+    end
+  end
+
+  def test_code_that_takes_too_long_is_stopped_and_raises
+    assert_raise(Timeout::Error) do
+      Timeout.timeout(0.1) {
+        sleep 10
+      }
+    end
+  end
+
+  def test_returns_block_value_when_not_timing_out
+    retval = Timeout.timeout(1){ "foobar" }
+    assert_equal "foobar", retval
+  end
+
+
+  ### Tests demonstrating problems with standard lib
+  # NOTE: this demonstration was done such that all of the assertions pass,
+  #       The ones marked weird, bad, and very bad should not, and their
+  #       passing is demonstrating the brokenness.
+
+  def subject(throws, catches)
+    $inner_attempted=nil
+    $inner_succeeded=nil
+    $caught_in_inner=nil
+
+    $raised_in_outer=nil
+    $not_raised_in_outer=nil
+    begin
+      Timeout.timeout(0.1, throws){
+        begin
+          $inner_attempted=true
+          sleep 10
+        rescue catches
+          $caught_in_inner=true
+        else
+          $inner_succeeded=true
+        end
+      }
+    rescue Exception
+      $raised_in_outer = true
+    else
+      $not_raised_in_outer = true
+    end
+  end
+
+  puts "when an exception to raise is not specified and the inner code does not catch Exception"
+  def test_1
+    subject(nil, StandardError)
+
+    # EXPECTED
+    assert $inner_attempted
+    assert !$inner_succeeded
+    assert !$caught_in_inner
+    assert $raised_in_outer && !$not_raised_in_outer
+  end
+
+  puts "when an exception to raise is not specified and the inner code does catch Exception"
+  def test_2
+    subject(nil, Exception)
+
+    # EXPECTED
+    assert $inner_attempted
+    assert !$inner_succeeded
+
+    # WEIRD
+    assert $caught_in_inner
+
+    # BAD
+    assert !$raised_in_outer && $not_raised_in_outer
+  end
+
+  puts "when an exception to raise is StandardError and the inner code does not catch Exception"
+  class MyError < StandardError; end
+  def test_3
+    subject(MyError, StandardError)
+
+    # EXPECTED
+    assert $inner_attempted
+    assert !$inner_succeeded
+
+    # WEIRD
+    assert $caught_in_inner
+
+    # BAD
+    assert !$raised_in_outer && $not_raised_in_outer
+  end
+
+  puts "when an exception to raise is StandardError and the inner code does catch Exception"
+  class MyError2 < StandardError; end
+  def test_4
+    subject(MyError2, Exception)
+
+    # EXPECTED
+    assert $inner_attempted
+    assert !$inner_succeeded
+
+    # WEIRD
+    assert $caught_in_inner
+
+    # BAD
+    assert !$raised_in_outer && $not_raised_in_outer
+  end
+
+  puts "when an exception to raise is Exception and the inner code does not catch Exception"
+  class MyError3 < Exception; end
+  def test_5
+    subject(MyError3, StandardError)
+
+    # EXPECTED
+    assert $inner_attempted
+    assert !$inner_succeeded
+    assert !$caught_in_inner
+    assert $raised_in_outer && !$not_raised_in_outer
+  end
+
+  puts "when an exception to raise is Exception and the inner code does catch Exception"
+  class MyError4 < Exception; end
+  def test_6
+    subject(MyError4, Exception)
+
+    # EXPECTED
+    assert $inner_attempted
+    assert !$inner_succeeded
+
+    # WEIRD
+    assert $caught_in_inner
+
+    # VERY BAD
+    assert !$raised_in_outer && $not_raised_in_outer
+  end
+
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: sane_timeout
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  prerelease: 
+platform: ruby
+authors:
+- John Joseph Bachir
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-15 00:00:00.000000000 Z
+dependencies: []
+description: Sane Timeout fixes Ruby standard lib Timeout
+email:
+- john@ganxy.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- Rakefile
+- lib/sane_timeout.rb
+- readme.md
+- sane_timeout.gemspec
+- test/test_sane_timeout.rb
+- test/test_timeout.rb
+homepage: https://github.com/jjb/sane_timeout
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Sane Timeout fixes Ruby standard lib Timeout
+test_files:
+- test/test_sane_timeout.rb
+- test/test_timeout.rb
+has_rdoc: