nuggets 0.9.9 → 1.0.0

data/lib/nuggets/string/case.rb

@@ -0,0 +1,81 @@
+#--
+###############################################################################
+#                                                                             #
+# 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 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

data/lib/nuggets/string/evaluate.rb

@@ -0,0 +1,5 @@
+require 'nuggets/string/evaluate_mixin'
+
+class String
+  include Nuggets::String::EvaluateMixin
+end

data/lib/nuggets/string/evaluate_mixin.rb

@@ -0,0 +1,47 @@
+#--
+###############################################################################
+#                                                                             #
+# 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 String
+    module EvaluateMixin
+
+  # call-seq:
+  #   str.evaluate([binding, [filename, [lineno]]]) => 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 <tt>"#{...}"</tt> that can get evaluated in a
+  # different environment (= +binding+) at a later point.
+  #
+  # Passes optional arguments +filename+ and +lineno+ on to Kernel#eval.
+  def evaluate(binding = ::TOPLEVEL_BINDING, filename = nil, lineno = nil)
+    buffer = gsub(/\\*"/) { |m| "#{"\\" * m.length}#{m}" }
+    eval(%Q{"#{buffer}"}, binding, filename || __FILE__, lineno || __LINE__)
+  end
+
+    end
+  end
+end

data/lib/nuggets/string/msub.rb

@@ -0,0 +1,84 @@
+#--
+###############################################################################
+#                                                                             #
+# 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/string/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+ can be a string (which may contain string
+  # expressions; cf. #evaluate), a proc (which will be call()ed), or any object
+  # really (which will be converted into a string).
+  def msub(*substitutions)
+    (_dup = dup).msub!(*substitutions) || _dup
+  end
+
+  # call-seq:
+  #   str.msub!(*substitutions) => str or +nil+
+  #
+  # Destructive version of #msub.
+  def msub!(*substitutions)
+    options = substitutions.last.is_a?(::Hash) ? substitutions.pop : {}
+    binding = options.delete(:__binding__) || ::Kernel.binding
+
+    keys, subs, cache = [], [], {}
+
+    substitutions.concat(options.to_a).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] ||= begin
+        value = subs.find { |key, _| key =~ match }.last
+
+        if value.respond_to?(:evaluate)
+          # make match available for string evaluation
+          eval("__match__ = #{match.inspect}", binding)
+
+          value.evaluate(binding)
+        elsif value.respond_to?(:call)
+          value.call(match)
+        else
+          value
+        end
+      end
+    }
+  end
+
+end

data/lib/nuggets/string/nsub.rb

@@ -0,0 +1,65 @@
+#--
+###############################################################################
+#                                                                             #
+# 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 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 = 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)
+    pattern, i = args.first, 0
+
+    case args.size
+      when 2
+        # Only +count+ given
+        count = args.last
+
+        gsub!(pattern) { |match| (i += 1) <= count ? yield(match) : match }
+      when 3
+        # Both +replacement+ and +count+ given;
+        # ignore block (just like String#gsub does)
+        replacement, count = args.values_at(1, 2)
+
+        gsub!(pattern) { |match| (i += 1) <= count ? replacement : match }
+      else
+        raise ::ArgumentError, "wrong number of arguments (#{args.size} for 2-3)"
+    end
+  end
+
+end

data/lib/nuggets/string/sub_with_md.rb

