functional-ruby 0.7.7 → 1.0.0

data/lib/functional/platform.rb

@@ -1,120 +0,0 @@
-require 'rbconfig'
-
-module Functional
-
-  class Platform
-
-    attr_reader :ruby_version
-    attr_reader :host_os
-    attr_reader :ruby_name
-
-    def rubies
-      @rubies ||= [
-        :ruby,     # C Ruby (MRI) or Rubinius, but NOT Windows
-        :ruby_18,  # ruby AND version 1.8
-        :ruby_19,  # ruby AND version 1.9
-        :mri,      # Same as ruby, but not Rubinius
-        :mri_18,   # mri AND version 1.8
-        :mri_19,   # mri AND version 1.9
-        :mri_20,   # mri AND version 20
-        :rbx,      # Same as ruby, but only Rubinius (not MRI)
-        :jruby,    # JRuby
-        :mswin,    # Windows
-        :mingw,    # Windows 'mingw32' platform (aka RubyInstaller)
-        :mingw_18, # mingw AND version 1.8
-        :mingw_19, # mingw AND version 1.9
-        :mingw_20, # mingw AND version 2.0
-      ].freeze
-    end
-
-    def initialize(*args)
-      unless args.size == 0 || args.size == 3
-        raise ArgumentError.new("wrong number of arguments (#{args.size} for 0 or 3)")
-      end
-
-      @ruby_version = args[0] || RUBY_VERSION || RbConfig::CONFIG['ruby_version']
-      @host_os = args[1] || RbConfig::CONFIG['host_os']
-      @ruby_name = args[2] || RbConfig::CONFIG['ruby_install_name']
-    end
-
-    def windows?
-      truthy(@host_os =~ /win32/i) || truthy(@host_os =~ /mingw32/i)
-    end
-
-    def linux?
-      truthy(@host_os =~ /linux/i)
-    end
-
-    def osx?
-      truthy(@host_os =~ /darwin/i)
-    end
-
-    def ruby?
-      mri? || rbx?
-    end
-
-    def ruby_18?
-      ruby? && truthy(@ruby_version =~ /^1\.8/)
-    end
-
-    def ruby_19?
-      ruby? && truthy(@ruby_version =~ /^1\.9/)
-    end
-
-    def ruby_20?
-      ruby? && truthy(@ruby_version =~ /^2\.0/)
-    end
-
-    def mri?
-      truthy(@ruby_name =~ /^ruby$/i) && !windows?
-    end
-
-    def mri_18?
-      mri? && truthy(@ruby_version =~ /^1\.8/)
-    end
-
-    def mri_19?
-      mri? && truthy(@ruby_version =~ /^1\.9/)
-    end
-
-    def mri_20?
-      mri? && truthy(@ruby_version =~ /^2\.0/)
-    end
-
-    def rbx?
-      truthy(@ruby_name =~ /^rbx$/i)
-    end
-
-    def jruby?
-      truthy(@ruby_name =~ /^jruby$/i)
-    end
-
-    def mswin?
-      truthy(@host_os =~ /win32/i)
-    end
-
-    def mingw?
-      truthy(@host_os =~ /mingw32/i)
-    end
-
-    def mingw_18?
-      mingw? && truthy(@ruby_version =~ /^1\.8/)
-    end
-
-    def mingw_19?
-      mingw? && truthy(@ruby_version =~ /^1\.9/)
-    end
-
-    def mingw_20?
-      mingw? && truthy(@ruby_version =~ /^2\.0/)
-    end
-
-    private
-
-    def truthy(value)
-      return value == 0
-    end
-  end
-
-  PLATFORM = Functional::Platform.new
-end

data/lib/functional/search.rb

