duct_tape 0.0.4

data/lib/duct_tape/autoassociative_array.rb

@@ -0,0 +1,110 @@
+module Containers
+  class AutoassociativeArray
+    def initialize
+      @values = []
+      @columns = Hash.new { |hsh,key| hsh[key] = {} }
+      @hash = Hash.new { |hsh,key| hsh[key] = [] }
+      self
+    end
+
+    def insert(*args)
+      @values |= [args]
+      args.size.times do |i|
+        @columns[i][@values[-1][i]] = @values[-1]
+        @hash[@values[-1][i]].push(@values[-1])
+      end
+      self
+    end
+
+    def partial_match(*args)
+      matches = {}
+      ret = []
+      (1..args.size).reverse_each do |i|
+        args.combination(i) do |subset|
+          check = match_impl(*subset)
+          matches[subset] = check unless check.empty?
+        end
+        most_matches = matches.map { |k,v| v.size }.max
+        matches.reject! { |k,v| v.size < most_matches }
+        unless matches.empty?
+          matches.each { |k,v| ret |= v }
+          break
+        end
+      end
+      (ret && ret.one? ? ret[0] : ret)
+    end
+
+    def [](*args)
+      ret = match_impl(*args)
+      (ret && ret.one? ? ret[0] : ret)
+    end
+
+    def by_column(col, key)
+      (@columns.has_key?(col) && @columns[col].has_key?(key)) ? @columns[col][key] : nil
+    end
+
+    def empty?
+      @values.empty?
+    end
+
+    def length
+      @values.size
+    end
+    alias_method :size, :length
+
+    def method_missing(*args, &block)
+      ret = @values.__send__(*args, &block)
+      rebuild_hash
+      ret
+    end
+
+    def clear
+      @hash.clear
+      @values.clear
+      @columns.clear
+      self
+    end
+
+    def inspect
+      @values.inspect
+    end
+
+    def to_s
+      @values.to_s
+    end
+
+    def dup
+      ret = self.class.new
+      @values.each { |set| ret.insert(*set) }
+      ret
+    end
+
+    def <<(ary)
+      insert(*ary)
+    end
+
+    private
+
+    def rebuild_hash
+      @hash.clear
+      @columns.clear
+      @values.each_with_index do |ary,idx|
+        type_assert(ary, Array)
+        ary.size.times do |i|
+          @columns[i][@values[idx][i]] = @values[idx]
+          @hash[@values[idx][i]].push(@values[idx])
+        end
+      end
+      self
+    end
+
+    def match_impl(*args)
+      ret = @hash[args.first]
+      args[1..-1].each do |k|
+        ret &= @hash[k]
+        break if ret.empty?
+      end
+      ret
+    end
+  end
+end

data/lib/duct_tape.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'facets'
+Dir[__DIR__("ext", "*.rb")].each { |f| require f }
+
+if gem_installed?('algorithms')
+  require 'algorithms'
+  automatic_require "algorithms"
+end
+
+automatic_require

data/lib/ext/array.rb

