quality_extensions 0.1.1

data/lib/qualitysmith_extensions/hash/to_query_string.rb

@@ -0,0 +1,121 @@
+#--
+# 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/autoreload.rb

@@ -0,0 +1,128 @@
+# CREDIT Michael Neumann
+# CREDIT George Moschovitis
+
+module Kernel
+
+  # Autoreload feature files.
+  #
+  # Automatically reload, at regular intervals, any previously loaded features,
+  # and/or other files not already loaded, if they have been modified since the last
+  # interval check. A numeric parameter sets the reload interval in seconds
+  # and the file parameter can either be a glob string or an array
+  # of file paths. If a glob string, it is expanded only once on the initial
+  # method call. Supplying a boolean parameter of 'false' will force autreload to
+  # skip previously loaded features and only reload the specified files.
+  # Also keeps a "dirty" flag.
+
+  def autoreload( *args )
+
+    check_interval=10
+    include_features = true
+    files = nil
+
+    args.each do |arg|
+      case arg
+      when Numeric
+        check_interval = arg
+      when String
+        files = Dir.glob( arg )
+      when Array
+        files = arg
+      when TrueClass, FalseClass
+        include_features = arg
+      end
+    end
+
+    file_mtime = {}
+
+    Thread.new(Time.now) do |start_time|
+      loop do
+        sleep check_interval
+
+        if include_features
+          feature_files = $LOADED_FEATURES.collect { |feature|
+            $LOAD_PATH.each { |lp| file = File.join(lp, feature) }
+          }.flatten
+          p feature_files
+
+          feature_files.each { |file|
+            if File.exists?(file) and (mtime = File.stat(file).mtime) > (file_mtime[file] || start_time)
+              $autoreload_dirty = true
+              file_mtime[file] = mtime
+              STDERR.puts "File '#{ file }' reloaded"
+              begin
+                load(file)
+              rescue Exception => e
+                STDERR.puts e.inspect
+              end
+            end
+          }
+        end
+
+        if files
+          files.each do |file|
+            if File.exists?(file) and (mtime = File.stat(file).mtime) > (file_mtime[file] || start_time)
+              $autoreload_dirty = true
+              file_mtime[file] = mtime
+              STDERR.puts "File '#{ file }' changed"
+              begin
+                load(file)
+              rescue Exception => e
+                STDERR.puts e.inspect
+              end
+            end
+          end
+        end
+
+      end
+    end
+
+  end
+
+
+  # Same as #autoreload, but does not include previously loaded features.
+  # This is equivalent to as adding a 'false' parameter to #autoreload.
+
+  def autoreload_files( *args )
+    autoreload( false, *args )
+  end
+
+  # deprecate
+  alias_method :autoreload_glob, :autoreload_files
+
+end
+
+#--
+#   # OLD VERSION
+#   def autoreload(check_interval=10)
+#     Thread.new(Time.now) { |start_time|
+#       file_mtime = {}
+#       loop {
+#         sleep check_interval
+#         $LOADED_FEATURES.each { |feature|
+#           $LOAD_PATH.each { |lp|
+#             file = File.join(lp, feature)
+#             if (File.exists?(file) and
+#               File.stat(file).mtime > (file_mtime[file] || start_time))
+#               file_mtime[file] = File.stat(file).mtime
+#               STDERR.puts "reload #{ file }"
+#               begin
+#                 load(file)
+#               rescue Exception => e
+#                 STDERR.puts e.inspect
+#               end
+#             end
+#           }
+#         }
+#       }
+#     }
+#   end
+#++
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+# TODO

data/lib/qualitysmith_extensions/kernel/backtrace.rb

@@ -0,0 +1,71 @@
+#--
+# 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,115 @@
+#--
+# 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,49 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: No.
+# Deprecated. Because I discovered Kernel::abort !
+#++
+
+module Kernel
+  def die(message, exit_code = 1)
+    $stderr.puts message
+    exit exit_code
+  end
+end
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'rubygems'
+require 'qualitysmith_extensions/kernel/capture_output'
+#require 'facets/core/kernel/require_local'
+#require_local './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
+
+  def test_abort
+    stderr = capture_output $stderr do
+      assert_raise(SystemExit) do
+        abort "Aggh! I'm dying!"
+      end
+    end
+    assert_equal "Aggh! I'm dying!", stderr.chomp
+  end
+
+end
+=end