trick_bag 0.30.0 → 0.31.0

data/RELEASE_NOTES.md

@@ -1,3 +1,11 @@
+## v0.31.0
+
+* Added EndlessLastEnumerable.
+* Added Formatter module with duration_to_s and end_with_nl.
+* Deleted IntegerDispenser.  It had little that [].cycle.to_enum couldn't offer.
+* In HashValidations: Add raise_on_missing_keys, permit passing either array or list.
+
+
 ## v0.30.0
 
 * Initial public version.

data/lib/trick_bag/enumerables/endless_last_enumerable.rb

@@ -0,0 +1,60 @@
+module TrickBag
+module Enumerables
+
+# Takes an array as input.  On successive calls to next, it returns the next
+# element in the array until the array has been exhausted, and then returns
+# the last element every time it's called.
+#
+# You can use Ruby's array addition and multiplication features
+# to provide rich functionality, e.g.:
+#
+#     array = [1] + [15]*3 + [60]*15 + [300]
+#
+# Values should only be nonzero positive integers.
+#
+# Why would this ever be useful?  It was created for the benefit of a long
+# running program, to provide time intervals for checking and reporting.
+# It was helpful to report frequently at the beginning of the run, to give
+# the user an opportunity to more easily verify correct behavior. Since
+# the operations performed were potentially time consuming, we did not
+# want to perform them frequently after the beginning of the run.
+# For example, the array provided might have been [1] + [5] * 10 + [10] * 10 + [30].
+  class EndlessLastEnumerable
+
+    include Enumerable
+
+    attr_reader :array
+
+    def initialize(array_or_number)
+      @array = case array_or_number
+        when Array
+         array_or_number
+        when Numeric
+         [array_or_number]
+        else
+         raise RuntimeError.new("Unsupported data type (#{array_or_number.class}.")
+        end
+      @pos = 0
+    end
+
+
+    def each
+      return to_enum unless block_given?
+      loop do
+        if @pos >= @array.size
+          value = @array.last
+        else
+          value = @array[@pos]
+          @pos += 1
+        end
+        yield(value)
+      end
+    end
+
+
+    def ==(other)   # mostly for testing
+      other.is_a?(self.class) && other.array == array
+    end
+  end
+end
+end

data/lib/trick_bag/formatters/formatters.rb

@@ -0,0 +1,54 @@
+module TrickBag
+module Formatters
+
+  module_function
+
+  def duration_to_s(seconds)
+
+    seconds_in_minute = 60
+    seconds_in_hour = 60 * seconds_in_minute
+    seconds_in_day = 24 *seconds_in_hour
+
+    seconds = seconds.to_i
+    str = ''
+
+    if seconds < 0
+      str << '-'
+      seconds = -seconds
+    end
+
+    fractional_second = seconds - Integer(seconds)
+    seconds = Integer(seconds)
+
+    days = seconds / seconds_in_day
+    print_days = days > 0
+    seconds %= seconds_in_day
+
+    hours = seconds / seconds_in_hour
+    print_hours = hours > 0 || days > 0
+    seconds %= seconds_in_hour
+
+    minutes = seconds / seconds_in_minute
+    print_minutes = minutes > 0 || hours > 0 || days > 0
+    seconds %= seconds_in_minute
+
+    str << "#{days} d, "     if print_days
+    str << "#{hours} h, "    if print_hours
+    str << "#{minutes} m, "  if print_minutes
+    str << "#{seconds + fractional_second} s"
+
+    str
+  end
+
+
+  # Convert to string if not already a string.
+  # Append new line to string if the string is not empty and does not already end with one.
+  # This is to disable the Diffy warning message "No newline at end of file"
+  def end_with_nl(object)
+    string = object.to_s
+    needs_modifying = string && string.size > 0 && string[-1] != "\n"
+    needs_modifying ? "#{string}\n" : string
+  end
+end
+end
+

data/lib/trick_bag/validations/hash_validations.rb

@@ -5,17 +5,31 @@ module HashValidations
 
   # Looks to see which keys, if any, are missing from the hash.
   # @return an array of missing keys (empty if none)
-  def missing_hash_entries(hash, keys)
-    keys.reject { |key| hash.keys.include?(key) }
+  def missing_hash_entries(the_hash, *keys)
+    # Support passing either an Array or multiple args:
+    if keys.size == 1 && keys.first.is_a?(Array)
+      keys = keys.first
+    end
+
+    keys.reject { |key| the_hash.keys.include?(key) }
   end
 
   # Looks to see which keys, if any, are missing from the hash.
   # @return nil if none missing, else comma separated string of missing keys.
-  def missing_hash_entries_as_string(hash, keys)
-    missing_keys = missing_hash_entries(hash, keys)
+  def missing_hash_entries_as_string(the_hash, *keys)
+    missing_keys = missing_hash_entries(the_hash, *keys)
     missing_keys.empty? ? nil : missing_keys.join(', ')
   end
 
