quality_extensions 0.1.1

data/lib/qualitysmith_extensions/object/send_if.rb

@@ -0,0 +1,151 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes.
+# Developer notes::
+# * The name of this method maybe ought to be a little more specific. What does anyone else think?
+#   * It should say something about the fact that it the message sending is conditional but the block execution is unconditional.
+#   * always_execute_block_but_only_send_message_if ? Hmm... a bit too verbose, perhaps.
+#   * conditional_passthrough ?
+#   * passthrough_unless ?
+#   * use_wrapper_method_if ?
+#   * Or just leave it how it is because all the alternatives are too long...
+#++
+
+require 'rubygems'
+gem 'facets'
+require 'facets/core/kernel/with'       # returning
+
+class Object
+  # Sends +message+ to +self+ (including +block_to_always_execute+ if supplied) if +condition+ is met. If +condition+ is _not_ met,
+  # +block_to_always_execute+ will still be called (if supplied), but we will _not_ pass the message. (If +condition+ is not met
+  # and +block_to_always_execute+ is not supplied, it will simply return +self+.)
+  #
+  # In summary:
+  # * +block+: _always_ executed
+  # * +message+: only sent if +condition+
+  #
+  # If a block (+block_to_always_execute+) is supplied, it is passed on to the message if the condition is met; (otherwise it is
+  # simply called without sending the message).
+  #
+  # This is useful if you want to wrap a block with some method but you only want the method itself to be used some of the time.
+  # For example, if it's for benchmarking, you may only want to enable it during development but disable during production to save on some overhead.
+  #
+  # Note: this cannot be used to call methods that expect blocks (Ruby 1.9 maybe?)
+  #
+  def send_if(condition, message, *args, &block_to_always_execute)
+      if condition
+        self.__send__(message, *args, &block_to_always_execute)
+      else
+        if block_given?
+          block_to_always_execute.call
+        else
+          self
+        end
+      end
+  end
+
+  # Opposite of send_if
+  def send_unless(condition, *args, &block)
+    self.send_if(!condition, *args, &block)
+  end
+
+  # Lets you reduce duplication a little bit. Can do this:
+  #   @foo.send_if_true(color)
+  # instead of this:
+  #   @foo.send_if(color, color)
+  #
+  def send_if_true(condition, *args, &block)
+    self.send_if(condition, condition, *args, &block)
+  end
+end
+
+
+
+
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+
+class Foo
+  attr_reader :called_benchmark
+  def benchmark(&block)
+    @called_benchmark = true
+    yield
+    sleep 0.1     # Simulate lots of overhead, which we may want to avoid if we can help it
+  end
+end
+class String
+  def pink
+    "#{self} (in pink)"
+  end
+end
+
+class TheTest < Test::Unit::TestCase
+  def setup
+    @foo = Foo.new
+    @string = 'food'
+  end
+
+  def test_send_if_with_true_condition
+    executed_block = false
+    @foo.send_if(true, :benchmark) do
+      executed_block = true
+    end
+    assert executed_block
+    assert @foo.called_benchmark
+  end
+
+  def test_send_if_with_false_condition
+    executed_block = false
+    @foo.send_if(false, :benchmark) do
+      executed_block = true
+    end
+    assert executed_block
+    assert !@foo.called_benchmark
+  end
+
+  def test_send_if_with_no_block
+    color = nil
+    returned = @string.send_if(color, color)
+    assert_equal 'food', @string
+    assert_equal @string, returned
+
+    color = :pink
+    returned = @string.send_if(color, color)
+    assert_equal 'food', @string    # @string itself should be unchanged, but the return value should be be a modified form of @string
+    assert_equal "#{@string} (in pink)", returned
+  end
+  def test_send_if_true_with_no_block
+    color = nil
+    returned = @string.send_if_true(color)
+    assert_equal 'food', @string
+    assert_equal @string, returned
+
+    color = :pink
+    returned = @string.send_if_true(color)
+    assert_equal 'food', @string
+    assert_equal "#{@string} (in pink)", returned
+  end
+
+  def test_send_unless
+    executed_block = false
+    @foo.send_unless(false, :benchmark) do
+      executed_block = true
+    end
+    assert executed_block
+    assert @foo.called_benchmark
+  end
+
+end
+=end
+

data/lib/qualitysmith_extensions/object/send_if_not_nil.rb

@@ -0,0 +1,35 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Maybe.
+# Developer notes::
+#++
+
+class Object
+  def send_if_not_nil(message, *args)
+    if message
+      send(message, *args) 
+    else
+      self
+    end
+  end
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+
+class TheTest < Test::Unit::TestCase
+  def test_1
+    assert_equal 'a', 'a'.send_if_not_nil(nil)
+    assert_equal 'A', 'a'.send_if_not_nil(:upcase)
+  end
+end
+=end

data/lib/qualitysmith_extensions/object/singleton_send.rb