@@ -0,0 +1,327 @@
+class Array
+  # Returns a copy of self deep_merged with another array
+  def deep_merge(second)
+    target = deep_dup
+    target.deep_merge!(second.deep_dup)
+    target
+  end
+
+  # Deep_merge self with another array
+  def deep_merge!(second)
+    return nil unless second
+    type_assert(second, Array)
+    changed = nil
+    second.each_index do |k|
+      if self[k].is_a?(Array) and second[k].is_a?(Array)
+        changed |= true if self[k].deep_merge!(second[k])
+      elsif self[k].is_a?(Hash) and second[k].is_a?(Hash)
+        changed |= true if self[k].deep_merge!(second[k])
+      elsif exclude?(second[k])
+        self << second[k]
+        changed |= true
+      end
+    end
+    return nil unless changed
+    self
+  end
+
+  # 3 Forms:
+  # Multiplied by an Integer, returns a single array with the repeated contents of self
+  # Multiplied by a String, returns self.join
+  # Multiplied by an Array, returns the set-wise cross-product of the two Arrays
+  def *(second)
+    ret = []
+    case second
+    when Integer
+      second.times { |i| ret += dup }
+    when String
+      return join(second)
+    when Array
+      each { |x| second.each { |y| ret << [x,y].flatten } }
+    else
+      raise TypeError.new("can't convert #{second.class} into Integer")
+    end
+    return ret
+  end
+
+  # Returns the set-wise n-th power of self. (The length of the return value
+  # is equal to: self.length ** n)
+  # e.g [0,1] ** 0  #=> []
+  # e.g [0,1] ** 1  #=> [[0], [1]]
+  # e.g [0,1] ** 2  #=> [[0, 0], [0, 1], [1, 0], [1, 1]]
+  # e.g [0,1] ** 3  #=> [[0, 0, 0], [0, 0, 1], [0, 1, 0], [0, 1, 1],
+  #                 #    [1, 0, 0], [1, 0, 1], [1, 1, 0], [1, 1, 1]]
+  def **(n)
+    type_assert(n, Integer)
+    ret = []
+    if n > 1
+      ret = dup
+      (n - 1).times {
+        temp = []
+        ret.each { |x| each { |y| temp << [x,y].flatten } }
+        ret = temp
+      }
+    elsif n == 1
+      ret = map { |item| [item] }
+    end
+    return ret
+  end
+
+  # Returns a new Array rejecting objects based on if the block-mapped
+  # values are unique
+  def uniq_by(&block)
+    ret = dup
+    ret.uniq_by!(&block)
+    ret
+  end
+
+  # 1st Form:
+  # [1,1,1].unanimous?                          #=> true
+  # [1,1,2].unanimous?                          #=> false
+  #
+  # 2nd Form:
+  # [1,1,1].unanimous?(1)                       #=> true
+  # [1,1,1].unanimous?(2)                       #=> false
+  #
+  # 3rd Form:
+  # [1,1,1].unanimous? { |i| i == 2 }           #=> true
+  #
+  # 4th Form:
+  # [1,3,5].unanimous?(true) { |i| i % 2 == 1 } #=> true
+  def unanimous?(arg=nil, &block)
+    ret = true
+    cmp = (arg.nil? ? (block_given? ? block[first] : first) : arg)
+    each_with_index do |elem,index|
+      next if index == 0 && arg.nil?
+      ret &&= (block_given? ? (cmp == block[elem]) : (cmp == elem))
+      break unless ret
+    end
+    ret
+  end
+
+  # Converts certain Arrays to Hashes:
+  # ["a","b","c"].to_h                  #=> {0=>"a", 1=>"b", 2=>"c"}
+  # [[1,2], [3,4]].to_h                 #=> {1=>2, 3=>4}
+  # [{1 => 2}, {3 => 4}].to_h           #=> {1=>2, 3=>4}
+  # [{"name" => 1, "value" => 2},
+  #  {"name" => 3, "value" => 4}].to_h  #=> {1=>2, 3=>4}
+  # [{:x => 1, :y => 2},
+  #  {:x => 3, :y => 4}].to_h(:x, :y)   #=> {1=>2, 3=>4}
+  # [{1 => 2, 3 => 4}, {1 => 4}].to_h   #=> {1=>[2, 4], 3=>4}
+  def to_h(name_key="name", value_key="value")
+    #raise "Elements are not unique!" unless self == uniq
+    ret = {}
+    collisions = Hash.new { |hsh,key| hsh[key] = 0 }
+    each_with_index do |elem,index|
+      temp = {}
+      if elem.is_a?(Hash)
+        temp = elem
+        if elem[name_key] and elem[value_key] and elem.length == 2
+          temp = {elem[name_key] => elem[value_key]}
+        elsif elem[name_key.to_s] and elem[value_key.to_s] and elem.length == 2
+          temp = {elem[name_key.to_s] => elem[value_key.to_s]}
+        elsif elem[name_key.to_sym] and elem[value_key.to_sym] and elem.length == 2
+          temp = {elem[name_key.to_sym] => elem[value_key.to_sym]}
+        end
+      elsif elem.is_a?(Array)
+        if elem.length == 2
+          temp[elem.first] = elem.last
+        elsif elem.length > 2
+          temp[elem.first] = elem[1..-1]
+        else
+          temp[index] = elem.first
+        end
+      else
+        temp[index] = elem
+      end
+      temp.each do |k,v|
+        if ret.has_key?(k)
+          if collisions[k] == 0
+            if ret[k] != v
+              collisions[k] += 1
+              ret[k] = [ret[k], v]
+            end
+          elsif ret[k].exclude?(v)
+            collisions[k] += 1
+            ret[k] << v
+          end
+        else
+          ret[k] = v
+        end
+      end
+    end
+    ret
+  end
+  alias_method :to_hash, :to_h
+
+  # Creates a hash with keys equal to the contents of self and values equal to the
+  # mapped array's values
+  def map_to_h(&block)
+    [self, map(&block)].transpose.to_h
+  end
+  alias_method :map_to_hash, :map_to_h
+
+  # Chunks an array into segments of maximum length
+  # [1,2,3,4,5,6,7,8,9,10].chunk(3) #=> [[1,2,3], [4,5,6], [7,8,9], [10]]
+  def chunk(max_length=nil, &block)
+    if ::RUBY_VERSION >= "1.9" && block_given?
+      super(&block)
+    else
+      each_slice(max_length).to_a
+    end
+  end
+
+  def not_empty?
+    !empty?
+  end
+
+  #
+  # Statistics from:
+  # http://github.com/christianblais/utilities.git
+  #
+
+  # Add each object of the array to each other in order to get the sum, as long as all objects respond to + operator
+  def sum
+    flatten.compact.inject(:+)
+  end
+
+  def product
+    flatten.compact.inject(:*)
+  end
+
+  # Calculate squares of each item
+  def squares
+    map { |i| i ** 2 }
+  end
+
+  # Return a new array containing the rank of each value
+  # Ex: [1, 2, 2, 8, 9] #=> [0.0, 1.5, 1.5, 3.0, 4.0]
+  def ranks(already_sorted=false)
+    a = already_sorted ? self : sort
+    map { |i| (a.index(i) + a.rindex(i)) / 2.0 }
+  end
+
+  # Calculate square roots of each item
+  def sqrts
+    map { |i| Math.sqrt(i) }
+  end
+
+  # Calculate the arithmetic mean of the array, as long as all objects respond to / operator
+  def mean
+    a = flatten.compact
+    (a.size > 0) ? a.sum.to_f / a.size : 0.0
+  end
+  alias_method :average, :mean
+
+  # TODO - Geometric mean
+
+  # Calculate the number of occurences for each element of the array
+  def frequencies
+    inject(Hash.new(0)) { |h,v| h[v] += 1; h }
+  end
+
+  # Return the variance of self
+  def variance(population=false)
+    m = mean.to_f
+    map { |v| (v - m) ** 2 }.sum / (size - (population ? 0 : 1))
+  end
+
+  # Return the (sample|population) standard deviation of self
+  # If population is set to true, then we consider the dataset as the complete population
+  # Else, we consider the dataset as a sample, so we use the sample standard deviation (size - 1)
+  def standard_deviation(population=false)
+    size > 1 ? Math.sqrt(variance(population)) : 0.0
+  end
+  alias_method :std_dev, :standard_deviation
+
+  # Return the median of sorted self
+  def median(already_sorted=false)
+    return nil if empty?
+    a = already_sorted ? self : sort
+    m_pos = size / 2
+    size % 2 == 1 ? a[m_pos] : (a[m_pos-1] + a[m_pos]).to_f / 2
+  end
+  alias_method :second_quartile, :median
+
+  # Return the first quartile of self
+  def first_quartile(already_sorted=false)
+    return nil if size < 4
+    a = already_sorted ? self : sort
+    a[0..((size / 2) - 1)].median(true)
+  end
+  alias_method :lower_quartile, :first_quartile
+
+  # Return the last quartile of self
+  def last_quartile(already_sorted=false)
+    return nil if size < 4
+    a = already_sorted ? self : sort
+    a[((size / 2) + 1)..-1].median(true)
+  end
+  alias_method :upper_quartile, :last_quartile
+
+  # Return an array containing the first, the second and the last quartile of self
+  def quartiles(already_sorted=false)
+    a = already_sorted ? self : sort
+    [a.first_quartile(true), a.median(true), a.last_quartile(true)]
+  end
+
+  # Calculate the interquartile range of self
+  def interquartile_range(already_sorted=false)
+    return nil if size < 4
+    a = already_sorted ? self : sort
+    a.last_quartile - a.first_quartile
+  end
+
+  # Return a hash of modes with their corresponding occurences
+  def modes
+    fre = frequencies
+    max = fre.values.max
+    fre.select { |k, f| f == max }
+  end
+
+  # Return the midrange of sorted self
+  def midrange(already_sorted=false)
+    return nil if empty?
+    a = already_sorted ? self : sort
+    (a.first + a.last) / 2.0
+  end
+
+  # Return the statistical range of sorted self
+  def statistical_range(already_sorted=false)
+    return nil if empty?
+    a = already_sorted ? self : sort
+    (a.last - a.first)
+  end
+
+  # Return all statistics from self in a simple hash
+  def statistics(already_sorted=false)
+    sorted = sort
+
+    {
+      :first => self.first,
+      :last => self.last,
+      :size => self.size,
+      :sum => self.sum,
+      :squares => self.squares,
+      :sqrts => self.sqrts,
+      :min => self.min,
+      :max => self.max,
+      :mean => self.mean,
+      :frequencies => self.frequencies,
+      :variance => self.variance,
+      :standard_deviation => self.standard_deviation,
+      :population_variance => self.variance(true),
+      :population_standard_deviation => self.standard_deviation(true),
+      :modes => self.modes,
+
+      # Need to be sorted...
+      :ranks => sorted.ranks(true),
+      :median => sorted.median(true),
+      :midrange => sorted.midrange(true),
+      :statistical_range => sorted.statistical_range(true),
+      :quartiles => sorted.quartiles(true),
+      :interquartile_range => sorted.interquartile_range(true)
+    }
+  end
+  alias_method :stats, :statistics
+end

