much-timeout 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
---- 
-SHA512: 
-  metadata.gz: 55949c8339e997def24be0b14f3319d93bb1679c887227c8b9f46a7b66c74e21e67181f090fe1b9535d19ffc26dc06387306a300260e05ca60b5af3b8a277bf4
-  data.tar.gz: 279f2401248030112cdcbb8fb4455970057e96b05f5d668b650c708ab889c759787103be4177e33ee0790e64317de66bd3701150be2b6ca8148bec7ba23074eb
-SHA1: 
-  metadata.gz: d18a32435d845e9c073cda374377e8ad266eb822
-  data.tar.gz: a099d9630bd0639f17ce857faf3b87659c1f4876
+---
+SHA256:
+  metadata.gz: 8ccbcba689d4e2e7838a5f1b176b2fab1b40f6cc4aeff5c477ef96b1416b64d3
+  data.tar.gz: 9ee85e10815badc1efbf6223ae3c7486e76a29176b0ce7e64ca05bb0cf31a0c9
+SHA512:
+  metadata.gz: 0a0038b7050f792541d92cb32ab42680b14b745ca4a8fdba540b2a2a393edb7b069f5867d0a58e5a88c670f5a6df681d24d840a7e0c0d39e471322aebe7d5ff7
+  data.tar.gz: f3a9b163d7379b238a3638d7d22ab42e07542405fd7ae2d6e4f27518332146b4111dbc5393c02ccf5c36c73107a276b0d44ffed8105bc8443057e2b39ff4562c

data/Gemfile

@@ -1,5 +1,9 @@
+# frozen_string_literal: true
+
 source "https://rubygems.org"
 
+ruby "~> 2.5"
+
 gemspec
 
-gem 'pry', "~> 0.9.0"
+gem "pry"

data/lib/much-timeout.rb

@@ -1,17 +1,18 @@
-require 'thread'
+# frozen_string_literal: true
+
+require "thread"
 require "much-timeout/version"
 
 module MuchTimeout
+  TimeoutError = Class.new(Interrupt) # rubocop:disable Lint/InheritException
 
-  TimeoutError = Class.new(Interrupt)
-
-  PIPE_SIGNAL = '.'
+  PIPE_SIGNAL = "."
 
   def self.timeout(seconds, klass = nil, &block)
     if seconds.nil?
-      raise ArgumentError, 'please specify a non-nil seconds value'
+      raise ArgumentError, "please specify a non-nil seconds value"
     end
-    if !seconds.kind_of?(::Numeric)
+    unless seconds.is_a?(::Numeric)
       raise ArgumentError, "please specify a numeric seconds value " \
                            "(`#{seconds.inspect}` was given)"
     end
@@ -21,25 +22,37 @@ module MuchTimeout
     begin
       main_thread = Thread.current
       io_select_thread ||= Thread.new do
-        if !::IO.select([reader], nil, nil, seconds)
+        unless ::IO.select([reader], nil, nil, seconds)
           main_thread.raise exception_klass
         end
       end
       begin
         block.call
       ensure
-        writer.write_nonblock(PIPE_SIGNAL) rescue false
+        begin
+          writer.write_nonblock(PIPE_SIGNAL)
+        rescue
+          false
+        end
         io_select_thread.join
       end
     ensure
-      reader.close rescue false
-      writer.close rescue false
+      begin
+        reader.close
+      rescue
+        false
+      end
+      begin
+        writer.close
+      rescue
+        false
+      end
     end
   end
 
   def self.optional_timeout(seconds, klass = nil, &block)
     if !seconds.nil?
-      self.timeout(seconds, klass, &block)
+      timeout(seconds, klass, &block)
     else
       block.call
     end
@@ -48,39 +61,38 @@ module MuchTimeout
   def self.just_timeout(seconds, args)
     args ||= {}
     if args[:do].nil?
-      raise ArgumentError, 'you need to specify a :do block arg to call'
+      raise ArgumentError, "you need to specify a :do block arg to call"
     end
