ruby-nuggets 0.0.1.126

data/lib/nuggets/object/singleton_class.rb

@@ -0,0 +1,46 @@
+#--
+###############################################################################
+#                                                                             #
+# 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 Object
+
+  # call-seq:
+  #   object.singleton_class => aClass
+  #
+  # Returns the singleton class associated with _object_.
+  def singleton_class
+    class << self; self; end
+  end
+  alias_method :eigenclass, :singleton_class
+  alias_method :metaclass,  :singleton_class
+
+end
+
+if $0 == __FILE__
+  o = Object.new
+  p o
+  p o.singleton_class
+end

data/lib/nuggets/string/case.rb

@@ -0,0 +1,104 @@
+#--
+###############################################################################
+#                                                                             #
+# 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 String
+
+  module Case
+
+    LOWER = :lower
+    UPPER = :upper
+    MIXED = :mixed
+
+  end
+
+  # call-seq:
+  #   str.case => aSymbol
+  #
+  # Returns a symbol indicating the case of _str_.
+  def case
+    self == downcase ? Case::LOWER :
+    self == upcase   ? Case::UPPER :
+                       Case::MIXED
+  end
+
+  # call-seq:
+  #   str.lower_case? => true or false
+  #
+  # Tell whether _str_ is all lower case.
+  def lower_case?
+    self.case == Case::LOWER
+  end
+  alias_method :downcase?, :lower_case?
+
+  # call-seq:
+  #   str.upper_case? => true or false
+  #
+  # Tell whether _str_ is all upper case.
+  def upper_case?
+    self.case == Case::UPPER
+  end
+  alias_method :upcase?, :upper_case?
+
+  # call-seq:
+  #   str.mixed_case? => true or false
+  #
+  # Tell whether _str_ is mixed case.
+  def mixed_case?
+    self.case == Case::MIXED
+  end
+
+  # call-seq:
+  #   str.capitalized? => true or false
+  #
+  # Tell whether _str_ is capitalized.
+  def capitalized?
+    self == capitalize
+  end
+
+end
+
+if $0 == __FILE__
+  s = 'Some string'
+  puts s
+  p    s.case
+  puts s.downcase?
+  puts s.upcase?
+  puts s.mixed_case?
+  puts s.capitalized?
+
+  s = 'some string'
+  puts s
+  p    s.case
+  puts s.downcase?
+  puts s.mixed_case?
+
+  s = 'SOME STRING'
+  puts s
+  p    s.case
+  puts s.upcase?
+  puts s.mixed_case?
+end

data/lib/nuggets/string/evaluate.rb

@@ -0,0 +1,53 @@
+#--
+###############################################################################
+#                                                                             #
+# 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 String
+
+  # call-seq:
+  #   str.evaluate(binding = TOPLEVEL_BINDING) => new_str
+  #
+  # Basically turns Kernel#eval into an instance method of String -- inspired
+  # by Ruby Cookbook example 1.3. This allows to pre-populate strings with
+  # substitution expressions ("#{...}") that can get evaluated in a different
+  # environment (= +binding+) at a later point.
+  def evaluate(binding = TOPLEVEL_BINDING)
+    eval(%Q{"#{self}"}, binding)
+  end
+
+end
+
+if $0 == __FILE__
+  s = 'bl#{a}blub'
+  p s
+
+  def foo(bar) # :nodoc:
+    a = 'ub'
+    bar.evaluate(binding)
+  end
+
+  p foo(s)
+end

data/lib/nuggets/string/msub.rb

@@ -0,0 +1,82 @@
+#--
+###############################################################################
+#                                                                             #
+# 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/>.              #
+#                                                                             #
+###############################################################################
+#++
+
+require File.join(File.dirname(__FILE__), 'evaluate')
+
+class String
+
+  # call-seq:
+  #   str.msub(*substitutions) => new_str
+  #
+  # Performs _multiple_ substitutions on _str_ with order being taken into
+  # account (thus results of previous substitutions won't be subject to later
+  # ones) -- inspired by Ruby Cookbook example 1.18.
+  #
+  # The +substitutions+ parameter can be an array or a list of <tt>[pattern,
+  # substitution]</tt> pairs, or, simply, a hash. Note that, when using a hash,
+  # the ordering of how substitutions are processed might differ from what you
+  # intended -- instead use an array when order matters. +pattern+ can be a
+  # string or a regexp, +substitution+ may contain string expressions (cf.
+  # #evaluate).
+  def msub(*substitutions)
+    dup.msub!(*substitutions) || dup
+  end
+
+  # call-seq:
+  #   str.msub!(*substitutions) => str or nil
+  #
+  # Destructive version of #msub.
+  def msub!(*substitutions)
+    substitutions = *substitutions  # Handle hashes and arrays alike
+    keys, subs, cache = [], [], {}
+
+    substitutions.each { |key, value|
+      key = Regexp.new(Regexp.escape(key)) unless key.is_a?(Regexp)
+
+      keys << key
+      subs << [key, value]
+    }
+
+    gsub!(Regexp.union(*keys)) { |match|
+      cache[match] ||= subs.find { |key,|
+        key =~ match
+      }.last.evaluate(binding)
+    }
+  end
+
+end
+
+if $0 == __FILE__
+  s = 'Foo, Bar - Baz'
+  p s
+
+  p s.gsub(/a/, 'o').gsub(/o/, 'a')
+  p s.msub('a' => 'o', 'o' => 'a')
+
+  s.msub!('a' => 'o','o' => 'a')
+  p s
+end

