nuggets 0.9.9 → 1.0.0

data/lib/nuggets/hash/unroll.rb

@@ -0,0 +1,5 @@
+require 'nuggets/hash/unroll_mixin'
+
+class Hash
+  include Nuggets::Hash::UnrollMixin
+end

data/lib/nuggets/hash/unroll_mixin.rb

@@ -0,0 +1,88 @@
+#--
+###############################################################################
+#                                                                             #
+# 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
+  class Hash
+    module UnrollMixin
+
+  # call-seq:
+  #   hash.unroll(*value_keys) => anArray
+  #   hash.unroll(*value_keys, :sort_by => ...) => anArray
+  #   hash.unroll(*value_keys) { |value_hash| ... } => anArray
+  #
+  # "Unrolls" a nested hash, so that each path through _hash_ results in a
+  # row that is, e.g., suitable for use with CSV.
+  #
+  # Note that from the final hash ("value hash") only the values are used,
+  # namely, if +value_keys+ are given, the values at those keys are returned.
+  # If a block is given, the +value_hash+ is passed to that block for any
+  # additional processing or sanitization.
+  #
+  # If +sort_by+ is given, all hashes are passed through that block for
+  # sorting before being put into the result array.
+  #
+  # Examples:
+  #
+  #   { :foo => { :bar => { :a => { :x => 1, :y => 2 }, :b => { :x => 0, :y => 3 } } } }.unroll
+  #   #=> [[:foo, :bar, :b, 3, 0], [:foo, :bar, :a, 2, 1]]
+  #
+  #   { :foo => { :bar => { :a => { :x => 1, :y => 2 }, :b => { :x => 0, :y => 3 } } } }.unroll(:sort_by => :to_s)
+  #   #=> [[:foo, :bar, :a, 1, 2], [:foo, :bar, :b, 0, 3]]
+  #
+  #   { :foo => { :bar => { :a => { :x => 1, :y => 2 }, :b => { :x => 0, :y => 3 } } } }.unroll { |data| data[:x] = nil; data[:y] *= 2 }
+  #   #=> [[:foo, :bar, :b, 6, nil], [:foo, :bar, :a, 4, nil]]
+  def unroll(*value_keys, &block)
+    args = value_keys.dup
+    options = value_keys.last.is_a?(::Hash) ? value_keys.pop : {}
+
+    sort_proc = if options.key?(:sort_by)
+      lambda { sort_by(&options[:sort_by]) }
+    elsif options.key?(:sort)
+      options[:sort] == true ? lambda { sort } : lambda { sort(&options[:sort]) }
+    end
+
+    rows = []
+
+    if values.first.is_a?(self.class)  # if any is, then all are
+      (sort_proc ? sort_proc.call : self).each { |key, value|
+        value.unroll(*args, &block).each { |row| rows << [key, *row] }
+      }
+    else
+      block[self] if block
+
+      rows << if value_keys.empty?
+        sort_proc ? sort_proc.call.map { |key, value| value } : values
+      else
+        values_at(*value_keys)
+      end
+    end
+
+    rows
+  end
+
+    end
+  end
+end

data/lib/nuggets/hash/zip.rb

@@ -0,0 +1,5 @@
+require 'nuggets/hash/zip_mixin'
+
+class Hash
+  extend Nuggets::Hash::ZipMixin
+end

data/lib/nuggets/hash/zip_mixin.rb

@@ -0,0 +1,159 @@
+#--
+###############################################################################
+#                                                                             #
+# nuggets -- Extending Ruby                                                   #
+#                                                                             #
+# Copyright (C) 2007-2014 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 'zlib'
+
+module Nuggets
+  class Hash
+    module ZipMixin
+
+  def zip(*args, &block)
+    ZipHash.new(*args, &block)
+  end
+
+  def zipval(*args, &block)
+    ZipValHash.new(*args, &block)
+  end
+
+  def zipkey(*args, &block)
+    ZipKeyHash.new(*args, &block)
+  end
+
+  class ZipHash < ::Hash
+
+    def [](key)
+      unzipval(super(zipkey(key)))
+    end
+
+    def []=(key, value)
+      super(zipkey(key), zipval(value))
+    end
+
+    def fetch(key, *args)
+      unzipval(super(zipkey(key), *args))
+    end
+
+    def store(key, value)
+      super(zipkey(key), zipval(value))
+    end
+
+    private
+
+    def zipval(value)
+      value.is_a?(ZipVal) ? value : ZipVal.new(value)
+    end
+
+    def unzipval(value)
+      value.is_a?(ZipVal) ? value.to_s : value
+    end
+
+    def zipkey(key)
+      key.is_a?(ZipKey) ? key : ZipKey.new(key)
+    end
+
+    def unzipkey(key)
+      key.is_a?(ZipKey) ? key.to_s : key
+    end
+
+  end
+
+  class ZipValHash < ZipHash
+
+    private
+
+    def zipkey(key)
+      key
+    end
+
+    def unzipkey(key)
+      key
+    end
+
+  end
+
+  class ZipKeyHash < ZipHash
+
+    private
+
+    def zipval(value)
+      value
+    end
+
+    def unzipval(value)
+      value
+    end
+
+  end
+
+  class ZipVal
+
+    include Comparable
+
+    def initialize(value)
+      @value = zip(value)
+    end
+
+    def <=>(other)
+      to_s <=> other.to_s if self.class.equal?(other.class)
+    end
+
+    def to_s
+      unzip(@value)
+    end
+
+    def inspect
+      !((s = to_s).length > 64 || s.include?($/)) ? to_s :
+        '#<%s:0x%x length=%p>' % [self.class, object_id, @value.length]
+    end
+
+    def hash
+      to_s.hash
+    end
+
+    def eql?(other)
+      (self <=> other) == 0
+    end
+
+    alias_method :==, :eql?
+
+    private
+
+    def zip(string)
+      Zlib::Deflate.deflate(string)
+    end
+
+    def unzip(string)
+      Zlib::Inflate.inflate(string)
+    end
+
+  end
+
+  class ZipKey < ZipVal
+  end
+
+    end
+  end
+end

