trick_bag 0.37.0 → 0.38.0

data/RELEASE_NOTES.md

@@ -1,3 +1,14 @@
+## v0.38.0
+
+* Added documentation.
+* Changed string returned by missing_hash_entries_as_string to be array.inspect.
+* TextModeStatusUpdater.print now calls to_s on lambda's return value.
+* Modified EndlessLastEnumerable so it could be initialized with any Enumerable, not only an Array.
+* Added documentation, tests that enumerators return enumerables when yield is called without a block.
+* Changed FilteredEnumerable default filter to be a lambda that always returns true.
+* Added LinkedList#to_ary.
+
+
 ## v0.37.0
 
 * Fixed: 'os' gem dependency was not properly specified in gemspec.

data/lib/trick_bag/collections/linked_list.rb

@@ -3,7 +3,6 @@ module Collections
 
 # Linked List based on git@github.com:neilparikh/ruby-linked-list.git,
 # but modified somewhat.
-
 class LinkedList
 
   class Node
@@ -18,18 +17,21 @@ class LinkedList
   attr_accessor :first
   attr_reader :length
 
+
+  # @param items items with which to initialize the list
   def initialize(*items)
     @length = items.length
     @first = Node.new(items.shift)
     items.each { |item| push(item) }
   end
 
-  # adds value to end of list
-  # returns self
+
+  # @param value value to add to end of list
+  # @return self
   def push(value)
     node = Node.new(value)
     current_node = @first
-    while current_node.next != nil
+    while current_node.next
       current_node = current_node.next
     end
     current_node.next = node
@@ -37,8 +39,9 @@ class LinkedList
     self
   end
 
-  # Removes last element from list
-  # returns that element's value
+
+  # Returns the last element from the list and removes it
+  # @return the last element's value
   def pop
     case(@length)
 
@@ -64,8 +67,9 @@ class LinkedList
   end
 
 
-  # adds value to beginning of list
-  # returns self
+  # Adds a value to the beginning of the list
+  # @param value value to add to beginning of list
+  # @return self
   def unshift(value)
     node = Node.new(value, @first)
     @first = node
@@ -73,16 +77,19 @@ class LinkedList
     self
   end
 
-  # Removes first element from list
-  # returns that element's value
+
+  # Removes the first element from the list
+  # @return the first element's value
   def shift
     raise "List is empty" if @length < 1
-    to_return = @first.value
+    return_value = @first.value
     @first = @first.next
     @length -= 1
-    to_return
+    return_value
   end
 
+
+  # @return the values in this list as an array
   def to_a
     current_node = @first
     array = []
@@ -92,6 +99,12 @@ class LinkedList
     end
     array
   end
+
+
+  # @return the values in this list as an array
+  def to_ary
+    to_a
+  end
 end
 end
 end

data/lib/trick_bag/enumerables/buffered_enumerable.rb

@@ -1,6 +1,20 @@
+
+require 'trick_bag/meta/classes'
+
+module TrickBag
+module Enumerables
+
 # Provides the plumbing for an enumerator that, in order to serve objects in each(),
 # fetches them in chunks.
 #
+# This class knows nothing about how to fetch anything; that behavior is provided
+# by either subclassing this class, or calling .create_with_lambdas and passing
+# a lambda that knows how to do that.
+#
+# Also supported is an optional fetch notification, a method or lambda that will
+# be called whenever a fetch is done.  This can be useful to update counters,
+# provide user feedback (e.g. a progress bar)
+#
 # This is useful, for example, in network requests, when multiple requests can be sent
 # one immediately after another, and the responses can be collected as a group,
 # for improved performance.
@@ -10,15 +24,10 @@
 # needlessly copying arrays,
 # and to eliminate the need for garbage collecting many array objects
 # (though the latter is not that important).
-
-require 'trick_bag/meta/classes'
-
-module TrickBag
-module Enumerables
-
 class BufferedEnumerable
 
   include Enumerable
+
   extend ::TrickBag::Meta::Classes
 
   attr_accessor :fetcher, :fetch_notifier
@@ -28,6 +37,10 @@ class BufferedEnumerable
   attr_access :public,    :private,   :chunk_count, :fetch_count, :yield_count
 
 