+  # Checks to see that all passed keys are present in the hash.
+  # If not, an exception is raised, with a message string listing the missing keys.
+  def raise_on_missing_keys(the_hash, *keys)
+    missing_entries_string = missing_hash_entries_as_string(the_hash, keys)
+    if missing_entries_string
+      raise "The following required options were not provided: #{missing_entries_string}"
+    end
+  end
 end
 end
 end
+

data/lib/trick_bag/version.rb

@@ -1,3 +1,3 @@
 module TrickBag
-  VERSION = "0.30.0"
+  VERSION = "0.31.0"
 end

data/spec/trick_bag/enumerables/endless_last_enumerable_spec.rb

@@ -0,0 +1,51 @@
+require_relative '../../spec_helper'
+
+require 'trick_bag/enumerables/endless_last_enumerable'
+
+module TrickBag::Enumerables
+
+  describe EndlessLastEnumerable do
+
+    it "should instantiate with an array" do
+      expect(->{ EndlessLastEnumerable.new([1]) }).not_to raise_error
+    end
+
+    it "should return the 3rd element on the 3rd call to next" do
+      array = (0..10).to_a
+      e = EndlessLastEnumerable.new(array).each
+      2.times { e.next }
+      expect(e.next).to eq(2)
+    end
+
+
+    it "should return the last value in the array when the iteration number >= the array size" do
+      array = (0..10).to_a
+      e = EndlessLastEnumerable.new(array).each
+      10.times { e.next }
+      2.times { expect(e.next).to eq(10) }
+    end
+
+
+    it "should return the original array and then repeat the last" do
+      array = (0..7).to_a
+      e = EndlessLastEnumerable.new(array).each
+      expect(e.take(8)).to eq(array)
+      expect(e.take(12)).to eq([7] * 12)
+    end
+
+    it "should return == for 2 instances created with the same array" do
+      array = (0..10).to_a
+      e1 = EndlessLastEnumerable.new(array)
+      e2 = EndlessLastEnumerable.new(array)
+      expect(e1).to eq(e2)
+    end
+
+
+    it "should return != for 2 instances created with arrays that are not equal" do
+      e1 = EndlessLastEnumerable.new([1])
+      e2 = EndlessLastEnumerable.new([2, 1])
+      expect(e1).not_to eq(e2)
+    end
+  end
+
+end

data/spec/trick_bag/formatters/formatters_spec.rb

@@ -0,0 +1,61 @@
+require_relative '../../spec_helper'
+
+require 'trick_bag/formatters/formatters'
+
+module TrickBag
+
+describe Formatters do
+
+  context ".duration_to_s" do
+
+    specify "it will not permit a non-number" do
+      expect(->() { Formatters.duration_to_s([])}).to raise_error
+    end
+
+    expect_output_for_input = ->(expected_output, input) do
+      description = "it returns '#{expected_output}' for an input of #{input}"
+      specify description do
+        expect(Formatters.duration_to_s(input)).to eq(expected_output)
+      end
+    end
+
+    # Positive numbers
+    expect_output_for_input.('1 s',                    1)
+    expect_output_for_input.('1 m, 0 s',              60)
+    expect_output_for_input.('3 m, 37 s',              3 * 60 + 37)
+    expect_output_for_input.('1 h, 0 m, 0 s',         60 * 60)
+    expect_output_for_input.('1 d, 0 h, 0 m, 0 s',    24 * 60 * 60)
+
+    # Negative numbers
+    expect_output_for_input.('-1 s',                    -1)
+    expect_output_for_input.('-1 m, 0 s',              -60)
+    expect_output_for_input.('-3 m, 37 s',             -(3 * 60 + 37))
+    expect_output_for_input.('-1 h, 0 m, 0 s',         -60 * 60)
+    expect_output_for_input.('-1 d, 0 h, 0 m, 0 s',    -24 * 60 * 60)
+
+    # Zero
+    expect_output_for_input.('0 s',                    0)
+
+  end
+
+
+  context ".end_with_nl" do
+
+    specify "it returns an empty string for an empty string" do
+      expect(Formatters.end_with_nl('')).to eq('')
+    end
+
+    specify "it leaves a single new line unchanged" do
+      expect(Formatters.end_with_nl("\n")).to eq("\n")
+    end
+
+    specify "it returns an empty string for nil because nil.to_s == ''" do
+      expect(Formatters.end_with_nl(nil)).to eq('')
+    end
+
+    specify "it converts a number and then adds a new line" do
+      expect(Formatters.end_with_nl(3)).to eq("3\n")
+    end
+  end
+end
+end

data/spec/trick_bag/validations/hashes_validations_spec.rb

@@ -8,32 +8,62 @@ module Validations
 
   include HashValidations
 
