blackwinter-ruby-nuggets 0.4.0

data/lib/nuggets/array/shuffle.rb

@@ -0,0 +1,133 @@
+#--
+###############################################################################
+#                                                                             #
+# A component of ruby-nuggets, some extensions to the Ruby programming        #
+# language.                                                                   #
+#                                                                             #
+# Copyright (C) 2007 Jens Wille                                               #
+#                                                                             #
+# Authors:                                                                    #
+#     Jens Wille <jens.wille@uni-koeln.de>                                    #
+#                                                                             #
+# ruby-nuggets is free software; you can redistribute it and/or modify it     #
+# under the terms of the GNU General Public License as published by the Free  #
+# Software Foundation; either version 3 of the License, or (at your option)   #
+# any later version.                                                          #
+#                                                                             #
+# ruby-nuggets is distributed in the hope that it will be useful, but WITHOUT #
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or       #
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for    #
+# more details.                                                               #
+#                                                                             #
+# You should have received a copy of the GNU General Public License along     #
+# with ruby-nuggets. If not, see <http://www.gnu.org/licenses/>.              #
+#                                                                             #
+###############################################################################
+#++
+
+class Array
+
+  # call-seq:
+  #   array.shuffle => new_array
+  #
+  # Shuffles _array_ in random order. Select a different shuffling algorithm:
+  # <tt>Array.send(:alias_method, :shuffle, :shuffle_kfy)</tt>.
+  def shuffle
+    sort_by { Kernel.rand }
+  end
+
+  # call-seq:
+  #   array.shuffle_knuth => new_array
+  #
+  # Non-destructive version of #shuffle_knuth!.
+  def shuffle_knuth
+    dup.shuffle_knuth!
+  end
+
+  # call-seq:
+  #   array.shuffle_kfy => new_array
+  #
+  # Non-destructive version of #shuffle_kfy!.
+  def shuffle_kfy
+    dup.shuffle_kfy!
+  end
+
+  # call-seq:
+  #   array.shuffle! => array
+  #
+  # Destructive version of #shuffle.
+  def shuffle!
+    replace shuffle
+  end
+
+  # call-seq:
+  #   array.shuffle_knuth! => array
+  #
+  # Shuffles _array_ in random order using Knuth's algorithm.
+  def shuffle_knuth!
+    0.upto(length - 2) { |i|
+      n = i + rand(length - i)
+      self[i], self[n] = self[n], self[i]
+    }
+
+    self
+  end
+
+  # call-seq:
+  #   array.shuffle_kfy! => array
+  #
+  # Shuffles _array_ in random order using the Knuth-Fisher-Yates algorithm.
+  def shuffle_kfy!
+    (length - 1).downto(0) { |i|
+      n = rand(i + 1)
+      self[n], self[i] = self[i], self[n]
+    }
+
+    self
+  end
+
+end
+
+if $0 == __FILE__
+  a = %w[1 2 3 4 5 6 7 8]
+  p a
+
+  p a.shuffle
+  p a.shuffle
+
+  p a.shuffle_knuth
+  p a.shuffle_kfy
+
+  a.shuffle!
+  p a
+
+  require 'nuggets/integer/factorial'
+  require 'nuggets/enumerable/minmax'
+
+  a = %w[a b c]
+  n = 100_000
+  m = a.length.f!
+  e = n / m.to_f
+  puts '%d / %d / %d / %.2f' % [a.length, n, m, e]
+
+  algorithms = %w[shuffle shuffle_knuth shuffle_kfy]
+  max = algorithms.max(:length)
+
+  algorithms.each { |algorithm|
+    score = Hash.new { |h, k| h[k] = 0 }
+
+    n.times {
+      score[a.send(algorithm)] += 1
+    }
+
+    x2 = 0
+    score.sort.each { |key, value|
+      x = value - e
+      y = x**2 / e
+      #puts '%s: %d (% .2f/%.2f)' % [key, value, x, y]
+
+      x2 += y
+    }
+    puts "%-#{max}s = %.2f (%.2f)" % [algorithm, x2, x2 / m]
+  }
+end

data/lib/nuggets/array/to_hash.rb