+  # Creates an instance with lambdas for fetch and fetch notify behaviors.
+  # @param chunk_size the maximum number of objects to be buffered
+  # @param fetcher lambda to be called to fetch to fill the buffer
+  # @param fetch_notifier lambda to be called to when a fetch is done
   def self.create_with_lambdas(chunk_size, fetcher, fetch_notifier)
     instance = self.new(chunk_size)
     instance.fetcher = fetcher
@@ -35,9 +48,9 @@ class BufferedEnumerable
     instance
   end
 
-  # @param fetcher a lambda/proc taking the chunk size as its parameter
-  # @param chunk_size how many objects to fetch at a time
-  # @param fetch_notifier a lambda/proc to be called when a fetch is done;
+  # @param fetcher lambda to be called to fetch to fill the buffer
+  # @param chunk_size the maximum number of objects to be buffered
+  # @param fetch_notifier lambda to be called to when a fetch is done
   #        in case the caller wants to receive notification, update counters, etc.
   #        It's passed the array of objects just fetched, whose size may be
   #        less than chunk size.
@@ -64,6 +77,10 @@ class BufferedEnumerable
   end
 
 
+  # Enumerable.each method.
+  # Note that, like all Enumerable.each methods, if you pass it without a block,
+  # it will return an enumerator, and any cleanup that would normally be done
+  # after each's loop has completed will not happen.
   def each
     return to_enum unless block_given?
 

data/lib/trick_bag/enumerables/compound_enumerable.rb

@@ -47,6 +47,8 @@ class CompoundEnumerable
   end
 
 
+  # @param mode determines whether each should yield hashes or arrays.
+  # Permissible values are [:yields_arrays, :yields_hashes].
   def initialize(mode, keys, *enumerables)
 
     validate_inputs = ->do

data/lib/trick_bag/enumerables/endless_last_enumerable.rb

@@ -1,3 +1,5 @@
+require 'set'
+
 module TrickBag
 module Enumerables
 
@@ -23,16 +25,16 @@ module Enumerables
 
     include Enumerable
 
-    attr_reader :array
+    attr_reader :inner_enumerable
 
-    def initialize(array_or_number)
-      @array = case array_or_number
-        when Array
-         array_or_number
+    def initialize(enumerable_or_number)
+      @inner_enumerable = case enumerable_or_number
+        when Enumerable
+         enumerable_or_number
         when Numeric
-         [array_or_number]
+         Array(enumerable_or_number)
         else
-         raise RuntimeError.new("Unsupported data type (#{array_or_number.class}.")
+         raise RuntimeError.new("Unsupported data type (#{enumerable_or_number.class}.")
         end
       @pos = 0
     end
@@ -40,20 +42,21 @@ module Enumerables
 
     def each
       return to_enum unless block_given?
+      last_number = nil
+
+      inner_enumerable.each do |number|
+        yield(number)
+        last_number = number
+      end
+
       loop do
-        if @pos >= @array.size
-          value = @array.last
-        else
-          value = @array[@pos]
-          @pos += 1
-        end
-        yield(value)
+        yield(last_number)
       end
     end
 
 
     def ==(other)   # mostly for testing
-      other.is_a?(self.class) && other.array == array
+      other.is_a?(self.class) && other.inner_enumerable == inner_enumerable
     end
   end
 end

data/lib/trick_bag/enumerables/file_line_reader.rb

@@ -9,6 +9,13 @@ module Enumerables
 #
 # If calling each without a block to get an enumerator, call enumerator.close when done
 # if not all values have been exhausted, so that the input file will be closed.
+#
+# Supports specifying a starting position and maximum count.  For example
+# if the starting position is 2, then the first 2 valid lines will be
+# discarded, and yielding will begin with the next valid line.
+#
+# Similarly, specifying a maximum count will cause yielding to end after
+# max_count objects have been yielded.
 class FileLineReader
 
   include Enumerable
@@ -24,22 +31,27 @@ class FileLineReader
     @start_and_max = TrickBag::Numeric::StartAndMax.new(start_pos, max_count)
   end
 
-
+  # @return the position of the first valid object to be yielded.
   def start_pos
     start_and_max.start_pos
   end
 
 
+  # @return the maximum number of objects to be yielded
   def max_count
     start_and_max.max_count
   end
 
 