@@ -1,132 +0,0 @@
-module Functional
-
-  module Search
-    extend self
-
-    # Conduct a linear search against an unsorted collection and
-    # return the index where the item was found. Returns nil if
-    # the item is not found.
-    #
-    # The default behavior is to search the entire collections. The
-    # options hash can be used to provide optional low and high indexes
-    # (:imin and :imax). If either :imin or :imax is out of range the
-    # natural collection boundary will be used.
-    # 
-    # When a block is given the block will be applied to both arguments.
-    # Using a block in this way allows computation against a specific field
-    # in a data set of hashes or objects.
-    #
-    # @yield iterates over each element in the data set
-    # @yieldparam item each element in the data set
-    #
-    # @param [Enumerable] data the data set to search
-    # @param [Hash] opts search options
-    # @param [Block] block optional block for per-item processing
-    #
-    # @option opts [Integer] :imin minimum index to search
-    # @option opts [Integer] :imax maximum index to search
-    #
-    # @return [Array] the index where the item is found or nil when the
-    #   collection is empty or nil
-    def linear_search(data, key, opts={}, &block)
-
-      imin, imax = check_search_options(data, key, opts, &block)
-      return nil if imin.nil? || imax.nil?
-      return imin if imin == imax
-
-      index = nil
-      (imin..imax).each do |i|
-        if (block_given? && yield(data[i]) == key) || data[i] == key
-          index = i
-          break
-        end
-      end
-
-      return index
-    end
-
-    # Conduct a binary search against the sorted collection and return
-    # a pair of indexes indicating the result of the search. The
-    # indexes will be returned as a two-element array.
-    #
-    # The default behavior is to search the entire collections. The
-    # options hash can be used to provide optional low and high indexes
-    # (:imin and :imax). If either :imin or :imax is out of range the
-    # natural collection boundary will be used.
-    # 
-    # When a block is given the block will be applied to both arguments.
-    # Using a block in this way allows computation against a specific field
-    # in a data set of hashes or objects.
-    #
-    # When the key is found both returned indexes will be the index of
-    # the item. When the key is not found but the value is within the
-    # range of value in the data set the returned indexes will be
-    # immediately above and below where the key would reside. When
-    # the key is below the lowest value in the search range the result
-    # will be nil and the lowest index. When the key is higher than the
-    # highest value in the search range the result will be the highest
-    # index and nil. 
-    #
-    # @yield iterates over each element in the data set
-    # @yieldparam item each element in the data set
-    #
-    # @param [Enumerable] data the data set to search
-    # @param [Hash] opts search options
-    # @param [Block] block optional block for per-item processing
-    #
-    # @option opts [Integer] :imin minimum index to search
-    # @option opts [Integer] :imax maximum index to search
-    #
-    # @return [Array] pair of indexes (see above) or nil when the collection
-    #   is empty or nil
-    def binary_search(data, key, opts={}, &block)
-
-      imin, imax = check_search_options(data, key, opts, &block)
-      return nil if imin.nil? && imax.nil?
-      return [imin, imax] if imin == imax || imin.nil? || imax.nil?
-
-      while (imax >= imin)
-        imid = (imin + imax) / 2
-        current = data[imid]
-        current = yield(current) if block_given?
-        if current < key
-          imin = imid + 1
-        elsif current > key
-          imax = imid - 1
-        else
-          imin = imax = imid
-          break
-        end
-      end
-
-      return imax, imin
-    end
-
-    alias_method :bsearch, :binary_search
-    alias_method :half_interval_search, :binary_search
-
-    private
-
-    # :nodoc:
-    # @private
-    def check_search_options(data, key, opts={})
-      return [nil, nil] if data.nil? || data.empty?
-
-      imin = [opts[:imin].to_i, 0].max
-      imax = opts[:imax].nil? ? data.size-1 : [opts[:imax], data.size-1].min
-      return [nil, nil] if imin > imax
-
-      if block_given?
-        min, max = yield(data[imin]), yield(data[imax])
-      else
-        min, max = data[imin], data[imax]
-      end
-      return [nil, imin] if key < min
-      return [imin, imin] if key == min
-      return [imax, nil] if key > max
-      return [imax, imax] if key == max
-
-      return [imin, imax]
-    end
-  end
-end

data/lib/functional/sort.rb

@@ -1,41 +0,0 @@
-module Functional
-
-  module Sort
-    extend self
-
-    # Sorts the collection using the insertion sort algorithm.
-    # 
-    # When a block is given the block will be applied to both arguments.
-    # Using a block in this way allows computation against a specific field
-    # in a data set of hashes or objects.
-    #
-    # @yield iterates over each element in the data set
-    # @yieldparam item each element in the data set
-    #
-    # @param [Enumerable] data the data set to search
-    # @param [Hash] opts search options
-    #
-    # @return [Array] the sorted collection
-    def insertion_sort!(data, opts={})
-      return data if data.nil? || data.size <= 1
-
-      (1..(data.size-1)).each do |j|
-
-        key = block_given? ? yield(data[j]) : data[j]
-        value = data[j]
-        i = j - 1
-        current = block_given? ? yield(data[i]) : data[i]
-
-        while i >= 0 && current > key
-          data[i+1] = data[i]
-          i = i - 1
-          current = block_given? ? yield(data[i]) : data[i]
-        end
-
-        data[i+1] = value
-      end
-
-      return data
-    end
-  end
-end

data/lib/functional/utilities.rb