-    if !args[:do].kind_of?(::Proc)
+    unless args[:do].is_a?(::Proc)
       raise ArgumentError, "you need pass a Proc as the :do arg " \
                            "(`#{args[:do].inspect}` was given)"
     end
-    if !args[:on_timeout].nil? && !args[:on_timeout].kind_of?(::Proc)
+    if !args[:on_timeout].nil? && !args[:on_timeout].is_a?(::Proc)
       raise ArgumentError, "you need pass a Proc as the :on_timeout arg " \
                            "(`#{args[:on_timeout].inspect}` was given)"
     end
 
     begin
-      self.timeout(seconds, &args[:do])
+      timeout(seconds, &args[:do])
     rescue TimeoutError
-      (args[:on_timeout] || proc{ }).call
+      (args[:on_timeout] || proc{}).call
     end
   end
 
   def self.just_optional_timeout(seconds, args)
     args ||= {}
     if args[:do].nil?
-      raise ArgumentError, 'you need to specify a :do block arg to call'
+      raise ArgumentError, "you need to specify a :do block arg to call"
     end
-    if !args[:do].kind_of?(::Proc)
+    unless args[:do].is_a?(::Proc)
       raise ArgumentError, "you need pass a Proc as the :do arg " \
                            "(`#{args[:do].inspect}` was given)"
     end
 
     if !seconds.nil?
-      self.just_timeout(seconds, args)
+      just_timeout(seconds, args)
     else
       args[:do].call
     end
   end
-
 end

data/lib/much-timeout/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module MuchTimeout
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/much-timeout.gemspec

@@ -1,23 +1,32 @@
 # -*- encoding: utf-8 -*-
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "much-timeout/version"
 
 Gem::Specification.new do |gem|
-  gem.name        = "much-timeout"
-  gem.version     = MuchTimeout::VERSION
-  gem.authors     = ["Kelly Redding", "Collin Redding"]
-  gem.email       = ["kelly@kellyredding.com", "collin.redding@me.com"]
-  gem.summary     = "IO.select based timeouts; an alternative to Ruby's stdlib Timeout module."
-  gem.description = "IO.select based timeouts; an alternative to Ruby's stdlib Timeout module."
-  gem.homepage    = "http://github.com/redding/much-timeout"
-  gem.license     = 'MIT'
-
-  gem.files         = `git ls-files`.split($/)
+  gem.name    = "much-timeout"
+  gem.version = MuchTimeout::VERSION
+  gem.authors = ["Kelly Redding", "Collin Redding"]
+  gem.email   = ["kelly@kellyredding.com", "collin.redding@me.com"]
+
+  gem.summary =
+    "IO.select based timeouts; an alternative to Ruby's stdlib Timeout module."
+  gem.description =
+    "IO.select based timeouts; an alternative to Ruby's stdlib Timeout module."
+
+  gem.homepage = "http://github.com/redding/much-timeout"
+  gem.license  = "MIT"
+
+  gem.files = `git ls-files | grep "^[^.]"`.split($INPUT_RECORD_SEPARATOR)
+
   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"]
 
-  gem.add_development_dependency("assert", ["~> 2.16.1"])
+  gem.required_ruby_version = "~> 2.5"
 
+  gem.add_development_dependency("much-style-guide", ["~> 0.6.0"])
+  gem.add_development_dependency("assert",           ["~> 2.19.3"])
 end

data/test/helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # this file is automatically required when you run `assert`
 # put any test helpers here
 
@@ -5,14 +7,14 @@
 $LOAD_PATH.unshift(File.expand_path("../..", __FILE__))
 
 # require pry for debugging (`binding.pry`)
-require 'pry'
+require "pry"
 
-require 'test/support/factory'
+require "test/support/factory"
 
 # 1.8.7 backfills
 
 # Array#sample
-if !(a = Array.new).respond_to?(:sample) && a.respond_to?(:choice)
+if !(a = []).respond_to?(:sample) && a.respond_to?(:choice)
   class Array
     alias_method :sample, :choice
   end

data/test/support/factory.rb