data/lib/ext/boolean.rb

@@ -0,0 +1,3 @@
+module Boolean; end
+class FalseClass; include Boolean; end
+class TrueClass; include Boolean; end

data/lib/ext/datetime.rb

@@ -0,0 +1,7 @@
+require 'date'
+
+class DateTime < Date
+  def to_time
+    Time.parse(self.to_s)
+  end
+end

data/lib/ext/dir.rb

@@ -0,0 +1,59 @@
+require 'pathname'
+
+class Dir
+  # Determine the relative path based on pwd
+  def self.relative_path(abs_path, from=Dir.pwd)
+    Pathname.new(abs_path).expand_path.relative_path_from(Pathname.new(from)).to_s
+  end
+
+  def self.absolute_path(path)
+    Pathname.new(path).expand_path.to_s
+  end
+
+  def self.empty?(dir)
+    entries(dir).join == "..."
+  end
+
+  def relative_path
+    Dir.relative_path(self.path)
+  end
+
+  def empty?
+    Dir.empty?(self)
+  end
+
+  def absolute_path
+    Dir.absolute_path(self.path)
+  end
+
+  def children
+    entries.map_to_h { |name| Pathname.join(absolute_path, name) }
+  end
+  alias_method :to_h, :children
+
+  def [](*path)
+    pathname = Pathname.new(File.join(path.flatten))
+    return nil unless pathname.exist?
+    pathname
+  end
+
+  def /(path)
+    self[path]
+  end
+
+  def files
+    children.values.reject { |v| !(File.file?(v)) }
+  end
+
+  def directories
+    children.values.reject { |v| !(File.directory?(v)) }
+  end
+
+  def writable?
+    File.writable?(self.path)
+  end
+
+  def readable?
+    File.readable?(self.path)
+  end
+end