+  # @param line the line to test
+  # @return whether or not this line is valid (eligible for yielding),
+  #        specifically not empty and not a comment
   def line_valid?(line)
     ! (line.empty? || /^#/ === line)
   end
 
 
+  # Closes the file if it is not null and has not already been closed
   def close_file(file)
     if file && (! file.closed?)
       file.close
@@ -47,12 +59,15 @@ class FileLineReader
   end
 
 
-  # Any enum returned should have a close method to close the file from which lines are read.
-  # Get the enumerator from the superclass, and add a close method to it.
+  # Any enumerator returned should have a close method to close the file
+  # from which lines are read.  This method gets an enumerator from the superclass,
+  # and adds a 'file' attribute and a close method to it.
   def to_enum(file)
     enumerator = super()
     enumerator.instance_variable_set(:@file, file)
 
+    # This method is defined on the instance of the new enumerator.
+    # It closes the input file.
     def enumerator.close
       if @file && (! @file.closed?)
         @file.close

data/lib/trick_bag/enumerables/filtered_enumerable.rb

@@ -12,19 +12,23 @@ class FilteredEnumerable
 
   include Enumerable
 
-  attr_reader :inner_enum
+  attr_reader :wrapped_enumerator
   attr_accessor :filter
 
-  def initialize(inner_enum, filter = nil)
-    @inner_enum = inner_enum
+  # @param wrapped_enumerator the enumerator to filter
+  # @param filter a lambda that returns whether or not to yield a given object,
+  #         defaults to lambda always returning true
+  def initialize(wrapped_enumerator, filter = ->(_) { true })
+    @wrapped_enumerator = wrapped_enumerator
     @filter = filter
   end
 
+  # Standard Enumerable.each; returns an Enumerator if called without a block
   def each
     return to_enum unless block_given?
 
-    inner_enum.each do |thing|
-      yield thing if filter.nil? || filter.(thing)
+    wrapped_enumerator.each do |thing|
+      yield thing if filter.(thing)
     end
   end
 end

data/lib/trick_bag/formatters/formatters.rb

@@ -5,13 +5,20 @@ module Formatters
 
   module_function
 
+  # Formats a number of seconds as a succinct string, with days, hours,
+  # minutes, and seconds.  Examples:
+  #
+  # duration_to_s(1_000_000)  => "11 d, 13 h, 46 m, 40 s"
+  # duration_to_s(1_000)      => "16 m, 40 s"
+  # duration_to_s(-1_000)     => "-16 m, 40 s"
+  # duration_to_s(1.234567)   => "1.234567 s"
+  # duration_to_s(1000.234567) => "16 m, 40.23456699999997 s"
   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
@@ -53,6 +60,9 @@ module Formatters
   end
 
 
+  # Returns a timestamp string suitable for use in filespecs,
+  # whose string sort order will be the same as a chronological sort would be.
+  # @param datetime the date to format, defaults to DateTime.now
   def timestamp(datetime = DateTime.now)
     datetime.strftime('%Y-%m-%d_%H-%M-%S')
   end
@@ -60,7 +70,12 @@ module Formatters
 
   # Replaces all occurrences of marker with the current date/time in
   # YYYYMMDD-HHMMSS format.
-  def replace_with_timestamp(string, marker = '{dt}', datetime = DateTime.now)
+  #
+  # Useful for creating filespecs with static content that will differ by date,
+  # for example:
+  #
+  # replace_with_timestamp('my-app-result-{dt}.txt') => "my-app-result-2014-03-24_15-25-57.txt"
+    def replace_with_timestamp(string, marker = '{dt}', datetime = DateTime.now)
     string.gsub(marker, timestamp(datetime))
   end
 

data/lib/trick_bag/io/temp_files.rb

@@ -4,7 +4,15 @@ module TempFiles
 
     module_function
 
+    # Creates a temporary file containing the specified text,
+    # passes its filespec to the passed block, then deletes the file.
+    #
+    # @param text the text to write to the temporary file
+    # @param file_prefix optional prefix for the temporary file's name
+    # @yield filespec of the temporary file
     def self.file_containing(text, file_prefix = '')
+      raise "This method must be called with a code block." unless block_given?
+
       filespec = nil
       begin
         Tempfile.open(file_prefix) do |file|

data/lib/trick_bag/io/text_mode_status_updater.rb

@@ -4,6 +4,11 @@ module Io
 # Updates the terminal line with text, erasing the original content and displaying at the same place.
 # Uses ANSI escape sequences for cursor positioning and clearing
 # (see http://www.oldlinux.org/Linux.old/Ref-docs/ASCII/ANSI%20Escape%20Sequences.htm).
+#
+# Example:
+#
+# updater = TrickBag::Io::TextModeStatusUpdater.new(->{ Time.now })
+# 5.times { updater.print; sleep(1) }
 class TextModeStatusUpdater
 
 
@@ -14,6 +19,33 @@ class TextModeStatusUpdater
     @first_time = true
   end
 
+
+  # Causes the text generator lambda to be called, calls to_s on its result,
+  # and outputs the resulting text to the output stream, moving the cursor
+  # left to the beginning of the previous call's output if not the first call to print.
+  #
+  # Since this method uses ASCII escape sequences that would look messy in a file,
+  # this method will silently return if the output stream is not a TTY, unless
+  # @force_output_non_tty has been set to true.
+  def print
+
+    # If output is being redirected, don't print anything; it will look like garbage;
+    # But if output was forced (e.g. to write to a string), then allow it.
+    return unless @outstream.tty? || @force_output_non_tty
+
+    if @first_time
+      @first_time = false
+    else
+      @outstream.print(move_cursor_left_text(@prev_text_length))
+    end
+    text = @text_generator.().to_s
+    @prev_text_length = text.length
+    @outstream.print(clear_to_end_of_line_text + text)
+  end
+
+  # The following methods are for cursor placement and text clearing:
+  private
+
   def clear_to_end_of_line_text
     "\x1b[2K"
   end
@@ -38,22 +70,6 @@ class TextModeStatusUpdater
     "\x1b[#{num_chars}@"
   end
 
-  def print
-
-    # If output is being redirected, don't print anything; it will look like garbage;
-    # But if output was forced (e.g. to write to a string), then allow it.
-    return unless @outstream.tty? || @force_output_non_tty
-
-    if @first_time
-      @first_time = false
-    else
-      @outstream.print(move_cursor_left_text(@prev_text_length))
-    end
-    text = @text_generator.()
-    @prev_text_length = text.length
-    @outstream.print(clear_to_end_of_line_text + text)
-  end
-
 end
 end
 end

data/lib/trick_bag/meta/classes.rb

@@ -15,13 +15,14 @@ module Classes
     #
     #     attr_access(:private, :none, :foo, :bar)
     #
-    # will create accessors for @foo and @bar, and make them private,
-    # but will not create any mutators.
+    # will create readers (aka accessors or getters) for @foo and @bar,
+    # and make them private, but will not create any writers
+    # (aka mutators or setters).
     def attr_access(read_access, write_access, *attrs)
       validate_input = -> do
         [read_access, write_access].each do |access|
           unless VALID_ACCESS_MODES.include?(access)
-            raise "Access mode must be one of [:public, :protected, :private]."
+            raise "Access mode must be one of #{VALID_ACCESS_MODES.inspect}]."
           end
         end
       end
@@ -41,41 +42,60 @@ module Classes
     end
 
 
+    # Creates private readers and no writers for the specified attributes.
     def private_attr_reader(*attrs)
       attr_access(:private, :none, *attrs)
     end
 
 
+    # Creates private writers and no readers for the specified attributes.
     def private_attr_writer(*attrs)
       attr_access(:none, :private, *attrs)
     end
 
 
+    # Creates private readers and writers for the specified attributes.
     def private_attr_accessor(*attrs)
       attr_access(:private, :private, *attrs)
     end
 
 
+    # Creates protected readers and no writers for the specified attributes.
     def protected_attr_reader(*attrs)
       attr_access(:protected, :none, *attrs)
     end
 
 
+    # Creates protected writers and no readers for the specified attributes.
     def protected_attr_writer(*attrs)
       attr_access(:none, :protected, *attrs)
     end
 
 
+    # Creates protected readers and writers for the specified attributes.
     def protected_attr_accessor(*attrs)
       attr_access(:protected, :protected, *attrs)
     end
 
 
+    # Returns whether or not the specified name is a defined class.
+    # @param class class name (a string)
+    # @param scope scope in which the class would be defined, defaults to Object
+    #        (e.g. could be MyModule::InnerModule)
+    #
+    # e.g. module M; class X; end; end;  class?('X', M) => true
     def class?(name, scope = Object)
       scope.const_defined?(name) && scope.const_get(name).is_a?(Class)
     end; module_function :class?
 
 
+    # Undefines a class; useful for unit testing code that manipulates classes.
+    #
+    # @param name  name of class to undefine
+    # @param scope scope in which the class is defined, defaults to Object
+    #
+    # e.g. module M; class X; end; end;  class?('X', M) => true
+    # undef_class('X', M);               class?('X', M) => false
     def undef_class(name, scope = Object)
       class_existed = class?(name, scope)
       scope.send(:remove_const, name) if class_existed

data/lib/trick_bag/numeric/multi_counter.rb

@@ -7,35 +7,47 @@ class MultiCounter
 
   attr_accessor :name
 
+  # Creates a multicounter.
+  #
+  # @param name optional name for printing in to_s
   def initialize(name = '')
     @name = name
     @counts = Hash.new(0)
   end
 
+  # Adds keys in the passed enumerable to this counter.
   def add_keys(keys)
     keys.each { |key| @counts[key] = 0 }
   end
 
+  # Increments the value corresponding to the specified key.
   def increment(key)
     @counts[key] += 1
   end
 
+  # Returns the count for the specified key.
   def [](key)
     @counts[key]
   end
 
+  # Returns this counter's keys.
   def keys
     @counts.keys
   end
 
+  # Returns whether or not the specified key exists in this counter.
   def key_exists?(key)
     keys.include?(key)
   end
 
+  # Creates a hash whose keys are this counter's keys, and whose values are
+  # their corresponding values.
   def to_hash
     @counts.clone
   end
 
+  # Returns a string representing this counter, including its values,
+  # and, if specified, its optional name.
   def to_s
     "#{self.class} '#{name}': #{@counts.to_s}"
   end

data/lib/trick_bag/numeric/start_and_max.rb

@@ -2,7 +2,7 @@ module TrickBag
 module Numeric
 
   # Like a Range, but includes useful functions with understandable names
-  # that account for the absence of limits.
+  # that account for the limits or absences of limits.
   class StartAndMax
 
   attr_reader :start_pos, :max_count
@@ -11,22 +11,27 @@ module Numeric
   # @param max_count - the maximum number of records to be served by each(); or :infinite
   def initialize(start_pos = :first, max_count = :infinite)
     @start_pos = ([nil, :first].include?(start_pos) || start_pos <= 0) ? :first : start_pos
-    @max_count = ([nil, :infinite].include?(max_count)     || max_count <= 0) ? :infinite : max_count
+    @max_count = ([nil, :infinite].include?(max_count) || max_count <= 0) ? :infinite : max_count
   end
 
 
+  # If a starting position has been specified, returns whether or not the specified number
+  # >= that position.  Else, returns true unconditionally.
   def start_position_reached?(num)
     @start_pos == :first || num >= @start_pos
   end
 
 
+  # If a maximum count has been specified, returns whether or not the specified number
+  # >= that count.  Else, returns false unconditionally.
   def max_count_reached?(count)
     @max_count != :infinite && (count >= @max_count)
   end
 
 
+  # Returns string representation including starting position and maximum count.
   def to_s
-    "#{self.class}: start position=#{start_pos}, max count=#{max_count}"
+    "#{self.class}: start position=#{start_pos.inspect}, max count=#{max_count.inspect}"
   end
 
 end

data/lib/trick_bag/numeric/totals.rb

@@ -6,6 +6,8 @@ module Totals
 
   # @inputs an enumerable of numbers
   # @return a collection containing the corresponding fractions of total of those numbers
+  #
+  # e.g.:  map_fraction_of_total [10,20,30] => [0.16666666666666666, 0.3333333333333333, 0.5]
   def map_fraction_of_total(inputs)
     return [] if inputs.size == 0
     sum = Float(inputs.inject(:+))
@@ -15,6 +17,8 @@ module Totals
 
   # @inputs an enumerable of numbers
   # @return a collection containing the corresponding percents of total of those numbers
+  #
+  # e.g.  map_percent_of_total [10,20,30] => [16.666666666666664, 33.33333333333333, 50.0]
   def map_percent_of_total(inputs)
     map_fraction_of_total(inputs).map { |n| n * 100 }
   end
@@ -22,8 +26,9 @@ module Totals
 
   # Given a hash whose values are numbers, produces a new hash with the same keys
   # as the original hash, but whose values are the % of total.
-  # Ex: for input  { foo: 100, bar: 200, baz: 300, razz: 400 }, value returned would be
-  # { foo: 10.0, bar: 20.0, baz: 30.0, razz: 40.0 }.
+  #
+  # Ex: fraction_of_total_hash({ foo: 10.0, bar: 20.0, baz: 30.0, razz: 40.0 })
+  #          => {:foo=>0.1, :bar=>0.2, :baz=>0.3, :razz=>0.4}
   def fraction_of_total_hash(the_hash)
     new_hash = percent_of_total_hash(the_hash)
     new_hash.keys.each do |key|
@@ -35,8 +40,9 @@ module Totals
 
   # Given a hash whose values are numbers, produces a new hash with the same keys
   # as the original hash, but whose values are the % of total.
-  # Ex: for input  { foo: 100, bar: 200, baz: 300, razz: 400 }, value returned would be
-  # { foo: 10.0, bar: 20.0, baz: 30.0, razz: 40.0 }.
+  #
+  # Ex:  percent_of_total_hash({ foo: 10.0, bar: 20.0, baz: 30.0, razz: 40.0 })
+  #         => {:foo=>10.0, :bar=>20.0, :baz=>30.0, :razz=>40.0}
   def percent_of_total_hash(the_hash)
     sum = Float(the_hash.values.inject(:+))
     keys = the_hash.keys

data/lib/trick_bag/operators/operators.rb

@@ -4,6 +4,8 @@ module Operators
   module_function
 
   # Returns whether or not all passed values are equal
+  #
+  # Ex: multi_eq(1, 1, 1, 2) => false; multi_eq(1, 1, 1, 1) => true
   def multi_eq(*values)
     values = values.first if values.is_a?(Array) && values.size == 1
     raise "Must be called with at least 2 parameters" if values.size < 2

data/lib/trick_bag/timing/timing.rb

@@ -14,6 +14,8 @@ module Timing
   #   that returns a truthy value that indicates no further retries are necessary
   # @param sleep_interval  number of seconds (fractions ok) to wait between tries
   # @param timeout_secs maximum number of seconds (fractions ok) during which to retry
+  #
+  # Ex: TrickBag::Timing.retry_until_true_or_timeout(->{false}, 1.0, 5)
   def retry_until_true_or_timeout(
       predicate, sleep_interval, timeout_secs, output_stream = $stdout)
 

data/lib/trick_bag/validations/hash_validations.rb

@@ -14,11 +14,12 @@ module HashValidations
     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(the_hash, *keys)
     missing_keys = missing_hash_entries(the_hash, *keys)
-    missing_keys.empty? ? nil : missing_keys.join(', ')
+    missing_keys.empty? ? nil : missing_keys.inspect
   end
 
   # Checks to see that all passed keys are present in the hash.

data/lib/trick_bag/version.rb

@@ -1,3 +1,3 @@
 module TrickBag
-  VERSION = "0.37.0"
+  VERSION = "0.38.0"
 end

data/spec/trick_bag/collections/linked_list_spec.rb

@@ -8,9 +8,11 @@ module Collections
 
 describe LinkedList do
 
+  let(:sample_array) { [1, 2, 3] }
+  let(:sample_list) { LinkedList.new(*sample_array) }
+
   specify 'to_a should return an array equal to the array with which it was initialized' do
-    array = [1, 3, 5]
-    expect(LinkedList.new(*array).to_a).to eq(array)
+    expect(LinkedList.new(*sample_array).to_a).to eq(sample_array)
   end
 
   it 'should push correctly' do
@@ -20,9 +22,8 @@ describe LinkedList do
   end
 
   it 'should pop from a list of multiple elements correctly' do
-    list = LinkedList.new(1, 2, 3)
-    expect(list.pop).to eq(3)
-    expect(list.to_a).to eq([1, 2])
+    expect(sample_list.pop).to eq(3)
+    expect(sample_list.to_a).to eq([1, 2])
   end
 
   it 'should pop from a list of 1 element correctly' do
@@ -44,9 +45,8 @@ describe LinkedList do
   end
 
   it 'should shift correctly from a list containing multiple elements' do
-    list = LinkedList.new(1, 3, 4)
-    expect(list.shift).to eq(1)
-    expect(list.to_a).to eq([3, 4])
+    expect(sample_list.shift).to eq(1)
+    expect(sample_list.to_a).to eq([2, 3])
   end
 
   it 'should shift correctly from a list containing 1 element' do
@@ -59,6 +59,12 @@ describe LinkedList do
     list = LinkedList.new
     expect(->{ list.shift }).to raise_error(RuntimeError)
   end
+
+  specify 'to_ary should return an array identical to that returned by to_a' do
+    a = sample_list.to_a
+    ary = sample_list.to_ary
+    expect(ary).to eq(a)
+  end
 end
 end
 end

data/spec/trick_bag/enumerables/buffered_enumerable_spec.rb

@@ -73,6 +73,7 @@ module Enumerables
         (1..10).each do |n|
           expect(enumerator.next).to eq(n)
         end
+        expect(enumerator).to be_a(Enumerator)
         expect(enumerable.chunk_fetch_calls).to eq(3)
         expect(enumerable.object_count).to eq(12)
         ::TrickBag::Meta::Classes.undef_class(:BufferedEnumerableSubclass, TrickBag)
@@ -87,12 +88,12 @@ module Enumerables
 
           def initialize(chunk_size, array)
             super(chunk_size)
-            @array = array
+            @inner_enumerable = array
           end
 
           def fetch
-            num_times = [chunk_size, @array.size].min
-            num_times.times { @data << @array.shift }
+            num_times = [chunk_size, @inner_enumerable.size].min
+            num_times.times { @data << @inner_enumerable.shift }
           end
         end
       end

data/spec/trick_bag/enumerables/compound_enumerable_spec.rb

@@ -75,6 +75,10 @@ module Enumerables
         it "provides the 'take' method" do
           expect(->{ CompoundEnumerable.array_enumerable([1, 2, 3]).take(2)}).not_to raise_error
         end
+
+        it 'returns an Enumerator when each is called without a block' do
+          expect(CompoundEnumerable.array_enumerable([1, 2, 3]).each).to be_a(Enumerator)
+        end
       end
     end
 

data/spec/trick_bag/enumerables/endless_last_enumerable_spec.rb

@@ -29,10 +29,10 @@ module TrickBag::Enumerables
     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)