@@ -1,6 +1,7 @@
-require 'assert/factory'
+# frozen_string_literal: true
+
+require "assert/factory"
 
 module Factory
   extend Assert::Factory
-
 end

data/test/unit/much-timeout_tests.rb

@@ -1,8 +1,9 @@
-require 'assert'
-require 'much-timeout'
+# frozen_string_literal: true
 
-module MuchTimeout
+require "assert"
+require "much-timeout"
 
+module MuchTimeout
   class UnitTests < Assert::Context
     desc "MuchTimeout"
     setup do
@@ -18,9 +19,8 @@ module MuchTimeout
     end
 
     should "know its pipe signal" do
-      assert_equal '.', subject::PIPE_SIGNAL
+      assert_equal ".", subject::PIPE_SIGNAL
     end
-
   end
 
   class TimeoutSetupTests < UnitTests
@@ -34,7 +34,6 @@ module MuchTimeout
     teardown do
       @cond_var.broadcast
     end
-
   end
 
   class TimeoutTests < TimeoutSetupTests
@@ -48,7 +47,8 @@ module MuchTimeout
       end
     end
 
-    should "interrupt and raise if a custom exception is given and block times out" do
+    should "interrupt and raise if a custom exception is given and block "\
+           "times out" do
       assert_raises(@exception) do
         subject.timeout(@seconds, @exception) do
           @mutex.synchronize{ @cond_var.wait(@mutex) }
@@ -56,7 +56,8 @@ module MuchTimeout
       end
     end
 
-    should "not interrupt and return the block's return value if there is no timeout" do
+    should "not interrupt and return the block's return value if there "\
+           "is no timeout" do
       val = nil
       assert_nothing_raised do
         val = subject.timeout(@seconds){ @return_val }
@@ -72,16 +73,15 @@ module MuchTimeout
 
     should "complain if given a nil seconds value" do
       assert_raises(ArgumentError) do
-        subject.timeout(nil){ }
+        subject.timeout(nil){}
       end
     end
 
     should "complain if given a non-numeric seconds value" do
       assert_raises(ArgumentError) do
-        subject.timeout(Factory.string){ }
+        subject.timeout(Factory.string){}
       end
     end
-
   end
 
   class OptionalTimeoutTests < TimeoutSetupTests
@@ -113,14 +113,18 @@ module MuchTimeout
       end
 
       assert_raises(ArgumentError) do
-        subject.optional_timeout(Factory.string){ }
+        subject.optional_timeout(Factory.string){}
       end
     end
 
     should "call the given block directly if seconds is nil" do
       val = nil
       assert_nothing_raised do
-        val = subject.optional_timeout(nil){ sleep @seconds; @return_val }
+        val =
+          subject.optional_timeout(nil) do
+            sleep @seconds
+            @return_val
+          end
       end
       assert_equal @return_val, val
 
@@ -128,7 +132,6 @@ module MuchTimeout
         subject.optional_timeout(nil){ raise @exception }
       end
     end
-
   end
 
   class JustTimeoutTests < TimeoutSetupTests
@@ -141,29 +144,29 @@ module MuchTimeout
       # this repeats the relevent tests from the TimeoutTests above
 
       assert_nothing_raised do
-        subject.just_timeout(@seconds, :do => proc{
+        subject.just_timeout(@seconds, do: proc{
           @mutex.synchronize{ @cond_var.wait(@mutex) }
           @val_set = Factory.string
-        })
+        },)
       end
       assert_nil @val_set
 
       val = nil
       assert_nothing_raised do
-        val = subject.just_timeout(@seconds, :do => proc{ @return_val })
+        val = subject.just_timeout(@seconds, do: proc{ @return_val })
       end
       assert_equal @return_val, val
 
       assert_raises(@exception) do
-        subject.just_timeout(@seconds, :do => proc{ raise @exception })
+        subject.just_timeout(@seconds, do: proc{ raise @exception })
       end
 
       assert_raises(ArgumentError) do
-        subject.just_timeout(nil, :do => proc{ })
+        subject.just_timeout(nil, do: proc{})
       end
 
       assert_raises(ArgumentError) do