data/lib/nuggets/string/nsub.rb

@@ -0,0 +1,82 @@
+#--
+###############################################################################
+#                                                                             #
+# 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 String
+
+  # call-seq:
+  #   str.nsub(pattern, replacement, count) => new_str
+  #   str.nsub(pattern, count) { |match| ... } => new_str
+  #
+  # Returns a copy of _str_ with the _first_ +count+ occurrences of pattern
+  # replaced with either +replacement+ or the value of the block.
+  def nsub(*args, &block)
+    dup.nsub!(*args, &block) || dup
+  end
+
+  # call-seq:
+  #   str.nsub!(pattern, replacement, count) => str or nil
+  #   str.nsub!(pattern, count) { |match| ... } => str or nil
+  #
+  # Performs the substitutions of #nsub in place, returning _str_, or +nil+ if
+  # no substitutions were performed.
+  def nsub!(*args, &block)
+    case args.size
+      when 2
+        pattern = args.shift
+
+        # Only +count+ given; require block
+        count = *args
+        raise(ArgumentError, 'no block given') unless block_given?
+      when 3
+        pattern = args.shift
+
+        # Both +replacement+ and +count+ given;
+        # ignore block (just like String#gsub does)
+        replacement, count = *args
+        block = lambda { replacement }
+      else
+        raise ArgumentError, "wrong number of arguments (#{args.size} for 2-3)"
+    end
+    
+    i = 0
+    gsub!(pattern) { |match|
+      (i += 1) <= count ? block[match] : match
+    }
+  end
+
+end
+
+if $0 == __FILE__
+  s = 'a b c d e f g h i'
+  puts s
+
+  puts s.nsub(' ', '', 6)
+  puts s.nsub(' ', 6) { '' }
+
+  s.nsub!(' ', '', 6)
+  puts s
+end

data/lib/nuggets/string/word_wrap.rb

@@ -0,0 +1,111 @@
+#--
+###############################################################################
+#                                                                             #
+# 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/>.              #
+#                                                                             #
+###############################################################################
+#++
+
+require 'enumerator'
+
+class String
+
+  # call-seq:
+  #   str.word_wrap(line_width) => new_str
+  #
+  # Word wrap a string not exceeding +line_width+. Based on the Ruby Facets
+  # implementation, but preserves paragraphs. Thus
+  # <tt>str == str.word_wrap(str.split("\n").map { |l| l.length }.max)</tt>.
+  def word_wrap(line_width = 80, as_array = false)
+    wrapped = []
+
+    split(/(\n+)/).to_enum(:each_slice, 2).each { |paragraph, linebreaks|
+      wrapped << paragraph.word_wrap_paragraph!(line_width) << linebreaks
+    }
+
+    wrapped = wrapped.join
+    
+    as_array ? wrapped.split("\n") : wrapped
+  end
+
+  # call-seq:
+  #   str.word_wrap!(line_width) => str
+  #
+  # As with #word_wrap, but modifies the string in place.
+  def word_wrap!(line_width = 80)
+    replace word_wrap(line_width)
+  end
+
+  # call-seq:
+  #   str.word_wrap_paragraph(line_width) => new_str
+  #
+  # Similar to #word_wrap, but assumes a single paragraph.
+  def word_wrap_paragraph(line_width = 80)
+    dup.word_wrap_paragraph!(line_width) || dup
+  end
+
+  # call-seq:
+  #   str.word_wrap_paragraph!(line_width) => str
+  #
+  # Destructive version of #word_wrap_paragraph.
+  def word_wrap_paragraph!(line_width = 80)
+    gsub!(/(.{1,#{line_width}})(?:\s+|$)/, "\\1\n")
+    sub!(/\n$/, '')
+
+    self
+  end
+
+end
+
+if $0 == __FILE__
+  s = <<EOT
+Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Nullam nulla arcu,
+ullamcorper non, vulputate eget, elementum quis, sapien. Quisque consequat
+porta enim. Phasellus porta libero et turpis. Ut felis.
+
+Phasellus eget est a enim rutrum accumsan. Integer nec purus. Maecenas
+facilisis urna sed arcu. Suspendisse potenti.
+
+
+Vestibulum lacus metus, faucibus sit amet, mattis non, mollis sed, pede. Aenean
+vitae sem nec sem euismod sollicitudin. Cras rhoncus.
+
+
+
+Phasellus condimentum, ante a cursus dictum, lectus ipsum convallis magna, sed
+tincidunt massa eros vitae ante. Suspendisse nec sem.
+In hac habitasse platea dictumst. Fusce purus leo, ullamcorper sit amet, luctus
+in, mollis mollis, enim. In adipiscing erat.
+EOT
+  puts s
+
+  puts '=' * 80
+
+  puts s.word_wrap(60)
+  puts '=' * 80
+  puts s.word_wrap(79)
+
+  puts '=' * 80
+
+  s.word_wrap!(60)
+  puts s
+end