@@ -0,0 +1,86 @@
+#--
+###############################################################################
+#                                                                             #
+# A component of ruby-nuggets, some extensions to the Ruby programming        #
+# language.                                                                   #
+#                                                                             #
+# Copyright (C) 2007-2008 Jens Wille                                          #
+#                                                                             #
+# Authors:                                                                    #
+#     Jens Wille <jens.wille@uni-koeln.de>                                    #
+#                                                                             #
+# ruby-nuggets is free software; you can redistribute it and/or modify it     #
+# under the terms of the GNU General Public License as published by the Free  #
+# Software Foundation; either version 3 of the License, or (at your option)   #
+# any later version.                                                          #
+#                                                                             #
+# ruby-nuggets is distributed in the hope that it will be useful, but WITHOUT #
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or       #
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for    #
+# more details.                                                               #
+#                                                                             #
+# You should have received a copy of the GNU General Public License along     #
+# with ruby-nuggets. If not, see <http://www.gnu.org/licenses/>.              #
+#                                                                             #
+###############################################################################
+#++
+
+require 'nuggets/array/flatten_once'
+
+class Array
+
+  # call-seq:
+  #   array.to_hash => aHash
+  #   array.to_hash(value) => aHash
+  #   array.to_hash { |element| ... } => aHash
+  #
+  # If neither +value+ nor block is given, converts _array_, taken as an
+  # array of key/value pairs, into a hash, preserving sub-arrays (Thus:
+  # <tt>hash.to_a.to_h == hash</tt>). Otherwise, maps each element of
+  # _array_ to +value+ or the result of the block.
+  #
+  # Examples:
+  #   [[0, 0], [1, [2, 3]]].to_h  #=> { 0 => 0, 1 => [2, 3] }
+  #   %w[a b c d].to_h            #=> { "a" => "b", "c" => "d" }
+  #   %w[a b c d].to_h(1)         #=> { "a" => 1, "b" => 1, "c" => 1, "d" => 1 }
+  #   %w[a b].to_h { |e| e * 2 }  #=> { "a" => "aa", "b" => "bb" }
+  def to_hash(value = default = Object.new)
+    hash = {}
+
+    if block_given?
+      raise ArgumentError, "both block and value argument given" if default.nil?
+
+      each { |element| hash[element] = yield element }
+    elsif default.nil?
+      each { |element| hash[element] = value }
+    else
+      return Hash[*flatten_once]
+    end
+
+    hash
+  end
+  alias_method :to_h, :to_hash
+
+end
+
+if $0 == __FILE__
+  a = [[:a, 1], [:b, 2], [:c, 3]]
+  p a
+  p a.to_h
+
+  b = [[:a, [1, 2]], [:b, 3], [[:c, :d], [4, [5, 6]]]]
+  p b
+  p b.to_h
+
+  c = %w[a b c d]
+  p c
+  p c.to_h
+  p c.to_h(1)
+  p c.to_h { nil }
+
+  h = { :a => 1, :b => [2, 3], :c => { :d => 4}}
+  p h
+  p h.to_a
+  p h.to_a.to_h
+  p h.to_a.to_h == h
+end

data/lib/nuggets/enumerable/agrep.rb