-        subject.just_timeout(Factory.string, :do => proc{ })
+        subject.just_timeout(Factory.string, do: proc{})
       end
     end
 
@@ -171,20 +174,20 @@ module MuchTimeout
       exp = Factory.string
       assert_nothing_raised do
         subject.just_timeout(@seconds, {
-          :do => proc{
+          do: proc{
             @mutex.synchronize{ @cond_var.wait(@mutex) }
           },
-          :on_timeout => proc{ @val_set = exp }
-        })
+          on_timeout: proc{ @val_set = exp },
+        },)
       end
       assert_equal exp, @val_set
 
       @val_set = val = nil
       assert_nothing_raised do
         val = subject.just_timeout(@seconds, {
-          :do         => proc{ @return_val },
-          :on_timeout => proc{ @val_set = exp }
-        })
+          do: proc{ @return_val },
+          on_timeout: proc{ @val_set = exp },
+        },)
       end
       assert_equal @return_val, val
       assert_nil @val_set
@@ -192,28 +195,27 @@ module MuchTimeout
 
     should "complain if not given a :do arg" do
       assert_raises(ArgumentError) do
-        subject.just_timeout(@seconds){ }
+        subject.just_timeout(@seconds){}
       end
       assert_raises(ArgumentError) do
-        subject.just_timeout(@seconds, :do => nil)
+        subject.just_timeout(@seconds, do: nil)
       end
     end
 
     should "complain if given a non-proc :do arg" do
       assert_raises(ArgumentError) do
-        subject.just_timeout(@seconds, :do => Factory.string)
+        subject.just_timeout(@seconds, do: Factory.string)
       end
     end
 
     should "complain if given a non-proc :on_timeout arg" do
       assert_raises(ArgumentError) do
         subject.just_timeout(@seconds, {
-          :do         => proc{ },
-          :on_timeout => Factory.string
-        })
+          do: proc{},
+          on_timeout: Factory.string,
+        },)
       end
     end
-
   end
 
   class JustOptionalTimeoutTests < TimeoutSetupTests
@@ -226,97 +228,99 @@ module MuchTimeout
       # this repeats the relevent tests from the JustTimeoutTests above
 
       assert_nothing_raised do
-        subject.just_optional_timeout(@seconds, :do => proc{
+        subject.just_optional_timeout(@seconds, do: proc{
           @mutex.synchronize{ @cond_var.wait(@mutex) }
           @val_set = Factory.string
-        })
+        },)
       end
       assert_nil @val_set
 
       val = nil
       assert_nothing_raised do
-        val = subject.just_optional_timeout(@seconds, :do => proc{ @return_val })
+        val =
+          subject.just_optional_timeout(@seconds, do: proc{ @return_val })
       end
       assert_equal @return_val, val
 
       assert_raises(@exception) do
-        subject.just_optional_timeout(@seconds, :do => proc{ raise @exception })
+        subject.just_optional_timeout(@seconds, do: proc{ raise @exception })
       end
 
       assert_raises(ArgumentError) do
-        subject.just_optional_timeout(Factory.string, :do => proc{ })
+        subject.just_optional_timeout(Factory.string, do: proc{})
       end
 
       exp = Factory.string
       assert_nothing_raised do
         subject.just_optional_timeout(@seconds, {
-          :do => proc{
+          do: proc{
             @mutex.synchronize{ @cond_var.wait(@mutex) }
           },
-          :on_timeout => proc{ @val_set = exp }
-        })
+          on_timeout: proc{ @val_set = exp },
+        },)
       end
       assert_equal exp, @val_set
 
       @val_set = val = nil
       assert_nothing_raised do
         val = subject.just_optional_timeout(@seconds, {
-          :do         => proc{ @return_val },
-          :on_timeout => proc{ @val_set = exp }
-        })
+          do: proc{ @return_val },
+          on_timeout: proc{ @val_set = exp },
+        },)
       end
       assert_equal @return_val, val
       assert_nil @val_set
 
       assert_raises(ArgumentError) do