@@ -1,189 +0,0 @@
-require 'pp'
-require 'stringio'
-require 'erb'
-require 'rbconfig'
-
-module Kernel
-
-  # Compute the difference (delta) between two values.
-  #
-  # When a block is given the block will be applied to both arguments.
-  # Using a block in this way allows computation against a specific field
-  # in a data set of hashes or objects.
-  #
-  # @yield iterates over each element in the data set
-  # @yieldparam item each element in the data set
-  #
-  # @param [Object] v1 the first value
-  # @param [Object] v2 the second value
-  #
-  # @return [Float] positive value representing the difference
-  #   between the two parameters
-  def delta(v1, v2)
-    if block_given?
-      v1 = yield(v1)
-      v2 = yield(v2)
-    end
-    return (v1 - v2).abs
-  end
-  module_function :delta
-
-  # Perform an operation numerous times, passing the value of the
-  # previous iteration, and collecting the results into an array.
-  #
-  # @yield iterates over each element in the data set
-  # @yieldparam previous the initial value (or nil) for the first
-  #   iteration then the value of the previous iteration for all
-  #   subsequent iterations
-  #
-  # @param [Integer] count the number of times to perform the operation
-  # @param [Object] initial the initial value to pass to the first iteration
-  #
-  # @return [Array] the results of the iterations collected into an array
-  def repeatedly(count, initial = nil)
-    return [] if (count = count.to_i) == 0
-    return count.times.collect{ nil } unless block_given?
-    return count.times.collect do
-      initial = yield(initial)
-    end
-  end
-  module_function :repeatedly
-
-  # Try an operation. If it fails (raises an exception), wait a second
-  # and try again. Try no more than the given number of times.
-  #
-  # @yield Tries the given block operation
-  #
-  # @param [Integer] tries The maximum number of times to attempt the operation.
-  # @param [Array] args Optional block arguments
-  #
-  # @return [Boolean] true if the operation succeeds on any attempt,
-  #   false if none of the attempts are successful
-  def retro(tries, *args)
-    tries = tries.to_i
-    return false if tries == 0 || ! block_given?
-    yield(*args)
-    return true
-  rescue Exception
-    sleep(1)
-    if (tries = tries - 1) > 0
-      retry
-    else
-      return false
-    end
-  end
-  module_function :retro
-
-  # Sandbox the given operation at a high $SAFE level.
-  #
-  # @param args [Array] zero or more arguments to pass to the block
-  #
-  # @return [Object] the result of the block operation
-  def safe(*args)
-    raise ArgumentError.new('no block given') unless block_given?
-    if RbConfig::CONFIG['ruby_install_name'] =~ /^ruby$/i
-      result = nil
-      t = Thread.new do
-        $SAFE = 3
-        result = yield(*args)
-      end
-      t.join
-      return result
-    else
-      return yield(*args)
-    end
-  end
-  module_function :safe
-
-  # Open a file, read it, close the file, and return its contents.
-  #
-  # @param file [String] path to and name of the file to open
-  #
-  # @return [String] file contents
-  #
-  # @see slurpee
-  def slurp(file)
-    File.open(file, 'rb') {|f| f.read }
-  end
-  module_function :slurp
-
-  # Open a file, read it, close the file, run the contents through the
-  # ERB parser, and return updated contents.
-  #
-  # @param file [String] path to and name of the file to open
-  # @param safe_level [Integer] when not nil, ERB will $SAFE set to this
-  #
-  # @return [String] file contents
-  #
-  # @see slurpee
-  def slurpee(file, safe_level = nil)
-    ERB.new(slurp(file), safe_level).result
-  end
-  module_function :slurpee
-
-  # Run the given block and time how long it takes in seconds. All arguments
-  # will be passed to the block. The function will return two values. The
-  # first value will be the duration of the timer in seconds. The second
-  # return value will be the result of the block.
-  #
-  # @param args [Array] zero or more arguments to pass to the block
-  #
-  # @return [Integer, Object] the duration of the operation in seconds and
-  #   the result of the block operation
-  def timer(*args)
-    return 0,nil unless block_given?
-    t1 = Time.now
-    result = yield(*args)
-    t2 = Time.now
-    return (t2 - t1), result
-  end
-  module_function :timer
-
-  #############################################################################
-
-  # @private
-  # @see http://cirw.in/blog/find-references
-  def object_counts # :nodoc:
-    counts = Hash.new{ 0 }
-    ObjectSpace.each_object do |obj|
-      counts[obj.class] += 1
-    end
-    return counts
-  end
-  module_function :object_counts
-
-  # @private
-  # @see http://rhaseventh.blogspot.com/2008/07/ruby-and-rails-how-to-get-pp-pretty.html
-  def pp_s(*objs) # :nodoc:
-    s = StringIO.new
-    objs.each {|obj|
-      PP.pp(obj, s)
-    }
-    s.rewind
-    s.read
-  end
-  module_function :pp_s
-
-  # @private
-  def repl? # :nodoc:
-    return ($0 == 'irb' || $0 == 'pry' || $0 == 'script/rails' || !!($0 =~ /bin\/bundle$/))
-  end
-  module_function :repl?
-
-  # @private
-  def strftimer(seconds) # :nodoc:
-    Time.at(seconds).gmtime.strftime('%R:%S.%L')
-  end
-  module_function :strftimer
-
-  # @private
-  def timestamp # :nodoc:
-    return Time.now.getutc.to_i
-  end
-
-  def write_object_counts(name = 'ruby')
-    file = "#{name}_#{Time.now.to_i}.txt"
-    File.open(file, 'w') {|f| f.write(pp_s(object_counts)) }
-  end
-  module_function :write_object_counts
-end