@@ -0,0 +1,82 @@
+#--
+###############################################################################
+#                                                                             #
+# A component of ruby-nuggets, some extensions to the Ruby programming        #
+# language.                                                                   #
+#                                                                             #
+# Copyright (C) 2007-2008 Jens Wille                                          #
+#                                                                             #
+# Authors:                                                                    #
+#     Jens Wille <jens.wille@uni-koeln.de>                                    #
+#                                                                             #
+# ruby-nuggets is free software; you can redistribute it and/or modify it     #
+# under the terms of the GNU General Public License as published by the Free  #
+# Software Foundation; either version 3 of the License, or (at your option)   #
+# any later version.                                                          #
+#                                                                             #
+# ruby-nuggets is distributed in the hope that it will be useful, but WITHOUT #
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or       #
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for    #
+# more details.                                                               #
+#                                                                             #
+# You should have received a copy of the GNU General Public License along     #
+# with ruby-nuggets. If not, see <http://www.gnu.org/licenses/>.              #
+#                                                                             #
+###############################################################################
+#++
+
+begin
+  require 'rubygems'
+rescue LoadError
+end
+
+begin
+  require 'amatch'
+rescue LoadError
+  warn "Couldn't load amatch..." if $VERBOSE
+end
+
+module Enumerable
+
+  # call-seq:
+  #   enum.agrep(pattern[, distance]) => anArray
+  #   enum.agrep(pattern[, distance]) { |obj| ... } => anArray
+  #
+  # Returns an array of every element in _enum_ for which +pattern+ approximately
+  # matches +element+ (see Amatch::Levenshtein#search). If the optional +block+
+  # is supplied, each matching element is passed to it, and the block‘s result
+  # is stored in the output array.
+  #
+  # LIMITATIONS:
+  #
+  # - Only strings are allowed as +pattern+. Regular expressions are reverted
+  #   to their respective source. (Equivalent to <tt>agrep -k</tt>)
+  # - Only works with string elements in _enum_. (Calls +to_s+ on each element)
+  # - The cost for individual error types (substitution, insertion, deletion)
+  #   cannot be adjusted. 
+  def agrep(pattern, distance = 0)
+    raise 'Amatch not available!' unless defined?(Amatch)
+
+    pattern = pattern.source if pattern.is_a?(Regexp)
+
+    amatch  = Amatch::Levenshtein.new(pattern)
+    matches = select { |obj| amatch.search(obj.to_s) <= distance }
+
+    block_given? ? matches.map { |match| yield match } : matches
+  end
+
+end
+
+if $0 == __FILE__
+  e = %w[quux quuux quix quixx]
+  p e
+
+  p e.agrep(/quux/)
+  p e.agrep(/quux/, 1)
+  p e.agrep(/quux/, 2)
+
+  p e.grep(/qu.x/)
+  p e.agrep(/qu.x/)
+
+  #p [123, 124, 1233].agrep(/123/, 1)
+end

data/lib/nuggets/enumerable/all_any_extended.rb

@@ -0,0 +1,99 @@
+#--
+###############################################################################
+#                                                                             #
+# A component of ruby-nuggets, some extensions to the Ruby programming        #
+# language.                                                                   #
+#                                                                             #
+# Copyright (C) 2007-2008 Jens Wille                                          #
+#                                                                             #
+# Authors:                                                                    #
+#     Jens Wille <jens.wille@uni-koeln.de>                                    #
+#                                                                             #
+# ruby-nuggets is free software; you can redistribute it and/or modify it     #
+# under the terms of the GNU General Public License as published by the Free  #
+# Software Foundation; either version 3 of the License, or (at your option)   #
+# any later version.                                                          #
+#                                                                             #
+# ruby-nuggets is distributed in the hope that it will be useful, but WITHOUT #
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or       #
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for    #
+# more details.                                                               #
+#                                                                             #
+# You should have received a copy of the GNU General Public License along     #
+# with ruby-nuggets. If not, see <http://www.gnu.org/licenses/>.              #
+#                                                                             #
+###############################################################################
+#++
+
+module Enumerable
+
+  alias_method :_nuggets_original_all?, :all?
+  alias_method :_nuggets_original_any?, :any?
+
+  # call-seq:
+  #   enum.all?(obj[, operator]) => true or false
+  #   enum.all? { ... } => true or false
+  #
+  # Adds the ability to pass an +object+ instead of a block, which will then
+  # be tested against each item in _enum_ according to +operator+, defaulting
+  # to :===.
+  def all?(object = default = Object.new, operator = :===)
+    _nuggets_original_all?(&block_given? ?
+      _block_for_all_any_extended(object, default, operator) { |*a| yield(*a) } :
+      _block_for_all_any_extended(object, default, operator))
+  end
+
+  # call-seq:
+  #   enum.any?(obj[, operator]) => true or false
+  #   enum.any? { ... } => true or false
+  #
+  # Adds the ability to pass an +object+ instead of a block, which will then
+  # be tested against each item in _enum_ according to +operator+, defaulting
+  # to :===.
+  def any?(object = default = Object.new, operator = :===)
+    _nuggets_original_any?(&block_given? ?
+      _block_for_all_any_extended(object, default, operator) { |*a| yield(*a) } :
+      _block_for_all_any_extended(object, default, operator))
+  end
+
+  private
+
+  # Common argument processing for extended versions of #all? and #any?.
+  def _block_for_all_any_extended(object, default, operator)
+    if default.nil?
+      raise ArgumentError, "both block and object argument given", caller(1) if block_given?
+
+      lambda { |item| object.send(operator, item) }
+    elsif block_given?
+      lambda { |item| yield item }
+    end
+  end
+
+end
+
+if $0 == __FILE__
+  e = %w[quux quuux quix]
+  p e
+
+  p e.all?(String)
+  p e.any?(Numeric)
+
+  e = [:one, 'c', nil, 88]
+  p e
+
+  p e.all?(Object)
+  p e.any?(NilClass)
+
+  begin
+    e.any?(NilClass) { |i| i.nil? }
+  rescue ArgumentError => err
+    puts "#{err.backtrace.first}: #{err} (#{err.class})"
+  end
+
+  e = [0, 10, 20]
+  p e
+
+  p e.any?(9..99)
+  p e.any?(9, :<)
+  p e.any? { |i| i < 9 }
+end

