qualitysmith_extensions 0.0.3

data/lib/qualitysmith_extensions/hash/to_query_string.rb

@@ -0,0 +1,119 @@
+# Author::    Anthony Kaufman, Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes.
+
+autoload :CGI, 'cgi'
+require 'rubygems'
+require 'facets/core/kernel/require_local'
+require_local '../array/to_query_string.rb'
+
+class Hash
+
+=begin rdoc
+  Converts into a string that can be used as the {query string}[http://en.wikipedia.org/wiki/Query_string] of a URL (for example, <tt>?key1=val1&key2=val2</tt>).
+
+  Example:
+    {
+      'colors' => ['red', 'blue'],
+      'username' => 'pineapple'
+    }.to_query_string('data')
+    ==> "data[username]=pineapple&data[colors][]=red&data[colors][]=blue"
+
+  The hash can be nested as deeply as you want and can also contain arrays.
+
+  <tt>key</tt> is the name of the key in params that will receive this hash when you load the page. So, for example, if you go to page with this query string (key = "name"): <tt>?name[first]=Fred&name[last]=Fredson</tt>, params will be have a key "name", like so: <tt>{"name"=>{"last"=>"Fredson", "first"=>"Fred"}}</tt>.
+
+    {
+      'colors' => ['red', 'blue'],
+      'username' => 'pineapple'
+    }.to_query_string('data')
+
+  is equivalent to just writing your hash like so:
+
+    {
+      'data' => {
+        'colors' => ['red', 'blue'],
+        'username' => 'pineapple'
+      }
+    }.to_query_string()
+=end
+  def to_query_string(key = '')
+    prefix = key.dup
+    elements = []
+
+    self.each_pair do |key, value|
+      key = CGI.escape key.to_s
+      key = prefix.length > 1 ? "#{prefix}[#{key}]" : key
+      if value.respond_to? :to_query_string
+        valuepre = value.dup
+        value = value.to_query_string(key)
+        #puts "#{key}#{valuepre.inspect} => #{value}"
+        elements << value
+      else
+        value = CGI.escape value.to_s
+        elements << key + '=' + value
+      end
+    end
+
+    elements.join('&')
+  end
+end
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+class TheTest < Test::Unit::TestCase
+  def test_hash_to_query_string_nesting
+    data = {
+      'foo' => 'bar',
+      'names' => {
+        'common' => 'smith',
+        'uncommon' => {
+          :first => 'lance',
+          :last => 'wilheiminkauf'
+        }
+      }
+    }
+    assert_equal 'foo=bar&names[common]=smith&names[uncommon][first]=lance&names[uncommon][last]=wilheiminkauf', data.to_query_string
+  end
+  def test_hash_to_query_string_nesting_2
+    data = {
+        'common' => 'smith',
+        'uncommon' => [
+          'frankenwatzel',
+          'wilheiminkauf'
+        ]
+    }
+    assert_equal 'names[common]=smith&names[uncommon][]=frankenwatzel&names[uncommon][]=wilheiminkauf', data.to_query_string('names')
+    assert_equal( {'names' => data}.to_query_string(), 
+                  data.to_query_string('names') )
+  end
+  
+  def test_hash_to_query_string_encoding
+    data = {'f&r' => 'a w$'}
+    
+    assert_equal 'f%26r=a+w%24', data.to_query_string
+  end
+end
+=end
+
+=begin examples
+require 'irb/xmp'
+xmp <<End
+    {
+      'colors' => ['red', 'blue'],
+      'username' => 'pineapple'
+    }.to_query_string('data')
+    {
+      'data' => {
+        'colors' => ['red', 'blue'],
+        'username' => 'pineapple'
+      }
+    }.to_query_string()
+End
+=end

data/lib/qualitysmith_extensions/kernel/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/kernel/backtrace.rb

@@ -0,0 +1,69 @@
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Not sure. This might not be necessary if caller() actually works reliably.
+
+require "rubygems"
+require "facet/string/lines"
+
+module Kernel
+  # Equivalent to calling caller(0)
+  def backtrace
+    full_backtrace = caller(0)
+    return full_backtrace[1..-1]    # We don't want this call to backtrace showing up in the backtrace, so skip top 1 frame.
+  end
+
+  # Returns a human-readable backtrace
+  def pretty_backtrace
+    "Backtrace:\n" +
+      backtrace[1..-1].map{|frame| "* " + frame}.join("\n")
+  end
+
+  # I thought I ran into some case where it didn't work to use caller(0)...which prompted me to do it this way (raise and rescue an exception)...but now I can't duplicate that problem, so I will deprecate this method.
+  def backtrace_using_exception
+    begin
+      raise "Where am I?"
+    rescue Exception => exception
+      full_backtrace = exception.backtrace
+      return full_backtrace[1..-1]    # We don't want this call to backtrace showing up in the backtrace, so skip top 1 frame.
+    end
+  end
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+class TheTest < Test::Unit::TestCase
+  def test_1_level
+    assert_match /^.*backtrace.rb:\d*:in `test_1_level'$/, backtrace[0]
+    assert_match /^.*testcase.rb:\d*:in `__send__'$/, backtrace[1]
+  end
+
+  def test_pretty_backtrace
+    assert_match /^Backtrace:$/, pretty_backtrace.lines[0]
+    assert_match /^.*backtrace.rb:\d*:in `test_pretty_backtrace'$/, pretty_backtrace.lines[1]
+    assert_match /^.*testcase.rb:\d*:in `__send__'$/, pretty_backtrace.lines[2]
+  end
+
+  def test_2_levels
+    assert_match /^.*backtrace.rb:\d*:in `a_method_that_returns_a_backtrace'$/, a_method_that_returns_a_backtrace[0]
+    assert_match /^.*backtrace.rb:\d*:in `test_2_levels'$/, a_method_that_returns_a_backtrace[1]
+    assert_match /^.*testcase.rb:\d*:in `__send__'$/, a_method_that_returns_a_backtrace[2]
+  end
+
+  def a_method_that_returns_a_backtrace
+    backtrace
+  end
+
+  def test_all_methods_of_getting_backtrace_are_equivalent
+    assert_equal backtrace_using_exception, backtrace
+    assert_equal backtrace_using_exception, caller(0)
+  end
+
+end
+=end

data/lib/qualitysmith_extensions/kernel/capture_output.rb

@@ -0,0 +1,113 @@
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes
+
+# :todo: Can we find a simpler way to do this based on facets' silence_stream?
+  #
+  # File lib/facets/core/kernel/silence_stream.rb, line 13
+  #  def silence_stream(stream)
+  #    old_stream = stream.dup
+  #    stream.reopen(RUBY_PLATFORM =~ /mswin/ ? 'NUL:' : '/dev/null')
+  #    stream.sync = true
+  #    yield
+  #  ensure
+  #    stream.reopen(old_stream)
+  #  end
+
+require 'stringio'
+require 'rubygems'
+require 'facets/more/dictionary'
+
+module Kernel
+
+  # Captures the output (stdout by default) that +block+ tries to generate and returns it as a string.
+  #
+  #   output = capture_output($stderr) { noisy_command }
+  #
+  #   output = capture_output([$stdout, $stderr]) do
+  #     noisy_command
+  #   end
+  #
+  # *Note*: If you specify more than one output stream, the entire results of each will be concatenated <i>in the order you listed them</i>, not necessarily in the order that you wrote _to_ those streams.
+  def capture_output(output_streams = $stdout, &block)
+    output_streams = [output_streams] unless output_streams.is_a? Array
+    
+    saved_output_streams = Dictionary.new
+    output_streams.each do |output_stream|
+      case output_stream.object_id
+        when $stdout.object_id
+          saved_output_streams[:$stdout] = $stdout
+          $stdout = StringIO.new
+        when $stderr.object_id
+          saved_output_streams[:$stderr] = $stderr
+          $stderr = StringIO.new
+      end
+    end
+
+    what_they_tried_to_output = '' 
+    begin
+      yield
+    rescue Exception
+      raise
+    ensure
+      saved_output_streams.each do |name, output_stream|
+        case name
+          when :$stdout
+            what_they_tried_to_output += $stdout.string
+          when :$stderr
+            what_they_tried_to_output += $stderr.string
+        end
+
+        # Restore the original output_stream that we saved.
+        case name
+          when :$stdout
+            $stdout = saved_output_streams[:$stdout]
+          when :$stderr
+            $stderr = saved_output_streams[:$stderr]
+        end
+      end
+    end
+    return what_they_tried_to_output
+  end
+
+end
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+
+def noisy_command
+  puts "Some lovely message"
+  $stderr.puts "Some lovely error message"
+end
+def noisy_command_with_error
+  puts "Some lovely message"
+  $stderr.puts "Some lovely error message"
+  raise 'an error'
+end
+
+class TheTest < Test::Unit::TestCase
+  def test_capture_all
+    assert_equal "Some lovely message\nSome lovely error message\n", capture_output([$stdout, $stderr]) { noisy_command }
+  end
+  def test_capture_all__different_order
+    # This is, I suppose a limitation of StingIO. This behavior may change in a future version if a workaround is found. (Creating a new IO subclass, +TimestampedStringIO+, that keeps a timestamp for every thing you add to it so that the results of two such objects can be merged to yield chronological output.)
+    assert_equal "Some lovely error message\nSome lovely message\n", capture_output([$stderr, $stdout]) { noisy_command }
+  end
+  def test_capture_stdout
+    assert_equal "Some lovely message\n", capture_output($stdout) { noisy_command }
+  end
+  def test_capture_stderr
+    assert_equal "Some lovely error message\n", capture_output($stderr) { noisy_command }
+  end
+  def test_when_an_error_is_raised_from_block
+    assert_raise(RuntimeError) { capture_output() { noisy_command_with_error } }
+  end
+end
+=end

data/lib/qualitysmith_extensions/kernel/die.rb

@@ -0,0 +1,34 @@
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes
+
+module Kernel
+  def die(message)
+    $stderr.puts message
+    exit 1
+  end
+end
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'qualitysmith_extensions/kernel/capture_output'
+
+class TheTest < Test::Unit::TestCase
+
+  def test_1
+    stderr = capture_output $stderr do
+      assert_raise(SystemExit) do
+        die "Aggh! I'm dying!"
+      end
+    end
+    assert_equal "Aggh! I'm dying!", stderr.chomp
+  end
+
+end
+=end

data/lib/qualitysmith_extensions/kernel/require_all.rb

@@ -0,0 +1,118 @@
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes
+
+require 'rubygems'
+require 'facets/more/filelist'
+
+require 'facets/core/kernel/require_local'
+require_local '../file/exact_match_regexp'
+
+module Kernel
+
+  # Recursively <tt>require</tt>s all Ruby files in <tt>base_dir</tt> or any of its subdirectories.
+  # <tt>:exclude</tt>:       An array of regular expressions or glob patterns that will be passed to FileList#exclude. If you specify this option, a file will not be included if it matches *any* of these patterns.
+  # <tt>:exclude_files</tt>: An array of filenames to exclude. These will be matched exactly, so if you tell it to exclude 'bar.rb', 'foobar.rb' will _not_ be excluded.
+  #
+  # Note:
+  #
+  # Examples:
+  #   require_all 'lib/', :exclude => [/ignore/, /bogus/]   # will require 'lib/a.rb', 'lib/long/path/b.rb', but not 'lib/ignore/c.rb'
+  #   require_all File.dirname(__FILE__), :exclude_files => ['blow_up_stuff.rb']
+  def require_all(base_dir, options = {})
+    base_dir += '/' unless base_dir[-1].chr == '/'
+    exclusions = nil
+    files = FileList[base_dir + "**/*.rb"]
+    files = files.exclude(*exclusions)                                       if (exclusions = options.delete(:exclude))
+    files = files.exclude(*exclusions.map {|a| File.exact_match_regexp(a) }) if (exclusions = options.delete(:exclude_files))
+
+    files.each do |filename|
+      # puts "requiring #{filename}" if filename =~ /test/
+      require filename
+    end
+  end
+
+end
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'tmpdir'
+require 'fileutils'
+
+class TheTest < Test::Unit::TestCase
+  def setup
+    @main_subdir = 'require_all_test'
+    @base_dir = "#{Dir.tmpdir}/#{@main_subdir}"
+    FileUtils.mkdir              @base_dir
+    FileUtils.mkdir_p @deep_dir = @base_dir + "/really/really/deep/subdir"
+    $loaded = Array.new(2)
+  end
+  def teardown
+    FileUtils.rm_rf @base_dir
+  end
+
+
+  def test_repeat_requires
+    $loaded[0] = 0
+    File.open("#{@base_dir}/moo.rb", "w") {|f| f.puts "$loaded[0] += 1"}
+    require_all File.dirname(@base_dir)
+    assert_equal [1, nil], $loaded
+
+    require "#{@base_dir}/moo.rb"
+    assert_equal [1, nil], $loaded
+
+    # Good! It refuses to load it again, even if we drop the ".rb" part!
+    require "#{@base_dir}/moo"
+    assert_equal [1, nil], $loaded
+
+    # But, we can still trick it!
+    $LOAD_PATH << @base_dir
+    require "moo"
+    assert_equal [2, nil], $loaded
+
+    load "moo.rb"
+    assert_equal [3, nil], $loaded
+  end
+
+  def test_deep_subdir
+    File.open("#{@base_dir}/flip.rb", "w") {|f| f.puts "$loaded[0] = true"}
+    File.open("#{@deep_dir}/flop.rb", "w") {|f| f.puts "$loaded[1] = true"}
+
+    require_all File.dirname(@base_dir)
+    assert_equal [true, true], $loaded
+  end
+
+  def test_exclude_pattern
+    File.open("#{@base_dir}/require_me.rb", "w")       {|f| f.puts "$loaded[0] = true"}
+    File.open("#{@base_dir}/please_ignore_me.rb", "w") {|f| f.puts "$loaded[1] = true"}
+
+    require_all File.dirname(@base_dir), :exclude => [/ignore/]
+    assert_equal [true, nil], $loaded
+  end
+
+  def test_exclude_filename
+    File.open("#{@base_dir}/yes.rb", "w") {|f| f.puts "$loaded[0] = true"}
+    File.open("#{@base_dir}/all.rb", "w") {|f| f.puts "$loaded[1] = true"}
+
+    # :todo: Interesting how none of these patterns work. I would have expected them to. Is there a bug in FileList? Find out...
+    #   /usr/lib/ruby/gems/1.8/gems/facets-1.8.51/lib/facets/more/filelist.rb
+    #require_all File.dirname(@base_dir), :exclude => ['all.rb']
+    #require_all File.dirname(@base_dir), :exclude => ['**/all']
+    #require_all File.dirname(@base_dir), :exclude => [/^all\.rb$/]
+    # This works, but it's too much to expect users to type out!:
+    #require_all File.dirname(@base_dir), :exclude => [/(\/|^)all\.rb$/]
+    
+    # So...... I added an :exclude_files option so that people wouldn't have to!
+    require_all File.dirname(@base_dir), :exclude_files => ['all.rb']
+
+    assert_equal [true, nil], $loaded
+  end
+
+end
+=end

data/lib/qualitysmith_extensions/kernel/require_once.rb

@@ -0,0 +1,16 @@
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: No, not yet
+
+require 'rubygems'
+
+module Kernel
+  # Fixes bug in Ruby (1.8, at least -- not sure if 2.0 fixes it) where a file can be required twice if the path is spelled differently.
+  def require_once(name)
+    raise NotImplementedError
+    # store expand_path(name) in an array ($required_files or something)
+    # only do the require if it wasn't already in the array
+  end
+end
+

data/lib/qualitysmith_extensions/month.rb

@@ -0,0 +1,62 @@
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Not sure. Who really cares about Months anyway?
+
+require "rubygems"
+require "active_support"
+require File.dirname(__FILE__) + "/date/all"
+
+class Month
+  include Comparable
+  attr_reader :year, :month
+
+  def initialize(year, month)
+    @year = year
+    @month = month
+  end
+
+  def succ
+    (to_date >> 1).to_month
+  end
+
+  def to_date
+    Date.new(year, month)
+  end
+
+  def <=>(other)
+    #puts "#{self.inspect} <=> #{other.inspect}"
+    return self.to_date <=> other.to_date
+  end
+
+  def inspect
+    "#{@year}-#{@month}"
+  end
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+class TheTest < Test::Unit::TestCase
+  def test_months_range
+    range = Month.new(2006, 6)..Month.new(2006, 9)
+    assert_equal Range.new(Month.new(2006, 6), Month.new(2006, 9)), range
+
+    range = Date.new(2006, 6, 1).to_month..Date.new(2006, 9, 3).to_month
+    assert_equal Range.new(Month.new(2006, 6), Month.new(2006, 9)), range
+
+    assert_equal [
+        Month.new(2006, 6), 
+        Month.new(2006, 7), 
+        Month.new(2006, 8), 
+        Month.new(2006, 9)
+      ], 
+      range.to_a
+  end
+end
+=end

data/lib/qualitysmith_extensions/object/singleton.rb

@@ -0,0 +1,95 @@
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes
+# 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 +extend+s +self+ with the methods from +moduule+ and then sends the supplied +message+ and +args+ (if any).
+  #
+  # Advantages:
+  # * Keeps things object-oriented. Better than having global/class methods.
+  # ** (<tt>"whatever".single_send(MyColorizer, :colorize).single_send(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(self, :some_method) if some_method is defined in self.
+  # ** So what do we call the module containing the "singleton method"? String::MyColorizer? MyColorizer::String? MyStringColorizer?
+  #
+  # Examples:
+  # "whatever".singleton(MyColorizer, :colorize, :blue)
+  #
+  def singleton(moduule, message, *args)
+    self.extend(moduule)
+    self.send(message, *args)
+  end
+
+  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'
+
+module MyColorizer
+  def colorize(color = nil)
+    self + " (colorized in #{color})"
+  end
+end
+
+class TheTest < Test::Unit::TestCase
+  def test_1
+    assert_equal "whatever (colorized in )", "whatever".singleton(MyColorizer, :colorize)
+    assert_equal "whatever (colorized in blue)", "whatever".singleton(MyColorizer, :colorize, :blue)
+  end
+
+#  def test_2
+#    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/simulate_input.rb

@@ -0,0 +1,51 @@
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes
+# Developer notes:
+# * Move to kernel/?
+
+require 'stringio'
+require 'rubygems'
+
+# Simulates a user typing in +input_string+ on the keyboard.
+#
+# Useful for testing console apps that are ordinarily (they prompt the user for input).
+#
+#   output = simulate_inpute('foo') do
+#     input = $stdin.gets
+#     capture_output { do_stuff() }
+#   end
+#
+def simulate_input(input_string, &block)
+
+  original_stdin = $stdin
+  $stdin = StringIO.new(input_string, 'r')
+
+  begin
+    yield
+  rescue Exception
+    raise
+  ensure
+    $stdin = original_stdin
+  end
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+
+class TheTest < Test::Unit::TestCase
+  def test_1
+    input_received = nil
+    simulate_input('foo') { input_received = $stdin.getc.chr }
+    assert_equal 'f', input_received
+  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'