data/lib/ext/file.rb

@@ -0,0 +1,40 @@
+require 'pathname'
+
+class File
+
+  def self.relative_path(abs_path, pwd=Dir.pwd)
+    Dir.relative_path(abs_path, pwd)
+  end
+
+  def self.absolute_path(path)
+    Dir.absolute_path(path)
+  end
+
+  def relative_path
+    Dir.relative_path(self.path)
+  end
+
+  def absolute_path
+    Dir.absolute_path(self.path)
+  end
+
+  def dirname
+    File.dirname(self.path)
+  end
+
+  def basename(*args)
+    File.basename(self.path, *args)
+  end
+
+  def writable?
+    File.writable?(self.path)
+  end
+
+  def readable?
+    File.readable?(self.path)
+  end
+
+  def executable?
+    File.executable?(self.path)
+  end
+end

data/lib/ext/hash.rb

@@ -0,0 +1,83 @@
+class Hash
+  # Merges self with another second, recursively.
+  #
+  # This code was lovingly stolen from some random gem:
+  # http://gemjack.com/gems/tartan-0.1.1/classes/Hash.html
+  #
+  # Thanks to whoever made it.
+  #
+  # Modified to provide same functionality with Arrays
+
+  def deep_merge(second)
+    target = deep_dup
+    target.deep_merge!(second.deep_dup)
+    target
+  end
+
+  # From: http://www.gemtacular.com/gemdocs/cerberus-0.2.2/doc/classes/Hash.html
+  # File lib/cerberus/utils.rb, line 42
+  # Modified to provide same functionality with Arrays
+
+  def deep_merge!(second)
+    return nil unless second
+    type_assert(second, Hash)
+    second.each_pair do |k,v|
+      if self[k].is_a?(Array) and second[k].is_a?(Array)
+        self[k].deep_merge!(second[k])
+      elsif self[k].is_a?(Hash) and second[k].is_a?(Hash)
+        self[k].deep_merge!(second[k])
+      else
+        self[k] = second[k]
+      end
+    end
+  end
+
+  def to_h
+    self
+  end
+  alias_method :to_hash, :to_h
+
+  def select_keys(other, &block)
+    target = dup
+    target.select_keys!(other, &block)
+    target
+  end
+  alias_method :&, :select_keys
+
+  def select_keys!(other, &block)
+    type_assert(other, Array, Hash)
+    unless block_given?
+      other = other.keys if Hash === other
+      block = proc { |k| other.include?(k) }
+    end
+    self.reject! { |key,val| !block[key] }
+  end
+
+  def reject_keys(other, &block)
+    target = dup
+    target.reject_keys!(other, &block)
+    target
+  end
+  alias_method :-, :reject_keys
+
+  def reject_keys!(other, &block)
+    type_assert(other, Array, Hash)
+    unless block_given?
+      other = other.keys if Hash === other
+      block = proc { |k| other.include?(k) }
+    end
+    self.reject! { |key,val| block[key] }
+  end
+
+  def chunk(max_length=nil, &block)
+    if ::RUBY_VERSION >= "1.9" && block_given?
+      super(&block)
+    else
+      each_slice(max_length).to_a.map! { |ary| ary.to_h }
+    end
+  end
+
+  def not_empty?(arg)
+    !empty?
+  end
+end