data/lib/nuggets/enumerable/minmax.rb

@@ -0,0 +1,119 @@
+#--
+###############################################################################
+#                                                                             #
+# A component of ruby-nuggets, some extensions to the Ruby programming        #
+# language.                                                                   #
+#                                                                             #
+# Copyright (C) 2007-2008 Jens Wille                                          #
+#                                                                             #
+# Authors:                                                                    #
+#     Jens Wille <jens.wille@uni-koeln.de>                                    #
+#                                                                             #
+# ruby-nuggets is free software; you can redistribute it and/or modify it     #
+# under the terms of the GNU General Public License as published by the Free  #
+# Software Foundation; either version 3 of the License, or (at your option)   #
+# any later version.                                                          #
+#                                                                             #
+# ruby-nuggets is distributed in the hope that it will be useful, but WITHOUT #
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or       #
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for    #
+# more details.                                                               #
+#                                                                             #
+# You should have received a copy of the GNU General Public License along     #
+# with ruby-nuggets. If not, see <http://www.gnu.org/licenses/>.              #
+#                                                                             #
+###############################################################################
+#++
+
+module Enumerable
+
+  alias_method :_nuggets_original_max, :max
+  alias_method :_nuggets_original_min, :min
+
+  # call-seq:
+  #   enum.minmax_by(meth, by) => aValue
+  #
+  # Finds the maximum/minimum (or whatever +meth+ is) value in _enum_ according
+  # to +by+ (which may be a symbol/string that is sent to each value, or a proc
+  # that receives each value as parameter).
+  def minmax_by(meth, by)
+    _by = by.is_a?(Proc) ? by : lambda { |i| i.send(by) }
+    send(meth) { |a, b| _by[a] <=> _by[b] }
+  end
+
+  # call-seq:
+  #   enum.max_by(by) => aValue
+  #
+  # Maximum #minmax_by.
+  def max_by(by)
+    minmax_by(:max, by)
+  end
+
+  # call-seq:
+  #   enum.min_by(by) => aValue
+  #
+  # Minimum #minmax_by.
+  def min_by(by)
+    minmax_by(:min, by)
+  end
+
+  # call-seq:
+  #   enum.minmax(meth, what) => anObject
+  #
+  # Finds the #minmax_by according to +what+ and returns that "what".
+  #
+  # Example:
+  #   %w[a bcd ef].max(:length)  #=> 3
+  def minmax(meth, what)
+    #m = minmax_by(meth, what)
+    #what.is_a?(Proc) ? what[m] : m.send(what)
+
+    _what = what.is_a?(Proc) ? what : lambda { |i| i.send(what) }
+    map { |i| _what[i] }.send(meth)
+
+    # Benchmark (:max, :length; enum.size = 20, N = 100_000):
+    #
+    # max_by(:length).length   7.920000   0.890000   8.810000 (  8.991915)
+    # map(:length).max         4.800000   0.600000   5.400000 (  5.418114)
+  end
+
+  # call-seq:
+  #   enum.max(what) => aValue
+  #
+  # Maximum #minmax. If +what+ is omitted, or nil, the original Enumerable#max
+  # is called.
+  def max(what = nil)
+    what ? minmax(:max, what) : block_given? ?
+      _nuggets_original_max { |*a| yield(*a) } : _nuggets_original_max
+  end
+
+  # call-seq:
+  #   enum.min(what) => aValue
+  #
+  # Minimum #minmax. If +what+ is omitted, or nil, the original Enumerable#min
+  # is called.
+  def min(what = nil)
+    what ? minmax(:min, what) : block_given? ?
+      _nuggets_original_min { |*a| yield(*a) } : _nuggets_original_min
+  end
+
+end
+
+if $0 == __FILE__
+  e = %w[quux quuux quix]
+  p e
+
+  p e.max
+  p e.max_by(:length)
+  p e.max(:length)
+
+  e = [3, 222, 45]
+  p e
+
+  # the last digit counts ;-)
+  l = lambda { |i| i.to_s.split(//).last.to_i }
+
+  p e.max
+  p e.max_by(l)
+  p e.max(l)
+end

data/lib/nuggets/env/user_encoding.rb

@@ -0,0 +1,53 @@
+#--
+###############################################################################
+#                                                                             #
+# A component of ruby-nuggets, some extensions to the Ruby programming        #
+# language.                                                                   #
+#                                                                             #
+# Copyright (C) 2008 Jens Wille                                               #
+#                                                                             #
+# Authors:                                                                    #
+#     Jens Wille <jens.wille@uni-koeln.de>                                    #
+#                                                                             #
+# ruby-nuggets is free software; you can redistribute it and/or modify it     #
+# under the terms of the GNU General Public License as published by the Free  #
+# Software Foundation; either version 3 of the License, or (at your option)   #
+# any later version.                                                          #
+#                                                                             #
+# ruby-nuggets is distributed in the hope that it will be useful, but WITHOUT #
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or       #
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for    #
+# more details.                                                               #
+#                                                                             #
+# You should have received a copy of the GNU General Public License along     #
+# with ruby-nuggets. If not, see <http://www.gnu.org/licenses/>.              #
+#                                                                             #
+###############################################################################
+#++
+
+begin
+  require 'win32console'
+rescue LoadError
+end
+
+class << ENV
+
+  # call-seq:
+  #   ENV.user_encoding => aString or nil
+  #
+  # Finds the user's selected encoding.
+  def user_encoding
+    ENV['ENCODING']          ||
+    ENV['LANG'][/\.(.*)/, 1] ||
+    if defined?(Win32::Console)
+      "CP#{Win32::Console.InputCP}"
+    else
+      cp = %x{chcp}[/:\s*(.*?)\./, 1] and "CP#{cp}"
+    end
+  end
+
+end
+
+if $0 == __FILE__
+  p ENV.user_encoding
+end

data/lib/nuggets/env/user_home.rb

@@ -0,0 +1,54 @@
+#--
+###############################################################################
+#                                                                             #
+# A component of ruby-nuggets, some extensions to the Ruby programming        #
+# language.                                                                   #
+#                                                                             #
+# Copyright (C) 2008 Jens Wille                                               #
+#                                                                             #
+# Authors:                                                                    #
+#     Jens Wille <jens.wille@uni-koeln.de>                                    #
+#                                                                             #
+# ruby-nuggets is free software; you can redistribute it and/or modify it     #
+# under the terms of the GNU General Public License as published by the Free  #
+# Software Foundation; either version 3 of the License, or (at your option)   #
+# any later version.                                                          #
+#                                                                             #
+# ruby-nuggets is distributed in the hope that it will be useful, but WITHOUT #
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or       #
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for    #
+# more details.                                                               #
+#                                                                             #
+# You should have received a copy of the GNU General Public License along     #
+# with ruby-nuggets. If not, see <http://www.gnu.org/licenses/>.              #
+#                                                                             #
+###############################################################################
+#++
+
+class << ENV
+
+  # call-seq:
+  #   ENV.user_home => aString
+  #
+  # Finds the user's home directory. Stolen from RubyGems ;-)
+  def user_home
+    %w[HOME USERPROFILE].each { |homekey|
+      return ENV[homekey] if ENV[homekey]
+    }
+
+    if ENV['HOMEDRIVE'] && ENV['HOMEPATH']
+      return "#{ENV['HOMEDRIVE']}:#{ENV['HOMEPATH']}"
+    end
+
+    begin
+      File.expand_path('~')
+    rescue ArgumentError
+      File::ALT_SEPARATOR ? 'C:/' : '/'
+    end
+  end
+
+end
+
+if $0 == __FILE__
+  p ENV.user_home
+end