trick_bag 0.30.0

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in trick_bag.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,8 @@
+# For running Guard to rerun tests whenever files change.
+# Run 'bundle exec guard' from project root.
+guard :rspec do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Keith Bennett
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,32 @@
+# TrickBag
+
+This gem is a collection of useful classes and modules for Ruby development.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'trick_bag'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install trick_bag
+
+## Usage
+
+See the unit tests in the spec directory tree for usage examples.
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/RELEASE_NOTES.md

@@ -0,0 +1,3 @@
+## v0.30.0
+
+* Initial public version.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/trick_bag.rb

@@ -0,0 +1,7 @@
+# Load all *.rb files in lib/trick_bag and below.
+# Use a lambda so that the intermediate variables do not survive this file.
+->() {
+  start_dir = File.join(File.dirname(__FILE__), 'trick_bag') # the lib directory
+  file_mask = "#{start_dir}/**/*.rb"
+  Dir[file_mask].each { |file| require file }
+}.()

data/lib/trick_bag/collections/linked_list.rb

@@ -0,0 +1,97 @@
+module TrickBag
+module Collections
+
+# Linked List based on git@github.com:neilparikh/ruby-linked-list.git,
+# but modified somewhat.
+
+class LinkedList
+
+  class Node
+    attr_accessor :value, :next
+
+    def initialize(value, next_node = nil)
+      @value = value
+      @next = next_node
+    end
+  end
+
+  attr_accessor :first
+  attr_reader :length
+
+  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
+  def push(value)
+    node = Node.new(value)
+    current_node = @first
+    while current_node.next != nil
+      current_node = current_node.next
+    end
+    current_node.next = node
+    @length += 1
+    self
+  end
+
+  # Removes last element from list
+  # returns that element's value
+  def pop
+    case(@length)
+
+      when 0
+        raise "List is empty"
+
+      when 1
+        @length = 0
+        value = @first.value
+        @first = nil
+        value
+
+      else
+        current = @first
+        while current.next && current.next.next
+          current = current.next
+        end
+        value = current.next.value
+        current.next = nil
+        @length -= 1
+        value
+    end
+  end
+
+
+  # adds value to beginning of list
+  # returns self
+  def unshift(value)
+    node = Node.new(value, @first)
+    @first = node
+    @length += 1
+    self
+  end
+
+  # Removes first element from list
+  # returns that element's value
+  def shift
+    raise "List is empty" if @length < 1
+    to_return = @first.value
+    @first = @first.next
+    @length -= 1
+    to_return
+  end
+
+  def to_a
+    current_node = @first
+    array = []
+    while current_node != nil
+      array << current_node.value
+      current_node = current_node.next
+    end
+    array
+  end
+end
+end
+end

data/lib/trick_bag/enumerables/buffered_enumerable.rb

@@ -0,0 +1,90 @@
+# Provides the plumbing for an enumerator that, in order to serve objects in each(),
+# fetches them in chunks.
+#
+# 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.
+#
+# The fetch method and fetcher lambda modify the instance's data array directly,
+# to avoid the need to allow the lambda to modify the data array reference,
+# 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
+  attr_reader :chunk_size
+
+  attr_access :protected, :protected, :data
+  attr_access :public,    :private,   :chunk_count, :fetch_count, :yield_count
+
+
+  def self.create_with_lambdas(chunk_size, fetcher, fetch_notifier)
+    instance = self.new(chunk_size)
+    instance.fetcher = fetcher
+    instance.fetch_notifier = fetch_notifier
+    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;
+  #        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.
+  def initialize(chunk_size)
+    @chunk_size = chunk_size
+    @data = []
+    @chunk_count = 0
+    @fetch_count = 0
+    @yield_count = 0
+  end
+
+
+  # Unless you use self.create_with_lambdas to create your instance,
+  # you'll need to override this method in your subclass.
+  def fetch
+    fetcher.(data, chunk_size) if fetcher
+  end
+
+
+  # Unless you use self.create_with_lambdas to create your instance,
+  # you'll need to override this method in your subclass.
+  def fetch_notify
+    fetch_notifier.(data) if fetch_notifier
+  end
+
+
+  def each
+    return to_enum unless block_given?
+
+    last_chunk = false
+    loop do
+      if data.empty?
+        return if last_chunk
+        fetch
+        @chunk_count += 1
+        return if data.empty?
+        self.fetch_count = self.fetch_count + data.size
+        last_chunk = true if data.size < chunk_size
+        fetch_notify
+      end
+
+      self.yield_count = self.yield_count + 1
+      object_to_yield = data.shift
+      yield(object_to_yield)
+    end
+  end
+
+end
+end
+end