@@ -0,0 +1,111 @@
+#--
+###############################################################################
+#                                                                             #
+# 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 String
+
+  alias_method :sub_without_md,   :sub
+  alias_method :sub_without_md!,  :sub!
+  alias_method :gsub_without_md,  :gsub
+  alias_method :gsub_without_md!, :gsub!
+
+  # call-seq:
+  #   str.sub_with_md(pattern) { |match_data| ... } => new_str
+  #
+  # Just like #sub, but passes the MatchData object instead of the current
+  # match string to the block.
+  def sub_with_md(pattern, replacement = nil, &block)
+    replacement ?
+      sub_without_md(pattern, replacement) :
+      (_dup = dup).sub_with_md!(pattern, &block) || _dup
+  end
+
+  # call-seq:
+  #   str.sub_with_md!(pattern) { |match_data| ... } => str or +nil+
+  #
+  # Destructive version of #sub_with_md.
+  def sub_with_md!(pattern, replacement = nil)
+    replacement ?
+      sub_without_md!(pattern, replacement) :
+      sub_without_md!(pattern) { |match| yield $~ }
+  end
+
+  # call-seq:
+  #   str.gsub_with_md(pattern) { |match_data| ... } => new_str
+  #
+  # Just like #gsub, but passes the MatchData object instead of the current
+  # match string to the block.
+  def gsub_with_md(pattern, replacement = nil, &block)
+    replacement ?
+      gsub_without_md(pattern, replacement) :
+      (_dup = dup).gsub_with_md!(pattern, &block) || _dup
+  end
+
+  # call-seq:
+  #   str.gsub_with_md!(pattern) { |match_data| ... } => str or +nil+
+  #
+  # Destructive version of #gsub_with_md.
+  def gsub_with_md!(pattern, replacement = nil)
+    replacement ?
+      gsub_without_md!(pattern, replacement) :
+      gsub_without_md!(pattern) { |match| yield $~ }
+  end
+
+  # call-seq:
+  #   gimme_match_data!
+  #
+  # Replaces the traditional substitution methods with their MatchData passing
+  # equivalents. USE WITH CAUTION!
+  def self.gimme_match_data!
+    alias_method :sub,   :sub_with_md
+    alias_method :sub!,  :sub_with_md!
+    alias_method :gsub,  :gsub_with_md
+    alias_method :gsub!, :gsub_with_md!
+  end
+
+end
+
+if $0 == __FILE__
+  s = 'Foo, Bar - Baz'
+  p s
+
+  String.gimme_match_data!
+
+  p s.gsub(/\w(\w+)(\W*)/) { |m|
+    begin
+      "#{$1.gsub(/[ao]/, 'X')}#{$2}"
+    rescue NoMethodError => err
+      warn err
+    end
+  }
+
+  p s.gsub(/\w(\w+)(\W*)/) { |md|
+    "#{md[1].gsub(/[ao]/, 'X')}#{md[2]}"
+  }
+
+  p s.gsub(/\w(\w+)(\W*)/) { |md|
+    "#{md[1].gsub(/[ao]/) { |md2| md2[0].upcase }}#{md[2]}"
+  }
+end

data/lib/nuggets/string/wc.rb

@@ -0,0 +1,5 @@
+require 'nuggets/string/wc_mixin'
+
+class String
+  include Nuggets::String::WcMixin
+end

data/lib/nuggets/string/wc_mixin.rb

@@ -0,0 +1,95 @@
+#--
+###############################################################################
+#                                                                             #
+# 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 String
+    module WcMixin
+
+  # call-seq:
+  #   str.wc => anArray
+  #
+  # Count number of lines, words, and bytes in _str_.
+  def wc
+    [wc_l, wc_w, wc_c]
+  end
+
+  # call-seq:
+  #   str.line_count => anInteger
+  #
+  # Count number of lines in _str_.
+  def line_count
+    count_by_re(/#{$/}/)
+  end
+  alias_method :wc_l, :line_count
+
+  # call-seq:
+  #   str.word_count => anInteger
+  #
+  # Count number of words in _str_.
+  def word_count
+    count_by_re(/\S+/)
+  end
+  alias_method :wc_w, :word_count
+
+  # call-seq:
+  #   str.byte_count => anInteger
+  #
+  # Count number of bytes in _str_.
+  def byte_count
+    respond_to?(:bytesize) ? bytesize : count_by_re(//n) - 1
+  end
+  alias_method :wc_c, :byte_count
+
+  # call-seq:
+  #   str.char_count => anInteger
+  #
+  # Count number of characters in _str_.
+  def char_count
+    count_by_re(/./um)
+  end
+  alias_method :wc_m, :char_count
+
+  # call-seq:
+  #   str.count_by_re(re) => anInteger
+  #
+  # Count number of occurrences of +re+ in _str_.
+  def count_by_re(re)
+    scan(re).size
+  end
+
+  # call-seq:
+  #   str.count_by_re2(re) => anInteger
+  #
+  # A more memory-efficient version of #count_by_re.
+  def count_by_re2(re)
+    count = 0
+    scan(re) { |_| count += 1 }
+    count
+  end
+
+    end
+  end
+end