@@ -0,0 +1,129 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Maybe.
+# Developer notes::
+# * Method name too long? Imagine if we wanted to string multiple calls together.
+#   * Ideas:
+#     * single_send
+#     * singleton_send
+#     * singleton_call
+#     * singleton
+#     * singsend
+#     * extend_send
+#     * extend_call
+#     * create_and_send
+#     * create_and_call
+#++
+
+class Object
+
+  # Creates a singleton method and then calls it.
+  #
+  # More specificaly, it <tt>extend</tt>s +self+ with the methods from +moduule+ and then sends the supplied +message+ and +args+ (if any).
+  #
+  # Examples:
+  #   "whatever".ss(MyColorizer, :colorize, :blue)
+  #
+  # Advantages:
+  # * Keeps things object-oriented. Better than having global/class methods.
+  #   * (<tt>"whatever".ss(MyColorizer, :colorize).ss(SomeOtherClass, :another_class_method)</tt> instead of 
+  #     * <tt>SomeOtherClass::another_class_method(MyColorizer::colorize("whatever"))</tt>)
+  #   * Method calls are _listed_ in the order in which they are _called_.
+  # * Still lets you keep your methods in a namespace.
+  # * Doesn't clutter up the base classes with methods that are only useful within a very small context. The methods are only added to the objects you specify. So you can "use" the base class <b>without cluttering up _all_ instances of the class with your methods</b>.
+  # * Useful for cases where creating a subclass wouldn't help because the methods you are calling would still return instances of the base class.
+  #
+  # Disadvantages:
+  # * You have to have/create a *module* for the functions you want to use.
+  #   * Can't just call .sigleton_send(self, :some_method) if you want to use +some_method+ that's defined in +self+.
+  #   * So what do we call the module containing the "singleton method"? String::MyColorizer? MyColorizer::String? MyStringColorizer?
+  #
+  # Adding methods to the base class using Facets' own *namespacing* facilities (Module#namespace and Module#include_as)
+  # might actually be a more sensible alternative a lot of the time than bothering to create singleton methods for single objects!
+  # That would look somethig like:
+  #
+  #   class String
+  #     namespace :my_colorizer do
+  #       def colorize(...); ...; end
+  #     end
+  #   end
+  #   "whatever".my_colorizer.colorize(:blue)
+  #
+  # or
+  #
+  #   class String
+  #     include_as :my_colorizer => MyColorizer
+  #   end
+  #   "whatever".my_colorizer.colorize(:blue)
+  #
+  def singleton_send(moduule, message, *args, &block)
+    self.extend(moduule)
+    self.send(message, *args, &block)
+  end
+  alias_method :ss, :singleton_send
+
+  # Couldn't get this idea to work:
+#  def singleton_that_accepts_object(object, method_name, *args)
+##    #class << self 
+##    #self.instance_eval do
+##    self.class.module_eval do
+##      define_method(:colorize2, object.class.instance_method(:colorize2))
+##    end
+##    # raises "TypeError: bind argument must be an instance of TheTest"
+#
+##    object.class.instance_method(method_name).
+##      bind(self)
+##    # raises "TypeError: bind argument must be an instance of TheTest"
+#
+##    self.class.extend(object.class)
+##    self.class.send(:include, object.class)
+##    # raises "TypeError: wrong argument type Class (expected Module)"
+#    self.send(method_name, *args)
+#  end
+
+end
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+require 'rubygems'
+require 'qualitysmith_extensions/test/assert_exception'
+require 'qualitysmith_extensions/test/assert_includes'
+
+
+module MyColorizer
+  def colorize(color = nil)
+    self + " (colorized in #{color})"
+  end
+end
+
+#module PresentationLayer
+#  create_module_method :to_currency do
+#    #...
+#  end
+#end
+
+
+class TheTest1_UsingSingletonSend < Test::Unit::TestCase
+  def test_using_singleton_send
+    assert_equal "whatever (colorized in )",     "whatever".ss(MyColorizer, :colorize)
+    assert_equal "whatever (colorized in blue)", "whatever".ss(MyColorizer, :colorize, :blue)
+  end
+
+#  def test_singleton_that_accepts_object
+#    assert_equal "whatever (colorized in )", "whatever".singleton_that_accepts_object(self, :colorize2)
+#    assert_equal "whatever (colorized in blue)", "whatever".singleton_that_accepts_object(self, :colorize2, :blue)
+#  end
+#  def colorize2(color = nil)
+#    self + " (colorized2 in #{color})"
+#  end
+end
+=end
+

data/lib/qualitysmith_extensions/regexp/join.rb