data/lib/nuggets/i18n.rb

@@ -0,0 +1,155 @@
+# encoding: utf-8
+
+#--
+###############################################################################
+#                                                                             #
+# 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 I18n
+
+    DIACRITICS = {
+      'À' => 'A',  # LATIN CAPITAL LETTER A WITH GRAVE
+      'Á' => 'A',  # LATIN CAPITAL LETTER A WITH ACUTE
+      'Â' => 'A',  # LATIN CAPITAL LETTER A WITH CIRCUMFLEX
+      'Ã' => 'A',  # LATIN CAPITAL LETTER A WITH TILDE
+      'Ä' => 'AE', # LATIN CAPITAL LETTER A WITH DIAERESIS
+      'Å' => 'A',  # LATIN CAPITAL LETTER A WITH RING ABOVE
+      'Æ' => 'AE', # LATIN CAPITAL LETTER AE
+      'Ç' => 'C',  # LATIN CAPITAL LETTER C WITH CEDILLA
+      'È' => 'E',  # LATIN CAPITAL LETTER E WITH GRAVE
+      'É' => 'E',  # LATIN CAPITAL LETTER E WITH ACUTE
+      'Ê' => 'E',  # LATIN CAPITAL LETTER E WITH CIRCUMFLEX
+      'Ë' => 'E',  # LATIN CAPITAL LETTER E WITH DIAERESIS
+      'Ì' => 'I',  # LATIN CAPITAL LETTER I WITH GRAVE
+      'Í' => 'I',  # LATIN CAPITAL LETTER I WITH ACUTE
+      'Î' => 'I',  # LATIN CAPITAL LETTER I WITH CIRCUMFLEX
+      'Ï' => 'I',  # LATIN CAPITAL LETTER I WITH DIAERESIS
+      'Ð' => 'DH', # LATIN CAPITAL LETTER ETH
+      'Ñ' => 'N',  # LATIN CAPITAL LETTER N WITH TILDE
+      'Ò' => 'O',  # LATIN CAPITAL LETTER O WITH GRAVE
+      'Ó' => 'O',  # LATIN CAPITAL LETTER O WITH ACUTE
+      'Ô' => 'O',  # LATIN CAPITAL LETTER O WITH CIRCUMFLEX
+      'Õ' => 'O',  # LATIN CAPITAL LETTER O WITH TILDE
+      'Ö' => 'OE', # LATIN CAPITAL LETTER O WITH DIAERESIS
+      'Ø' => 'O',  # LATIN CAPITAL LETTER O WITH STROKE
+      'Ù' => 'U',  # LATIN CAPITAL LETTER U WITH GRAVE
+      'Ú' => 'U',  # LATIN CAPITAL LETTER U WITH ACUTE
+      'Û' => 'U',  # LATIN CAPITAL LETTER U WITH CIRCUMFLEX
+      'Ü' => 'UE', # LATIN CAPITAL LETTER U WITH DIAERESIS
+      'Ý' => 'Y',  # LATIN CAPITAL LETTER Y WITH ACUTE
+      'Þ' => 'TH', # LATIN CAPITAL LETTER THORN
+      'ß' => 'ss', # LATIN SMALL LETTER SHARP S
+      'à' => 'a',  # LATIN SMALL LETTER A WITH GRAVE
+      'á' => 'a',  # LATIN SMALL LETTER A WITH ACUTE
+      'â' => 'a',  # LATIN SMALL LETTER A WITH CIRCUMFLEX
+      'ã' => 'a',  # LATIN SMALL LETTER A WITH TILDE
+      'ä' => 'ae', # LATIN SMALL LETTER A WITH DIAERESIS
+      'å' => 'a',  # LATIN SMALL LETTER A WITH RING ABOVE
+      'æ' => 'ae', # LATIN SMALL LETTER AE
+      'ç' => 'c',  # LATIN SMALL LETTER C WITH CEDILLA
+      'è' => 'e',  # LATIN SMALL LETTER E WITH GRAVE
+      'é' => 'e',  # LATIN SMALL LETTER E WITH ACUTE
+      'ê' => 'e',  # LATIN SMALL LETTER E WITH CIRCUMFLEX
+      'ë' => 'e',  # LATIN SMALL LETTER E WITH DIAERESIS
+      'ì' => 'i',  # LATIN SMALL LETTER I WITH GRAVE
+      'í' => 'i',  # LATIN SMALL LETTER I WITH ACUTE
+      'î' => 'i',  # LATIN SMALL LETTER I WITH CIRCUMFLEX
+      'ï' => 'i',  # LATIN SMALL LETTER I WITH DIAERESIS
+      'ð' => 'dh', # LATIN SMALL LETTER ETH
+      'ñ' => 'n',  # LATIN SMALL LETTER N WITH TILDE
+      'ò' => 'o',  # LATIN SMALL LETTER O WITH GRAVE
+      'ó' => 'o',  # LATIN SMALL LETTER O WITH ACUTE
+      'ô' => 'o',  # LATIN SMALL LETTER O WITH CIRCUMFLEX
+      'õ' => 'o',  # LATIN SMALL LETTER O WITH TILDE
+      'ö' => 'oe', # LATIN SMALL LETTER O WITH DIAERESIS
+      'ø' => 'o',  # LATIN SMALL LETTER O WITH STROKE
+      'ù' => 'u',  # LATIN SMALL LETTER U WITH GRAVE
+      'ú' => 'u',  # LATIN SMALL LETTER U WITH ACUTE
+      'û' => 'u',  # LATIN SMALL LETTER U WITH CIRCUMFLEX
+      'ü' => 'ue', # LATIN SMALL LETTER U WITH DIAERESIS
+      'ý' => 'y',  # LATIN SMALL LETTER Y WITH ACUTE
+      'þ' => 'th', # LATIN SMALL LETTER THORN
+      'ÿ' => 'y'   # LATIN SMALL LETTER Y WITH DIAERESIS
+    }
+
+    def self.args_for_map_diacritics
+      @args_for_map_diacritics ||= begin
+        map = ::Hash.new { |h, k| h[k] = [] }
+
+        DIACRITICS.each { |a| a.each { |i| map[i].concat(a) } }
+        map.each { |k, v| v.uniq!; map[k] = "(#{::Regexp.union(*v).source})" }
+
+        [::Regexp.union(*map.keys.sort_by { |k| -k.length }), map.method(:[])]
+      end
+    end
+
+  end
+end
+
+class String
+
+  # call-seq:
+  #   str.replace_diacritics => new_str
+  #
+  # Substitutes any diacritics in _str_ with their replacements as per
+  # Nuggets::I18n::DIACRITICS.
+  def replace_diacritics
+    (_dup = dup).replace_diacritics! || _dup
+  end
+
+  # call-seq:
+  #   str.replace_diacritics! => str or +nil+
+  #
+  # Destructive version of #replace_diacritics.
+  def replace_diacritics!
+    diacritics = ::Nuggets::I18n::DIACRITICS
+
+    gsub!(/#{::Regexp.union(*diacritics.keys)}/) { |m|
+      s = diacritics[m]
+
+      # Try to adjust case:
+      #   'Äh' => 'AEh' => 'Aeh'
+      #
+      # But:
+      #   'SÖS' => 'SOES' (not 'SOeS'!)
+      if s.length > 1
+        t = $'[0, 1]
+        s[1..-1] = s[1..-1].downcase if t == t.downcase
+      end
+
+      s
+    }
+  end
+
+  def map_diacritics
+    (_dup = dup).map_diacritics! || _dup
+  end
+
+  def map_diacritics!
+    re, block = ::Nuggets::I18n.args_for_map_diacritics
+    gsub!(re, &block)
+  end
+
+end

data/lib/nuggets/integer/factorial.rb

@@ -0,0 +1,56 @@
+#--
+###############################################################################
+#                                                                             #
+# 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/>.             #
+#                                                                             #
+###############################################################################
+#++
+
+class Integer
+
+  # Memoization container: integer => factorial(integer)
+  FACTORIAL = { 0 => 1 }
+
+  # call-seq:
+  #   int.factorial => anInteger
+  #
+  # Calculate the factorial of _int_. To use the memoized version:
+  # <tt>Integer.send(:alias_method, :factorial, :factorial_memoized)</tt>
+  def factorial
+    (1..self).inject { |f, i| f * i }
+  end
+
+  # call-seq:
+  #   int.factorial_memoized => anInteger
+  #
+  # Calculate the factorial of _int_ with the help of memoization (Which gives
+  # a considerable speedup for repeated calculations -- at the cost of memory).
+  #
+  # WARNING: Don't try to calculate the factorial this way for "large"
+  # integers! This might well bring your system down to its knees... ;-)
+  def factorial_memoized
+    FACTORIAL[self] ||= (1..self).inject { |f, i| FACTORIAL[i] ||= f * i }
+  end
+
+  alias_method :fac, :factorial
+  alias_method :f!,  :factorial
+
+end