nuggets 0.9.9 → 1.0.0

data/lib/nuggets/dotted_decimal.rb

@@ -0,0 +1,59 @@
+#--
+###############################################################################
+#                                                                             #
+# nuggets -- Extending Ruby                                                   #
+#                                                                             #
+# Copyright (C) 2007-2011 Jens Wille                                          #
+#                                                                             #
+# Authors:                                                                    #
+#     Jens Wille <jens.wille@gmail.com>                                       #
+#                                                                             #
+# nuggets is free software; you can redistribute it and/or modify it under    #
+# the terms of the GNU Affero General Public License as published by the Free #
+# Software Foundation; either version 3 of the License, or (at your option)   #
+# any later version.                                                          #
+#                                                                             #
+# 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 Affero General Public License for     #
+# more details.                                                               #
+#                                                                             #
+# You should have received a copy of the GNU Affero General Public License    #
+# along with nuggets. If not, see <http://www.gnu.org/licenses/>.             #
+#                                                                             #
+###############################################################################
+#++
+
+require 'nuggets/integer/to_binary_s'
+
+class Integer
+
+  # call-seq:
+  #   int.to_dotted_decimal => aString
+  #
+  # Converts _int_ to dotted-decimal notation.
+  def to_dotted_decimal
+    to_binary_s(32).unpack('a8' * 4).map { |s| s.to_i(2) }.join('.')
+  end
+
+end
+
+class String
+
+  # call-seq:
+  #   str.from_dotted_decimal => anInteger
+  #
+  # Converts _str_ from dotted-decimal notation to integer.
+  def from_dotted_decimal
+    split('.').map { |i| i.to_i.to_binary_s(8) }.join.to_i(2)
+  end
+
+end
+
+class Array
+
+  def sort_by_dotted_decimal
+    sort_by { |i| i.split('.').map { |j| j.to_i } }
+  end
+
+end

data/lib/nuggets/enumerable/agrep.rb

@@ -0,0 +1,79 @@
+#--
+###############################################################################
+#                                                                             #
+# nuggets -- Extending Ruby                                                   #
+#                                                                             #
+# Copyright (C) 2007-2011 Jens Wille                                          #
+#                                                                             #
+# Authors:                                                                    #
+#     Jens Wille <jens.wille@gmail.com>                                       #
+#                                                                             #
+# nuggets is free software; you can redistribute it and/or modify it under    #
+# the terms of the GNU Affero General Public License as published by the Free #
+# Software Foundation; either version 3 of the License, or (at your option)   #
+# any later version.                                                          #
+#                                                                             #
+# 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 Affero General Public License for     #
+# more details.                                                               #
+#                                                                             #
+# You should have received a copy of the GNU Affero General Public License    #
+# along with 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]) { |element| ... } -> enum
+  #
+  # Returns an array of all elements 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 _enum_ itself is
+  # returned.
+  #
+  # 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)
+    pattern = pattern.source if pattern.is_a?(::Regexp)
+
+    am = ::Amatch::Levenshtein.new(pattern)
+    ma = lambda { |i| am.search(i.to_s) <= distance }
+
+    block_given? ? each { |i| yield i if ma[i] } : select(&ma)
+  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,66 @@
+#--
+###############################################################################
+#                                                                             #
+# nuggets -- Extending Ruby                                                   #
+#                                                                             #
+# Copyright (C) 2007-2011 Jens Wille                                          #
+#                                                                             #
+# Authors:                                                                    #
+#     Jens Wille <jens.wille@gmail.com>                                       #
+#                                                                             #
+# nuggets is free software; you can redistribute it and/or modify it under    #
+# the terms of the GNU Affero General Public License as published by the Free #
+# Software Foundation; either version 3 of the License, or (at your option)   #
+# any later version.                                                          #
+#                                                                             #
+# 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 Affero General Public License for     #
+# more details.                                                               #
+#                                                                             #
+# You should have received a copy of the GNU Affero General Public License    #
+# along with 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 <tt>:===</tt>.
+  def all?(object = default = true, operator = :===, &block)
+    _nuggets_original_all?(&_block_for_all_any_extended(object, default, operator, &block))
+  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 <tt>:===</tt>.
+  def any?(object = default = true, operator = :===, &block)
+    _nuggets_original_any?(&_block_for_all_any_extended(object, default, operator, &block))
+  end
+
+  private
+
+  # Common argument processing for extended versions of #all? and #any?.
+  def _block_for_all_any_extended(object, default, operator, &block)
+    unless default
+      raise ::ArgumentError, 'both block and object argument given', caller(1) if block
+      lambda { |*a| object.send(operator, *a) }
+    else
+      block
+    end
+  end
+
+end

data/lib/nuggets/enumerable/minmax.rb