-        subject.just_optional_timeout(@seconds){ }
+        subject.just_optional_timeout(@seconds){}
       end
       assert_raises(ArgumentError) do
-        subject.just_optional_timeout(@seconds, :do => nil)
+        subject.just_optional_timeout(@seconds, do: nil)
       end
 
       assert_raises(ArgumentError) do
-        subject.just_optional_timeout(@seconds, :do => Factory.string)
+        subject.just_optional_timeout(@seconds, do: Factory.string)
       end
 
       assert_raises(ArgumentError) do
         subject.just_optional_timeout(@seconds, {
-          :do         => proc{ },
-          :on_timeout => Factory.string
-        })
+          do: proc{},
+          on_timeout: Factory.string,
+        },)
       end
     end
 
     should "call the given :do arg directly if seconds is nil" do
       val = nil
       assert_nothing_raised do
-        val = subject.just_optional_timeout(nil, :do => proc{
+        val = subject.just_optional_timeout(nil, do: proc{
           sleep @seconds
           @return_val
-        })
+        },)
       end
       assert_equal @return_val, val
 
       assert_raises(@exception) do
-        subject.just_optional_timeout(nil, :do => proc{ raise @exception })
+        subject.just_optional_timeout(nil, do: proc{ raise @exception })
       end
     end
 
     should "complain if not given a :do arg" do
       assert_raises(ArgumentError) do
-        subject.just_optional_timeout([@seconds, nil].sample){ }
+        subject.just_optional_timeout([@seconds, nil].sample){}
       end
       assert_raises(ArgumentError) do
-        subject.just_optional_timeout([@seconds, nil].sample, :do => nil)
+        subject.just_optional_timeout([@seconds, nil].sample, do: nil)
       end
     end
 
     should "complain if given a non-proc :do arg" do
       assert_raises(ArgumentError) do
-        subject.just_optional_timeout([@seconds, nil].sample, :do => Factory.string)
+        subject.just_optional_timeout(
+          [@seconds, nil].sample,
+          do: Factory.string,
+        )
       end
     end
-
   end
-
 end

metadata

@@ -1,39 +1,52 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: much-timeout
-version: !ruby/object:Gem::Version 
-  version: 0.1.1
+version: !ruby/object:Gem::Version
+  version: 0.1.2
 platform: ruby
-authors: 
+authors:
 - Kelly Redding
 - Collin Redding
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2016-06-22 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: assert
+date: 2021-01-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: much-style-guide
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :development
   prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        version: 2.16.1
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+- !ruby/object:Gem::Dependency
+  name: assert
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.19.3
   type: :development
-  version_requirements: *id001
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.19.3
 description: IO.select based timeouts; an alternative to Ruby's stdlib Timeout module.
-email: 
+email:
 - kelly@kellyredding.com
 - collin.redding@me.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-- .gitignore
+files:
 - Gemfile
 - LICENSE
 - README.md
@@ -43,35 +56,34 @@ files:
 - much-timeout.gemspec
 - test/helper.rb
 - test/support/factory.rb
+- test/system/.keep
 - test/unit/much-timeout_tests.rb
 - tmp/.gitkeep
 homepage: http://github.com/redding/much-timeout
-licenses: 
+licenses:
 - MIT
 metadata: {}
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - &id002 
-    - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - *id002
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-rubyforge_project: 
-rubygems_version: 2.6.4
+rubygems_version: 3.2.4
 signing_key: 
 specification_version: 4
 summary: IO.select based timeouts; an alternative to Ruby's stdlib Timeout module.
-test_files: 
+test_files:
 - test/helper.rb
 - test/support/factory.rb
+- test/system/.keep
 - test/unit/much-timeout_tests.rb

data/.gitignore

@@ -1,19 +0,0 @@
-*.gem
-*.log
-*.rbc
-.rbx/
-.bundle
-.config
-.yardoc
-Gemfile.lock
-InstalledFiles
-_yardoc
-coverage
-doc/
-lib/bundler/man
-pkg
-rdoc
-spec/reports
-test/tmp
-test/version_tmp
-tmp