+      expect(e.take(20)).to eq(array + ([7] * 12))
     end
 
+
     it "should return == for 2 instances created with the same array" do
       array = (0..10).to_a
       e1 = EndlessLastEnumerable.new(array)
@@ -46,6 +46,22 @@ module TrickBag::Enumerables
       e2 = EndlessLastEnumerable.new([2, 1])
       expect(e1).not_to eq(e2)
     end
+
+    it 'returns an Enumerator when each is called without a block' do
+      expect(EndlessLastEnumerable.new([1]).each).to be_a(Enumerator)
+    end
+
+    context 'initializing with non-Array enumerables' do
+      specify 'it does not raise an error when initialized with a set' do
+        set = Set.new([1, 2])
+        expect(->() { EndlessLastEnumerable.new(set) }).not_to raise_error
+      end
+
+      specify 'it behaves correctly when initialized with a set' do
+        set = Set.new([1, 2])
+        expect(EndlessLastEnumerable.new(set).take(4)).to eq([1,2,2,2])
+      end
+    end
   end
 
 end

data/spec/trick_bag/enumerables/file_line_reader_spec.rb

@@ -106,6 +106,9 @@ nbc.com
       expect(get_lsof_lines.().size).to eq(0)
     end
 
+  it 'returns an Enumerator when each is called without a block' do
+    expect(subject.each).to be_a(Enumerator)
+  end
 
     specify "calling the enumerator's close method multiple times will not raise an error" do
       enumerator = subject.each

data/spec/trick_bag/enumerables/filtered_enumerable_spec.rb

@@ -30,6 +30,11 @@ module Enumerables
       expect(enumerator.next).to eq(4)
       expect(-> { enumerator.next }).to raise_error(StopIteration)
     end
+
+    it 'returns an Enumerator when each is called without a block' do
+      expect(FilteredEnumerable.new([]).each).to be_a(Enumerator)
+    end
+
   end
 end
 end

data/spec/trick_bag/validations/hashes_validations_spec.rb

@@ -30,7 +30,7 @@ module Validations
     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')
+      expect(missing_hash_entries_as_string(h, keys_to_test)).to eq("[:d, :b]")
     end
 
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: trick_bag
 version: !ruby/object:Gem::Version
-  version: 0.37.0
+  version: 0.38.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-20 00:00:00.000000000 Z
+date: 2014-03-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: os