trick_bag 0.59 → 0.62.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 80de6b95f6465d84976cfff65217064adab423c6
-  data.tar.gz: 6a91c5d2a35c666f85de817f64d78587978ace2a
+  metadata.gz: e7febbc99a5bd373e0964dd23b7cc4b4dd8482b7
+  data.tar.gz: 8c0ea6ac86a0dff90774250edc1143b0af5a6d19
 SHA512:
-  metadata.gz: df097a1226f5ba6a5bdcaaf2200050fd8450e7a3cafdcd0827b6766ac15a8bfc5ef4f724b525c6d191891e0a272818348cabbee4a3ae27ed05e018e1f44eb493
-  data.tar.gz: 6f25b512ee5485ee8a7e78c089764420f29519d4abcb6a1fd2fa6faa1c3cde512f7018b4f3cd26589a3e75da057a65be5a04bb2d5457e75e5bf50a065ed8bd10
+  metadata.gz: d86943b5df0ab4289411f2c641cd9670d44c907502ce68432e2e79987a81989930678ad59423127897777352d243b4cebef19fe979c16897b59f6f608144583e
+  data.tar.gz: 7aa3678b4694537560c327bab79f8f8d4279c97bae890cbeb42b23231ffda852e5ce3e339c516223fcae63ea7e5280edc73ff7b112f0b9edbe5c49e7da908a03

data/RELEASE_NOTES.md

@@ -1,3 +1,18 @@
+## v0.62.0
+
+* Added Timing.try_with_timeout.
+
+## v0.61.0
+
+* Added Timing::Elapser.
+
+
+## v0.60
+
+* CollectionAccess methods now support an array of keys/subscripts instead of
+  a string.
+
+
 ## v0.59
 
 * Timing.retry_until_true_or_timeout now optionally takes a code block instead of a lambda.

data/lib/trick_bag/collections/collection_access.rb

@@ -19,37 +19,41 @@ module CollectionAccess
   #
   # Error occurred processing key [x.1] in [x.1.2]: undefined method `[]' for nil:NilClass
   #
-  # @param the collection to access
-  # @param key_string the string representing the keys to use
-  # @separator the string to use to separate the
-  def access(collection, key_string, separator = '.')
+  # @param collection the collection to access
+  # @param key_string_or_array the string or array representing the keys to use
+  # @param separator the string to use to separate the keys, defaults to '.'
+  def access(collection, key_string_or_array, separator = '.')
 
-    is_number_string = ->(s) do
+    to_integer = ->(object) do
       begin
-        Integer(s)
-        true
+        Integer(object)
       rescue
-        false
+        raise "Key is not a number string: #{object}"
       end
     end
 
-    keys = key_string.split(separator)
+    get_key_array = -> do
+      case key_string_or_array
+        when Array
+          key_string_or_array
+        when String
+          key_string_or_array.split(separator)
+        else
+          raise "Invalid data type: #{key_string_or_array.class}"
+      end
+    end
+
+    keys = get_key_array.()
     return_object = collection
 
     keys.each_with_index do |key, index|
-
-      if return_object.kind_of?(Array)
-        unless is_number_string.(key)
-          raise "Key is not a number string: #{key}"
-        end
-        key = key.to_i
-      end
+      key = to_integer.(key) if return_object.kind_of?(Array)
 
       begin
         return_object = return_object[key]
       rescue => e
         this_key = keys[0..index].join(separator)
-        raise "Error occurred processing key [#{this_key}] in [#{key_string}]: #{e}"
+        raise "Error occurred processing key [#{this_key}] in [#{key_string_or_array}]: #{e}"
       end
     end
     return_object
@@ -69,7 +73,10 @@ module CollectionAccess
   # or
   # accessor.('h.1')    # => 'b'
   def accessor(collection, separator = '.')
-    ->(key_string) { access(collection, key_string, separator) }
+    ->(*args) do
+      key_string = (args.size == 1) ? args.first : args.map(&:to_s).join(separator)
+      access(collection, key_string, separator)
+    end
   end
 
 end

data/lib/trick_bag/timing/elapser.rb

@@ -0,0 +1,67 @@
+module TrickBag
+module Timing
+
+
+# Very simple class that enables you to specify an elapsed time in
+# either seconds or by the time itself.
+class Elapser
+
+  attr_reader :seconds, :end_time
+  attr_accessor :never_elapse
+
+  def self.never_elapser
+    @never_elapser ||= begin
+       instance = new(0)
+       instance.never_elapse = true
+       instance
+    end
+  end
+
+
+  # Can be used to create an instance or return the passed instance (see test for example).
+  def self.from(object)
+    case object
+      when :never
+        never_elapser
+      when self
+        object
+      else
+        new(object)
+    end
+  end
+
+
+  # Create the instance with the passed parameter.  If it's a Time instance,
+  # it is assumed to be the end time at which elapsed? should return true.
+  # If it's a number, it's assumed to be a number of seconds after which
+  # elapsed? should return true.
+  def initialize(seconds_or_end_time)
+    case seconds_or_end_time
+      when Time
+        @end_time = seconds_or_end_time
+        @seconds = @end_time - Time.now
+      when ::Numeric
+        @seconds = seconds_or_end_time
+        @end_time = Time.now + @seconds
+      else
+        raise ArgumentError.new("Invalid parameter class: #{seconds_or_end_time.class}, object: #{seconds_or_end_time}")
+    end
+  end
+
+  def elapsed?
+    never_elapse ? false : Time.now >= @end_time
+  end
+
+
+  def hash
+    Integer(@seconds - @end_time.to_i)
+  end
+
+
+  def ==(other)
+    other.class == self.class && other.seconds == self.seconds && other.end_time == self.end_time
+  end
+end
+
+end
+end