data/lib/trick_bag/enumerables/compound_enumerable.rb

@@ -0,0 +1,114 @@
+require 'trick_bag/collections/linked_list'
+require 'trick_bag/meta/classes'
+
+module TrickBag
+module Enumerables
+
+# An enumerator Used to provide all combinations of a set of Enumerables.
+
+# For example, for blood types [:a, :b, :ab, :o] and rh [:+, :-],
+# provides an enumerator whose 'each' method gives:
+#
+# [:a, :+]
+# [:a, :-]
+# [:b, :+]
+# [:b, :-]
+# [:ab, :+]
+# [:ab, :-]
+# [:o, :+]
+# [:o, :-]
+#
+# Initialized with enumerables whose 'each' method returns an Enumerator
+# when no block is provided.
+#
+# Guaranteed to follow the order as shown above, that is, each value of
+# the first enumerable will be processed in its entirety before advancing
+# to the next value.
+#
+# Can be used with an arbitrary number of enumerables.
+class CompoundEnumerable
+
+  include Enumerable
+  extend ::TrickBag::Meta::Classes
+
+  attr_reader :enum_count, :keys
+  private_attr_reader :enumerables
+  attr_reader :mode
+
+  # Creates a compound enumerable that returns a hash whenever 'each' is called
+  def self.hash_enumerable(keys, *enumerables)
+    self.new(:yields_hashes, keys, *enumerables)
+  end
+
+
+  # Creates a compound enumerable that returns an array whenever 'each' is called
+  def self.array_enumerable(*enumerables)
+    self.new(:yields_arrays, nil, *enumerables)
+  end
+
+
+
+  def initialize(mode, keys, *enumerables)
+
+    validate_inputs = ->do
+      raise "Mode must be either :yields_arrays or :yields_hashes" unless [:yields_arrays, :yields_hashes].include?(mode)
+      raise "Keys not provided" if mode == :yields_hashes && (! keys.is_a?(Array))
+      raise "No enumerables provided" if enumerables.empty?
+
+      if mode == :yields_hashes && (keys.size != enumerables.size)
+        raise "Key array size (#{keys.size}) is different from enumerables size (#{enumerables.size})."
+      end
+
+    end
+
+    validate_inputs.()
+    @enumerables = enumerables
+    @enum_count = enumerables.size
+    @mode = mode
+    @keys = keys
+  end
+
+
+  def each(&block)
+    return to_enum unless block_given?
+    return if enum_count == 0
+    initial_value = mode == :yields_arrays ? [] : {}
+    each_multi_enumerable(0, ::TrickBag::Collections::LinkedList.new(*@enumerables).first, initial_value, &block)
+  end
+
+
+  # This method will be called recursively down the list of enumerables.
+  # @param node will advance to the next node for each recursive call
+  # @param values will be a list of values collected on the stack
+  def each_multi_enumerable(depth, node, values, &block)
+    enumerable = node.value
+    is_deepest_enumerable = node.next.nil?
+
+    as_array = ->(thing) do
+      new_value_array = values + [thing]
+      if is_deepest_enumerable
+        yield *new_value_array
+      else
+        each_multi_enumerable(depth + 1, node.next, new_value_array, &block)
+      end
+    end
+
+    as_hash = ->(thing) do
+      key = keys[depth]
+      new_values = values.clone
+      new_values[key] = thing
+      if is_deepest_enumerable
+        yield new_values
+      else
+        each_multi_enumerable(depth + 1, node.next, new_values, &block)
+      end
+      new_values
+    end
+
+    enumerable.each do |thing|
+      mode == :yields_arrays ? as_array.(thing) : as_hash.(thing)
+    end
+  end
+end
+end
+end

data/lib/trick_bag/enumerables/filtered_enumerable.rb

@@ -0,0 +1,32 @@
+module TrickBag
+module Enumerables
+
+
+# Decorator that wraps an Enumerable and takes a filter predicate
+# to determine whether or not objects from the wrapped enumerator
+# should be processed.
+#
+# The filter is an optional parameter on the constructor, but can
+# also be set after creation with a mutator.
+class FilteredEnumerable
+
+  include Enumerable
+
+  attr_reader :inner_enum
+  attr_accessor :filter
+
+  def initialize(inner_enum, filter = nil)
+    @inner_enum = inner_enum
+    @filter = filter
+  end
+
+  def each
+    return to_enum unless block_given?
+
+    inner_enum.each do |thing|
+      yield thing if filter.nil? || filter.(thing)
+    end
+  end
+end
+end
+end