@@ -0,0 +1,102 @@
+#--
+###############################################################################
+#                                                                             #
+# nuggets -- Extending Ruby                                                   #
+#                                                                             #
+# Copyright (C) 2007-2011 Jens Wille                                          #
+#                                                                             #
+# Authors:                                                                    #
+#     Jens Wille <jens.wille@gmail.com>                                       #
+#                                                                             #
+# nuggets is free software; you can redistribute it and/or modify it under    #
+# the terms of the GNU Affero General Public License as published by the Free #
+# Software Foundation; either version 3 of the License, or (at your option)   #
+# any later version.                                                          #
+#                                                                             #
+# 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 Affero General Public License for     #
+# more details.                                                               #
+#                                                                             #
+# You should have received a copy of the GNU Affero General Public License    #
+# along with nuggets. If not, see <http://www.gnu.org/licenses/>.             #
+#                                                                             #
+###############################################################################
+#++
+
+module Enumerable
+
+  alias_method :_nuggets_original_minmax_by, :minmax_by if method_defined?(:minmax_by)
+  alias_method :_nuggets_original_min_by,    :min_by    if method_defined?(:min_by)
+  alias_method :_nuggets_original_max_by,    :max_by    if method_defined?(:max_by)
+  alias_method :_nuggets_original_minmax,    :minmax    if method_defined?(:minmax)
+
+  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, &block)
+    what ? minmax(:max, what) : _nuggets_original_max(&block)
+  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, &block)
+    what ? minmax(:min, what) : _nuggets_original_min(&block)
+  end
+
+end

data/lib/nuggets/env/set.rb

@@ -0,0 +1,3 @@
+require 'nuggets/env/set_mixin'
+
+ENV.extend(Nuggets::Env::SetMixin)

data/lib/nuggets/env/set_mixin.rb

@@ -0,0 +1,67 @@
+#--
+###############################################################################
+#                                                                             #
+# nuggets -- Extending Ruby                                                   #
+#                                                                             #
+# Copyright (C) 2007-2011 Jens Wille                                          #
+#                                                                             #
+# Authors:                                                                    #
+#     Jens Wille <jens.wille@gmail.com>                                       #
+#                                                                             #
+# nuggets is free software; you can redistribute it and/or modify it under    #
+# the terms of the GNU Affero General Public License as published by the Free #
+# Software Foundation; either version 3 of the License, or (at your option)   #
+# any later version.                                                          #
+#                                                                             #
+# 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 Affero General Public License for     #
+# more details.                                                               #
+#                                                                             #
+# You should have received a copy of the GNU Affero General Public License    #
+# along with nuggets. If not, see <http://www.gnu.org/licenses/>.             #
+#                                                                             #
+###############################################################################
+#++
+
+module Nuggets
+  module Env
+    module SetMixin
+
+  # call-seq:
+  #   ENV.set([env[, clear]]) => aHash
+  #   ENV.set([env[, clear]]) { ... } => anObject
+  #
+  # Overrides ENV with +env+, clearing it beforehand if +clear+ is +true+. If a
+  # block is given, restores ENV to its original state afterwards and returns
+  # the result of the block; otherwise returns the original ENV as a hash.
+  def set(env = {}, clear = true)
+    old_env = to_hash
+
+    self.clear if clear
+
+    env.each { |key, value|
+      key = key.to_s.upcase unless key.is_a?(::String)
+      value = value.to_s unless value.is_a?(::String)
+
+      self[key] = value
+    }
+
+    block_given? ? yield : old_env
+  ensure
+    set(old_env) if old_env && block_given?
+  end
+
+  alias_method :without, :set
+
+  # call-seq:
+  #   ENV.with([env[, clear]]) { ... } => anObject
+  #
+  # Temporarily overrides ENV with +env+ for the block execution. See #set.
+  def with(env = {}, clear = false)
+    set(env, clear) { yield }
+  end
+
+    end
+  end
+end

data/lib/nuggets/env/user_encoding.rb

@@ -0,0 +1,3 @@
+require 'nuggets/env/user_encoding_mixin'
+
+ENV.extend(Nuggets::Env::UserEncodingMixin)

data/lib/nuggets/env/user_encoding_mixin.rb

@@ -0,0 +1,54 @@
+#--
+###############################################################################
+#                                                                             #
+# nuggets -- Extending Ruby                                                   #
+#                                                                             #
+# Copyright (C) 2007-2011 Jens Wille                                          #
+#                                                                             #
+# Authors:                                                                    #
+#     Jens Wille <jens.wille@gmail.com>                                       #
+#                                                                             #
+# nuggets is free software; you can redistribute it and/or modify it under    #
+# the terms of the GNU Affero General Public License as published by the Free #
+# Software Foundation; either version 3 of the License, or (at your option)   #
+# any later version.                                                          #
+#                                                                             #
+# 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 Affero General Public License for     #
+# more details.                                                               #
+#                                                                             #
+# You should have received a copy of the GNU Affero General Public License    #
+# along with nuggets. If not, see <http://www.gnu.org/licenses/>.             #
+#                                                                             #
+###############################################################################
+#++
+
+begin
+  require 'win32console'
+rescue ::LoadError
+end
+
+module Nuggets
+  module Env
+    module UserEncodingMixin
+
+  # call-seq:
+  #   ENV.user_encoding => aString
+  #
+  # Finds the user's selected encoding.
+  def user_encoding(default = 'UTF-8')
+    self['ENCODING'] || begin
+      lang = self['LANG']
+      lang[/\.(.*)/, 1] if lang
+    end || if defined?(::Win32::Console)
+      "CP#{::Win32::Console.InputCP}"
+    elsif ::File::ALT_SEPARATOR
+      cp = %x{chcp}[/:\s*(.*?)\./, 1]
+      "CP#{cp}" if cp
+    end || default
+  end
+
+    end
+  end
+end

data/lib/nuggets/env/user_home.rb

@@ -0,0 +1,3 @@
+require 'nuggets/env/user_home_mixin'
+
+ENV.extend(Nuggets::Env::UserHomeMixin)