data/lib/trick_bag/timing/timing.rb

@@ -90,5 +90,31 @@ module Timing
     return_value
   end
 
+
+  # Runs the passed block in a new thread, ensuring that its execution time
+  # does not exceed the specified duration.
+  #
+  # @param max_seconds maximum number of seconds to wait for completion
+  # @param check_interval_in_secs interval in seconds at which to check for completion
+  # @block block of code to execute in the secondary thread
+  #
+  # @return [true, block return value] if the block completes before timeout
+  #      or [false, nil] if the block is still active (i.e. the thread is still alive)
+  #      when max_seconds is reached
+  def try_with_timeout(max_seconds, check_interval_in_secs, &block)
+    raise "Must pass block to this method" unless block_given?
+    end_time = Time.now + max_seconds
+    block_return_value = nil
+    thread = Thread.new { block_return_value = block.call }
+    while Time.now < end_time
+      unless thread.alive?
+        return [true, block_return_value]
+      end
+      sleep(check_interval_in_secs)
+    end
+    # thread.kill
+    [false, nil]
+  end
+
 end
 end

data/lib/trick_bag/version.rb

@@ -1,3 +1,3 @@
 module TrickBag
-  VERSION = "0.59"
+  VERSION = '0.62.0'
 end

data/spec/trick_bag/collections/collection_access_spec.rb

@@ -19,12 +19,14 @@ describe CollectionAccess do
       h = { 'a' => { 'b' => 234 }}
       # instead of h['a']['b']:
       expect(CollectionAccess.access(h, 'a.b')).to eq(234)
+      expect(CollectionAccess.access(h, %w(a b))).to eq(234)
     end
 
     it 'works with 3 keys' do
       h = { 'a' => { 'bb' => { 'ccc' => 345 }}}
       # instead of h['a']['bb']['ccc']:
       expect(CollectionAccess.access(h, 'a.bb.ccc')).to eq(345)
+      expect(CollectionAccess.access(h, %w(a bb ccc))).to eq(345)
     end
 
     it 'works with spaces as separators' do
@@ -41,21 +43,26 @@ describe CollectionAccess do
     it 'works with numeric array subscripts 1 deep' do
       a = ['a', 'b']
       expect(CollectionAccess.access(a, '1')).to eq('b')
+      expect(CollectionAccess.access(a, [1])).to eq('b')
     end
 
     it 'works with a hash containing an array' do
       h = { 'h' => ['a', 'b'] }
       expect(CollectionAccess.access(h, 'h.1')).to eq('b')
+      expect(CollectionAccess.access(h, ['h', 1])).to eq('b')
+      expect(CollectionAccess.access(h, ['h', '1'])).to eq('b')
     end
 
     it 'raises an error when accessing an invalid key' do
       h = { 'h' => ['a', 'b'] }
       expect(-> { CollectionAccess.access(h, 'x.1.2') }).to raise_error
+      expect(-> { CollectionAccess.access(h, [x, 1, 2]) }).to raise_error
     end
 
     it 'raises an error when accessing a string that should be a number' do
       h = { 'x' => ['a', 'b'] }
       expect(-> { CollectionAccess.access(h, 'x.x') }).to raise_error
+      expect(-> { CollectionAccess.access(h, [x, x]) }).to raise_error
     end
   end
 
@@ -63,16 +70,18 @@ describe CollectionAccess do
   context '#accessor' do
 
     it 'works with a hash containing an array' do
-      h = { 'h' => ['a', 'b'] }
+      h = { 'h' => %w(a  b) }
       accessor = CollectionAccess.accessor(h)
       expect(accessor['h.1']).to eq('b')
-    end
-
-  end
 
+      # Test both [] and .() notations, with 1 as number and string:
+      expect(accessor[['h', 1]]).to eq('b')
+      expect(accessor.('h', 1)).to eq('b')
 
+      expect(accessor[['h', '1']]).to eq('b')
+      expect(accessor.(['h', '1'])).to eq('b')
+    end
+  end
 end
-
-
 end
 end

data/spec/trick_bag/timing/elapser_spec.rb