@@ -0,0 +1,111 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes.
+# Developer notes::
+# * Names considered:
+#   * intersection (since there's already a Regexp#union), but unlike Regexp#union, it really doesn't seem like this method lends itself to a name from set theory. Mostly because unlike when dealing with sets (or unioned Regexps), *order matters* here.
+#   * merge, concat, sum, add, combines
+#   * join -- Settled on this because it's a lot like File.join: it combines the given pieces, *in order*, to make a whole.
+#++
+
+
+class Regexp
+  # Returns a Regexp that results from interpolating each of the given +elements+ into an empty regular expression.
+  #   /ab/ == Regexp.join(/a/, /b/)  # except spelled differently
+  # Accepts both strings and Regexp's as +elements+ to join together. Strings that are passed in will be escaped (so characters like '*' will lose all of the Regexp powers that they would otherwise have and are treated as literals).
+  #
+  # Serving suggestion: Use it to check if the +actual+ string in an <tt>assert_match</tt> contains certain literal strings, which may be separated by any number of characters or lines that we don't care about. In other words, use it to see if a string contains the necessary "keywords" or "key phrases"...
+  #   assert_match Regexp.join(
+  #     'keyword1',
+  #     /.*/m,
+  #     'keyword2'
+  #   ), some_method()
+  #   # where some_method() returns "keyword1 blah blah blah keyword2"
+  #
+  def self.join(*elements)
+    elements.inject(//) do |accumulator, element|
+      accumulator + element
+    end
+  end
+
+  # Pads the +elements+ (which may be strings or Regexp's) with /.*/ (match any number of characters) patterns.
+  # Pass :multi_line => true if you want /.*/m as the padding pattern instead.
+  def self.loose_join(*elements)
+    options = (if elements.last.is_a?(Hash) then elements.pop else {} end)
+    multi_line = options[:multi_line] || options[:m]
+    padding = (multi_line ? /.*/m : /.*/)
+    elements.inject(//) do |accumulator, element|
+      accumulator + padding + element
+    end
+  end
+
+  #   /a/ + /b/ == /ab/
+  # Actually, the way it's currently implemented, it is
+  #   /a/ + /b/ == /(?-mix:a)(?-mix:b)/
+  # But they seem to be functionally equivalent despite the different spellings.
+  def +(other)
+    other = Regexp.escape(other) if other.is_a?(String)
+    /#{self}#{other}/
+  end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+
+class TheTest < Test::Unit::TestCase
+  def test_1_simple_letters
+    assert_equal /(?-mix:)(?-mix:b)/,  // + /b/
+    assert_equal /(?-mix:)b/,          // + 'b'
+    assert_equal /(?-mix:a)(?-mix:b)/, /a/ + /b/
+    assert_equal /(?-mix:a)b/,         /a/ + 'b'
+    assert_equal /(?-mix:(?-mix:(?-mix:)a)b)c/, Regexp.join('a', 'b', 'c')
+    #assert_equal /(?-mix:(?-mix:(?-mix:)a)b)c/, Regexp.join(/a/, /b/, /c/)
+    assert_equal 2,   '__abc__' =~ Regexp.join('a', 'b', 'c')
+    assert_equal 2,   '__abc__' =~ Regexp.join(/a/, /b/, /c/)
+    assert_equal nil, '__a.c__' =~ Regexp.join('a', 'b', 'c')
+    assert_equal nil, '__a.c__' =~ Regexp.join(/a/, /b/, /c/)
+  end
+
+  def test_2_escaping
+    assert_equal /(?-mix:)\./,          // + '.'  # Escaped
+    assert_equal /(?-mix:)(?-mix:.)/,  // + /./   # Not escaped
+  end
+
+  def test_3
+    assert_match Regexp.join(
+      'keyword1',
+      /.*/m,
+      'keyword2'
+    ),
+'keyword1
+asuethausnthauesth
+blah blah blah
+keyword2'
+  end
+
+  def test_loose_join
+    regexp = Regexp.loose_join('keyword1', 'keyword2')
+    assert_match regexp, 'keyword1 blah blah blah keyword2'
+    assert_equal nil,    "keyword1 blah\nblah\nblah keyword2" =~ regexp
+  end
+  def test_loose_join_multiline
+    regexp = Regexp.loose_join('keyword1', 'keyword2', :m => true)
+    assert_match regexp, 'keyword1 blah blah blah keyword2'
+    assert_match regexp, "keyword1 blah\nblah\nblah keyword2"
+  end
+
+end
+=end
+
+

data/lib/qualitysmith_extensions/string/all.rb

@@ -0,0 +1,2 @@
+require File.dirname(__FILE__) + "/../kernel/require_all"
+require_all File.dirname(__FILE__), :exclude_files => 'all.rb'

data/lib/qualitysmith_extensions/string/constantize.rb

@@ -0,0 +1,4 @@
+require 'rubygems'
+# Alias for:
+require 'qualitysmith_extensions/symbol/constantize'
+

data/lib/qualitysmith_extensions/string/digits_only.rb

@@ -0,0 +1,27 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes
+#++
+
+class String
+  # Strips out everything except digits.
+  def digits_only
+    self.gsub(/[^0-9]/, "")
+  end
+end
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+class TheTest < Test::Unit::TestCase
+  def test_digits_only
+    assert_equal "123", "$!@)(*&abc123[]{}".digits_only
+  end
+end
+=end