-  it 'should return a correct list of missing keys' do
-    h = { a: 1, c: 1, e: 1}
-    keys_to_test = [:e, :d, :c, :b, :a]
-    expect(missing_hash_entries(h, keys_to_test)).to eq([:d, :b])
-  end
+  context '.missing_hash_entries' do
+
+    it 'should return a correct list of missing keys' do
+      h = { a: 1, c: 1, e: 1}
+      keys_to_test = [:e, :d, :c, :b, :a]
+      expect(missing_hash_entries(h, keys_to_test)).to eq([:d, :b])
+    end
 
 
-  it 'should return an empty array for no missing keys' do
-    h = { a: 1, c: 1, e: 1}
-    keys_to_test = [:e, :c, :a]
-    expect(missing_hash_entries(h, keys_to_test)).to eq([])
+    it 'should return an empty array for no missing keys' do
+      h = { a: 1, c: 1, e: 1}
+      keys_to_test = [:e, :c, :a]
+      expect(missing_hash_entries(h, keys_to_test)).to eq([])
+    end
   end
 
 
-  it 'should return a correct string listing missing keys' do
-    h = { a: 1, c: 1, e: 1}
-    keys_to_test = [:e, :d, :c, :b, :a]
-    expect(missing_hash_entries_as_string(h, keys_to_test)).to eq('d, b')
+  context '.missing_hash_entries_as_string' do
+
+    it 'should return a correct string listing missing keys' do
+      h = { a: 1, c: 1, e: 1}
+      keys_to_test = [:e, :d, :c, :b, :a]
+      expect(missing_hash_entries_as_string(h, keys_to_test)).to eq('d, b')
+    end
+
+
+    it 'should return nil instead of a string for no missing keys' do
+      h = { a: 1, c: 1, e: 1}
+      keys_to_test = [:e, :c, :a]
+      expect(missing_hash_entries_as_string(h, keys_to_test)).to be_nil
+    end
   end
 
 
-  it 'should return nil instead of a string for no missing keys' do
-    h = { a: 1, c: 1, e: 1}
-    keys_to_test = [:e, :c, :a]
-    expect(missing_hash_entries_as_string(h, keys_to_test)).to be_nil
+  context '.raise_on_missing_keys'do
+
+    it 'should raise an exception whose message includes the missing keys' do
+      my_hash = {}
+      missing_keys = [:foo, :bar]
+      begin
+        raise_on_missing_keys(my_hash, missing_keys)
+        fail "An exception should have been raised."
+      rescue => e
+        message = e.to_s
+        missing_keys.each do |key|
+          expect(message).to include(key.to_s)
+        end
+      end
+    end
+
+    it 'should not raise an exception when all keys are present' do
+      my_hash = { foo: 1, bar: 2, baz: 3}
+      expect(->() { raise_on_missing_keys(my_hash, :foo, :baz) }).not_to raise_error
+    end
   end
 end
 end
 end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: trick_bag
 version: !ruby/object:Gem::Version
-  version: 0.30.0
+  version: 0.31.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-04 00:00:00.000000000 Z
+date: 2014-03-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: vrsn-ie-dnsruby
@@ -125,7 +125,9 @@ files:
 - lib/trick_bag/collections/linked_list.rb
 - lib/trick_bag/enumerables/buffered_enumerable.rb
 - lib/trick_bag/enumerables/compound_enumerable.rb
+- lib/trick_bag/enumerables/endless_last_enumerable.rb
 - lib/trick_bag/enumerables/filtered_enumerable.rb
+- lib/trick_bag/formatters/formatters.rb
 - lib/trick_bag/io/temp_files.rb
 - lib/trick_bag/io/text_mode_status_updater.rb
 - lib/trick_bag/meta/classes.rb
@@ -140,7 +142,9 @@ files:
 - spec/trick_bag/collections/linked_list_spec.rb
 - spec/trick_bag/enumerables/buffered_enumerable_spec.rb
 - spec/trick_bag/enumerables/compound_enumerable_spec.rb
+- spec/trick_bag/enumerables/endless_last_enumerable_spec.rb
 - spec/trick_bag/enumerables/filtered_enumerable_spec.rb
+- spec/trick_bag/formatters/formatters_spec.rb
 - spec/trick_bag/io/temp_files_spec.rb
 - spec/trick_bag/io/text_mode_status_updater_spec.rb
 - spec/trick_bag/meta/classes_spec.rb
@@ -181,7 +185,9 @@ test_files:
 - spec/trick_bag/collections/linked_list_spec.rb
 - spec/trick_bag/enumerables/buffered_enumerable_spec.rb
 - spec/trick_bag/enumerables/compound_enumerable_spec.rb
+- spec/trick_bag/enumerables/endless_last_enumerable_spec.rb
 - spec/trick_bag/enumerables/filtered_enumerable_spec.rb
+- spec/trick_bag/formatters/formatters_spec.rb
 - spec/trick_bag/io/temp_files_spec.rb
 - spec/trick_bag/io/text_mode_status_updater_spec.rb
 - spec/trick_bag/meta/classes_spec.rb