@@ -0,0 +1,95 @@
+require_relative '../../spec_helper'
+
+require 'trick_bag/timing/elapser'
+
+module TrickBag
+  module Timing
+
+    describe Elapser do
+
+      def test_number(number)
+        e = Elapser.new(number)
+        expect(e.class).to eq(Elapser)
+        expect(e.seconds).to eq(number)
+        expect(e.end_time - Time.now).to be_within(2.0).of(number)
+      end
+
+
+      context 'instantiation' do
+
+        it 'can take an integer' do
+          test_number(30)
+        end
+
+        it 'can take a float' do
+          test_number(30.0)
+        end
+
+        it 'can take an end time' do
+          now = Time.now
+          e = Elapser.new(now + 30)
+          expect(e.class).to eq(Elapser)
+          expect(e.seconds).to be_within(0.1).of(30)
+          expect(e.end_time - now).to be_within(0.1).of(30)
+        end
+
+        specify 'an invalid parameter type raises an error' do
+          expect { Elapser.new(nil) }.to raise_error(ArgumentError)
+          expect { Elapser.new('30') }.to raise_error(ArgumentError)
+        end
+      end
+
+
+      context '#elapsed?' do
+
+        specify 'elapsed? returns true if seconds is negative' do
+          expect(Elapser.new(-1).elapsed?).to eq(true)
+        end
+
+        specify 'elapsed? returns false if seconds is positive' do
+          expect(Elapser.new(100).elapsed?).to eq(false)
+        end
+      end
+
+
+      context '.from' do
+        specify 'calling with an Elapsed instance returns that instance' do
+          e = Elapser.new(30)
+          expect(Elapser.from(e)).to equal(e)
+        end
+
+        specify 'calling with a number or time works correctly' do
+          now = Time.now
+          secs = 45
+
+          expect(Elapser.from(secs).seconds - (Elapser.new(secs).seconds)).to be_within(1).of(0)
+          expect(Elapser.from(secs).end_time - (Elapser.new(secs).end_time)).to be_within(1).of(0)
+
+          expect(Elapser.from(now).seconds - (Elapser.new(now).seconds)).to be_within(1).of(0)
+          expect(Elapser.from(now).end_time - (Elapser.new(now).end_time)).to be_within(1).of(0)
+        end
+
+
+      end
+
+
+      context '.never' do
+
+        specify 'never_elapser is intialized correctly' do
+          expect(Elapser.never_elapser.elapsed?).to eq(false)
+          expect(Elapser.never_elapser.never_elapse).to eq(true)
+
+          expect(Elapser.from(:never).elapsed?).to eq(false)
+          expect(Elapser.from(:never).never_elapse).to eq(true)
+        end
+      end
+
+      context '#hash' do
+        specify '#hash returns an Integer' do
+          expect(Elapser.new(3).hash).to be_a(Integer)
+        end
+      end
+    end
+  end
+end
+

data/spec/trick_bag/timing/timing_spec.rb

@@ -68,4 +68,14 @@ module TrickBag
     end
   end
 
+
+  context '.try_with_timeout' do
+    it 'should return true and the block return value when timeout does not occur' do
+      expect(Timing.try_with_timeout(0.2, 0.01) { 7 }).to eq([true, 7])
+    end
+
+    it 'should return false and nil when timeout occurs' do
+      expect(Timing.try_with_timeout(0.2, 0.01) { sleep 100; 7 }).to eq([false, nil])
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trick_bag
 version: !ruby/object:Gem::Version
-  version: '0.59'
+  version: 0.62.0
 platform: ruby
 authors:
 - Keith Bennett
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-23 00:00:00.000000000 Z
+date: 2015-06-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: os
@@ -146,6 +146,7 @@ files:
 - lib/trick_bag/numeric/totals.rb
 - lib/trick_bag/operators/operators.rb
 - lib/trick_bag/system.rb
+- lib/trick_bag/timing/elapser.rb
 - lib/trick_bag/timing/timing.rb
 - lib/trick_bag/validations/gem_dependency_script.rb
 - lib/trick_bag/validations/hash_validations.rb
@@ -176,6 +177,7 @@ files:
 - spec/trick_bag/numeric/totals_spec.rb
 - spec/trick_bag/operators/operators_spec.rb
 - spec/trick_bag/system_spec.rb
+- spec/trick_bag/timing/elapser_spec.rb
 - spec/trick_bag/timing/timing_spec.rb
 - spec/trick_bag/validations/hash_validations_spec.rb
 - spec/trick_bag/validations/object_validations_spec.rb
@@ -202,7 +204,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.2
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: Miscellaneous general useful tools.
@@ -230,9 +232,9 @@ test_files:
 - spec/trick_bag/numeric/totals_spec.rb
 - spec/trick_bag/operators/operators_spec.rb
 - spec/trick_bag/system_spec.rb
+- spec/trick_bag/timing/elapser_spec.rb
 - spec/trick_bag/timing/timing_spec.rb
 - spec/trick_bag/validations/hash_validations_spec.rb
 - spec/trick_bag/validations/object_validations_spec.rb
 - spec/trick_bag/validations/other_validations_spec.rb
 - spec/trick_bag/validations/regex_validations_spec.rb
-has_rdoc: