trick_bag 0.30.0

data/lib/trick_bag/io/temp_files.rb

@@ -0,0 +1,22 @@
+module TrickBag
+module Io
+module TempFiles
+
+    module_function
+
+    def self.file_containing(text, file_prefix = '')
+      filespec = nil
+      begin
+        Tempfile.open(file_prefix) do |file|
+          file << text
+          filespec = file.path
+        end
+        yield(filespec)
+      ensure
+        File.delete filespec if filespec && File.exist?(filespec)
+      end
+    end
+
+  end
+end
+end

data/lib/trick_bag/io/text_mode_status_updater.rb

@@ -0,0 +1,59 @@
+module TrickBag
+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).
+class TextModeStatusUpdater
+
+
+  def initialize(text_generator, outstream = $stdout, force_output_non_tty = false)
+    @text_generator = text_generator
+    @outstream = outstream
+    @force_output_non_tty = force_output_non_tty
+    @first_time = true
+  end
+
+  def clear_to_end_of_line_text
+    "\x1b[2K"
+  end
+
+  def save_cursor_position_text
+    "\x1b[s"
+  end
+
+  def go_to_start_of_line_text
+    "\x1b0`"
+  end
+
+  def move_cursor_left_text(num_chars)
+    "\x1b[#{num_chars}D"
+  end
+
+  def restore_cursor_position_text
+    "\x1b[u"
+  end
+
+  def insert_blank_chars_text(num_chars)
+    "\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

@@ -0,0 +1,87 @@
+# Provides useful additions to class Class.
+
+module TrickBag
+module Meta
+module Classes
+
+    VALID_ACCESS_MODES = [:public, :protected, :private, :none]
+
+    # Enables concise and flexible creation of getters and setters
+    # whose access modes for reading and writing may be different.
+    #
+    # Access modes can be: :public, :protected, :private, :none
+    #
+    # For example:
+    #
+    #     attr_access(:private, :none, :foo, :bar)
+    #
+    # will create accessors for @foo and @bar, and make them private,
+    # but will not create any mutators.
+    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]."
+          end
+        end
+      end
+
+      validate_input.()
+
+      unless read_access == :none
+        attr_reader(*attrs)
+        send(read_access, *attrs)
+      end
+
+      unless write_access == :none
+        attr_writer(*attrs)
+        writers = attrs.map { |attr| "#{attr}=".to_sym }
+        send(write_access, *writers)
+      end
+    end
+
+
+    def private_attr_reader(*attrs)
+      attr_access(:private, :none, *attrs)
+    end
+
+
+    def private_attr_writer(*attrs)
+      attr_access(:none, :private, *attrs)
+    end
+
+
+    def private_attr_accessor(*attrs)
+      attr_access(:private, :private, *attrs)
+    end
+
+
+    def protected_attr_reader(*attrs)
+      attr_access(:protected, :none, *attrs)
+    end
+
+
+    def protected_attr_writer(*attrs)
+      attr_access(:none, :protected, *attrs)
+    end
+
+
+    def protected_attr_accessor(*attrs)
+      attr_access(:protected, :protected, *attrs)
+    end
+
+
+    def class?(name, scope = Object)
+      scope.const_defined?(name) && scope.const_get(name).is_a?(Class)
+    end; module_function :class?
+
+
+    def undef_class(name, scope = Object)
+      class_existed = class?(name, scope)
+      scope.send(:remove_const, name) if class_existed
+      class_existed
+    end; module_function :undef_class
+
+  end
+end
+end

data/lib/trick_bag/numeric/multi_counter.rb

@@ -0,0 +1,44 @@
+module TrickBag
+module Numeric
+
+# Counts the results of any resolver comparisons made.
+# Like a hash, but does not allow []=; increment is the only way to modify a value.
+class MultiCounter
+
+  attr_accessor :name
+
+  def initialize(name = '')
+    @name = name
+    @counts = Hash.new(0)
+  end
+
+  def add_keys(keys)
+    keys.each { |key| @counts[key] = 0 }
+  end
+
+  def increment(key)
+    @counts[key] += 1
+  end
+
+  def [](key)
+    @counts[key]
+  end
+
+  def keys
+    @counts.keys
+  end
+
+  def key_exists?(key)
+    keys.include?(key)
+  end
+
+  def to_hash
+    @counts.clone
+  end
+
+  def to_s
+    "#{self.class} '#{name}': #{@counts.to_s}"
+  end
+end
+end
+end

data/lib/trick_bag/numeric/totals.rb

@@ -0,0 +1,49 @@
+module TrickBag
+module Numeric
+module Totals
+
+  module_function
+
+  # @inputs an enumerable of numbers
+  # @return a collection containing the corresponding fractions of total of those numbers
+  def map_fraction_of_total(inputs)
+    return [] if inputs.size == 0
+    sum = Float(inputs.inject(:+))
+    inputs.map { |n| n / sum }
+  end
+
+
+  # @inputs an enumerable of numbers
+  # @return a collection containing the corresponding percents of total of those numbers
+  def map_percent_of_total(inputs)
+    map_fraction_of_total(inputs).map { |n| n * 100 }
+  end
+
+
+  # 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 }.
+  def fraction_of_total_hash(the_hash)
+    new_hash = percent_of_total_hash(the_hash)
+    new_hash.keys.each do |key|
+      new_hash[key] = new_hash[key] / 100.0
+    end
+    new_hash
+  end
+
+
+  # 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 }.
+  def percent_of_total_hash(the_hash)
+    sum = Float(the_hash.values.inject(:+))
+    keys = the_hash.keys
+    keys.each_with_object({}) do |key, percent_total_hash|
+      percent_total_hash[key] = 100 * the_hash[key] / sum
+    end
+  end
+end
+end
+end

data/lib/trick_bag/operators/operators.rb

@@ -0,0 +1,13 @@
+module TrickBag
+module Operators
+
+  module_function
+
+  # Returns whether or not all passed values are equal
+  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
+    values[1..-1].all? { |value| value == values.first }
+  end
+end
+end

data/lib/trick_bag/timing/timing.rb

@@ -0,0 +1,47 @@
+require 'trick_bag/io/text_mode_status_updater'
+
+module TrickBag
+module Timing
+
+  module_function
+
+
+  # Calls a predicate proc repeatedly, sleeping the specified interval
+  # between calls, and giving up after the specified number of seconds.
+  # Displays elapsed and remaining times on the terminal.
+  #
+  # @param predicate something that can be called with .() or .call
+  #   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
+  def retry_until_true_or_timeout(
+      predicate, sleep_interval, timeout_secs, output_stream = $stdout)
+
+    success = false
+    start_time = Time.now
+    end_time = start_time + timeout_secs
+    time_elapsed = nil
+    time_to_go = nil
+    text_generator = ->() { "%9.3f   %9.3f" % [time_elapsed, time_to_go] }
+    status_updater = ::TrickBag::Io::TextModeStatusUpdater.new(text_generator, output_stream)
+
+    loop do
+      now = Time.now
+      time_elapsed = now - start_time
+      time_to_go = end_time - now
+      time_up = now >= end_time
+
+      break if time_up
+
+      success = !! predicate.()
+      break if success
+
+      status_updater.print
+      sleep(sleep_interval)
+    end
+    print "\n"
+    success
+  end
+
+end
+end

data/lib/trick_bag/validations/hash_validations.rb

@@ -0,0 +1,21 @@
+module TrickBag
+module Validations
+module HashValidations
+  module_function
+
+  # 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) }
+  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)
+    missing_keys.empty? ? nil : missing_keys.join(', ')
+  end
+
+end
+end
+end

data/lib/trick_bag/validations/object_validations.rb

@@ -0,0 +1,26 @@
+module TrickBag
+module Validations
+module ObjectValidations
+
+  module_function
+
+
+  # Returns an array containing each symbol in vars for which the
+  # corresponding instance variable  in the specified object is nil.
+  def nil_instance_vars(object, vars)
+    vars = Array(vars)
+    vars.select { |var| object.instance_variable_get(var).nil? }
+  end
+
+  # For each symbol in vars, checks to see that the corresponding instance
+  # variable in the specified object is not nil.
+  # If any are nil, raises an error listing the nils.
+  def raise_on_nil_instance_vars(object, vars)
+    nil_vars = nil_instance_vars(object, vars)
+    unless nil_vars.empty?
+      raise "The following instance variables were nil: #{nil_vars.join(', ')}."
+    end
+  end
+end
+end
+end

data/lib/trick_bag/version.rb

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

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'rspec'
+require 'pry'
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    # disable the `should` syntax; it's deprecated and will later be removed
+    c.syntax = :expect
+  end
+end

data/spec/trick_bag/collections/linked_list_spec.rb

@@ -0,0 +1,64 @@
+# Adapted from Test Unit test at https://github.com/neilparikh/ruby-linked-list.
+
+require_relative '../../spec_helper'
+require 'trick_bag/collections/linked_list'
+
+module TrickBag
+module Collections
+
+describe LinkedList do
+
+  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)
+  end
+
+  it 'should push correctly' do
+    list = LinkedList.new(1)
+    list.push(2)
+    expect(list.to_a).to eq([1, 2])
+  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])
+  end
+
+  it 'should pop from a list of 1 element correctly' do
+    list = LinkedList.new(1)
+    expect(list.pop).to eq(1)
+    expect(list.to_a).to eq([])
+  end
+
+  it 'should raise an error when popping from an empty list' do
+    list = LinkedList.new
+    expect(list.length).to eq(0)
+    expect(->{ list.pop }).to raise_error(RuntimeError)
+  end
+
+  it 'should unshift correctly' do
+    list = LinkedList.new(1)
+    list.unshift(0)
+    expect(list.to_a).to eq([0,1])
+  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])
+  end
+
+  it 'should shift correctly from a list containing 1 element' do
+    list = LinkedList.new(1)
+    expect(list.shift).to eq(1)
+    expect(list.to_a).to eq([])
+  end
+
+  it 'should raise an error when shifting from an empty list' do
+    list = LinkedList.new
+    expect(->{ list.shift }).to raise_error(RuntimeError)
+  end
+end
+end
+end