quality_extensions 0.1.1

data/lib/qualitysmith_extensions/exception/inspect_with_backtrace.rb

@@ -0,0 +1,65 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes
+# Developer notes::
+# * Add depth argument to inspect()? 
+#++
+
+require 'rubygems'
+require 'facets/core/module/alias_method_chain'
+
+class Exception
+  # Use this if you want to output an exception with all the details that you'd *normally* see if the exception went unrescued
+  # (since exception.inspect/p exception doesn't provide a backtrace!) 
+  #
+  # This is mostly useful if you rescue an exception, want to print or log it and then re-raise it...
+  #
+  # Use inspect_without_backtrace if you want to access the previous behavior (<tt>#<MissingSourceFile: no such file to load -- whatever></tt>).
+  #
+  def inspect_with_backtrace
+    exception.class.name + ": " + exception.message + "\n" +
+      exception.backtrace.map {|v| '  ' + v}.join( "\n" )
+  end
+  alias_method_chain :inspect, :backtrace
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'rubygems'
+require 'facets/core/string/lines'
+
+class TheTest < Test::Unit::TestCase
+  def raise_an_error(arg = nil)
+    raise ArgumentError, "You passed in the wrong argument!" 
+  end
+  def test_1
+    begin
+      raise_an_error
+    rescue ArgumentError => exception
+      #puts exception.inspect
+      assert_equal 'ArgumentError: You passed in the wrong argument!', exception.inspect.lines[0]
+      assert_match /[^:]+:\d+:in `raise_an_error'/, exception.inspect.lines[1]
+      assert exception.inspect.lines.size > 3
+    end
+  end
+
+end
+=end
+
+
+=begin
+Sightings of other exception -> string formatters
+
+log4r/formatter/formatter.rb
+        return "Caught #{obj.class}: #{obj.message}\n\t" +\
+               obj.backtrace[0...@depth].join("\n\t")
+
+=end

data/lib/qualitysmith_extensions/file/exact_match_regexp.rb

@@ -0,0 +1,34 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes
+#++
+
+# To do:
+# * Is there a more object-oriented way to do this? Instance method instead of class method?
+
+class File
+  def self.exact_match_regexp(filename)
+    /(^|\/)#{Regexp.escape(filename)}$/
+  end
+end
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+class TheTest < Test::Unit::TestCase
+  def test_1
+    assert 'bar.rb'          =~ File.exact_match_regexp('bar.rb')
+    assert '/path/to/bar.rb' =~ File.exact_match_regexp('bar.rb')
+    # But:
+    assert 'foobar.rb'       !~ File.exact_match_regexp('bar.rb')
+  end
+end
+=end
+

data/lib/qualitysmith_extensions/file_test/binary_file.rb

@@ -0,0 +1,110 @@
+#--
+# Author::    Lloyd Zusman, Tyler Rick
+# Copyright:: Copyright (c) 2002-2007 Lloyd Zusman
+# License::   Ruby License
+# History::
+# * 2002-10-05: Based on code posted by Lloyd Zusman on ruby-talk on 2002-10-05 (http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/52548) 
+# * 2007-03-15: Cleaned up a bit and wrote tests.
+# Submit to Facets?:: Yes
+#++
+
+module FileTest
+
+private
+  def self.is_text?(block)
+    return (block.count("^ -~", "^\b\f\t\r\n") < (block.size / 3.0) &&
+            block.count("\x00") < 1)
+  end
+
+public
+  # The text_file? and binary_file? methods are not inverses of each other. Both return false if the item is not a file, or if it
+  # is a zero-length file. The "textness" or "binariness" of a file can only be determined if it's a file that contains at least
+  # one byte.
+
+  def self._binary_file?(filename)
+    size = self.size(filename)
+    blksize = File.stat(filename).blksize
+    return nil if !File.file?(filename) || size < 1
+    size = [size, blksize].min
+    begin
+      open(filename) {
+        |file|
+        block = file.read(size)
+        return !self.is_text?(block)
+      }
+    end
+  end
+
+  def self.binary_file?(filename)
+    self._binary_file?(filename)   
+  end
+
+  def self.text_file?(filename)
+    return_value = self._binary_file?(filename)   
+    if return_value.nil?
+      return_value 
+    else
+      !return_value 
+    end
+  end
+end
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+require 'fileutils'
+
+class TheTest < Test::Unit::TestCase
+  def empty_file
+    File.open(filename = 'test_file', 'w') do |file|
+    end
+    yield filename
+  ensure
+    FileUtils.rm filename
+  end
+
+  def binary_file
+    File.open(filename = 'test_file', 'wb') do |file|
+      bin_data = [0].pack('c')*(1024)
+      file.write(bin_data)
+    end
+    yield filename
+  ensure
+    FileUtils.rm filename
+  end
+
+  def text_file
+    File.open(filename = 'test_file', 'w') do |file|
+      file.puts('Guten Tag!')
+    end
+    yield filename
+  ensure
+    FileUtils.rm filename
+  end
+
+  def test_empty
+    empty_file do |filename|
+      assert !FileTest.binary_file?(filename)
+      assert !FileTest.text_file?(filename)
+    end
+  end
+  def test_binary
+    binary_file do |filename|
+      assert FileTest.binary_file?(filename)
+      assert !FileTest.text_file?(filename)
+    end
+  end
+  def test_text
+    text_file do |filename|
+      assert !FileTest.binary_file?(filename)
+      assert FileTest.text_file?(filename)
+    end
+  end
+end
+=end
+

data/lib/qualitysmith_extensions/find/select.rb

@@ -0,0 +1,68 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?::
+# Developer notes::
+# Changes::
+#++
+
+
+require 'find'
+require 'enumerator'
+
+module Find
+  # Identical to +find+ except +select+ returns the matching files as an _array_. (+find+ returns nil, which is not very useful if you actually wanted an array.)
+  #
+  # Calls the associated block with the name of every file and directory listed as arguments, then recursively on their subdirectories, and so on.
+  #
+  # Return a true (non-false) value from the block for every path that you want to be returned in the resulting array.
+  #
+  # You can still use <tt>Find.prune</tt>.
+  #
+  def self.select(*paths, &block)
+    Enumerable::Enumerator.new(self, :find, *paths).select{|value| yield value}
+  end
+end
+
+
+
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+
+class TheTest < Test::Unit::TestCase
+  # to do: would probably be safer if we *created* our own files/directories during setup, rather than expecting there to be some for us to use in cwd
+  
+  def test_true
+    dir = '.'
+    files_expected = []
+    Find.find(dir) { |path| files_expected << path }
+
+    files = Find.select(dir) { |path| true }
+    assert_equal files_expected, files
+
+    # Doesn't have to be true necessarily -- can be a string
+    files = Find.select(dir) { |path| path }
+    assert_equal files_expected, files
+  end
+
+  def test_false
+    dir = '.'
+    files = Find.select(dir) { |path| false }
+
+    assert_equal [], files
+  end
+
+end
+=end
+
+

data/lib/qualitysmith_extensions/global_variable_set.rb

@@ -0,0 +1,153 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: No, too ugly and unreliable.
+#++
+
+module Kernel
+  # Gets the global variable +var+, which can either be a symbol or an actual global variable (use +:match_object+).
+  #  global_variable_get(:$a)
+  #  global_variable_get($a, :match_object => true)
+  def global_variable_get(var, options = {})
+    if options.delete(:match_object)
+      return global_variable_get(global_variable_name(var), options)
+    else 
+      if var.is_a? Symbol
+        raise NameError.new("#{var} is not a valid global variable name") unless var.to_s[0..0] == '$'
+        return eval("#{var}")
+      else
+        raise ArgumentError.new("var must be a symbol unless :match_object => true")
+      end
+    end
+  end
+
+  # Looks up the name of global variable +var+, which must be an actual global variable.
+  #   global_variable_name($a)
+  def global_variable_name(var)
+    global_variables.each do |test_var|
+      #if eval(test_var).eql?(var)
+      if eval(test_var).object_id == var.object_id
+        #$stderr.puts "Checking #{test_var}. #{eval(test_var).inspect}" 
+        #$stderr.puts "          #{$stdout.inspect}"
+        return test_var.to_sym
+      end
+    end
+    raise ArgumentError.new("The given object (#{var.inspect}) (#{var.object_id}) is not a valid global variable")
+  end
+
+  # Sets the global variable +var+, which can either be a symbol or an actual global variable (use +:match_object+).
+  #  global_variable_set(:$a, 'new')
+  #  global_variable_set($a, 'new', :match_object => true)
+  #  global_variable_set(:$a, "StringIO.new", :eval_string => true)
+  def global_variable_set(var, value, options = {})
+    #puts "global_variable_set(#{var}, #{value.inspect}, #{options.inspect}"
+    if options.delete(:match_object)
+      return global_variable_set(global_variable_name(var), value, options)
+    else 
+      if var.is_a? Symbol
+        raise NameError.new("#{var} is not a valid global variable name") unless var.to_s[0..0] == '$'
+        if options.delete(:eval_string)
+          #puts("About to eval: #{var} = #{value}")
+          eval("#{var} = #{value}")
+        else
+          marshalled_data = Marshal.dump(value)
+          eval("#{var} = Marshal.load(%Q<#{marshalled_data}>)")
+        end
+        return var
+      else
+        raise ArgumentError.new("var must be a symbol unless :match_object => true")
+      end
+    end
+  end
+end
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+require 'stringio'
+
+class MyClass
+  attr_reader :data
+  @data = [:foo]
+  def ==(other)
+    self.data == other.data
+  end
+end
+
+class GlobalVariableGetTest < Test::Unit::TestCase
+  def test_simple
+    $a = 'old'
+    assert_equal 'old', global_variable_get(:$a)
+    assert_equal :$a, global_variable_name($a)
+  end
+
+  def test_can_pass_variable_instead_of_symbol
+    $a = 'old'
+    assert_equal 'old', global_variable_get($a, :match_object => true)
+
+    $a = :already_a_symbol
+    assert_raise(NameError) { global_variable_get($a) }   # If the global ($a) contains a symbol, it will assume we want to get the global variable *named* :$already_a_symbol . Wrong! That's why the :match_object option was introduced.
+    assert_nothing_raised   { global_variable_get($a, :match_object => true) }
+    assert_equal :already_a_symbol, global_variable_get($a, :match_object => true)
+    assert_equal :$a, global_variable_name($a)
+  end
+
+  def test_error
+    assert_raise(NameError) { global_variable_get(:a) }  # Must be :$a, not :a
+  end
+end
+
+class GlobalVariableSetTest < Test::Unit::TestCase
+  def test_simple
+    $a = 'old'
+    global_variable_set(:$a, 'new')
+    assert_equal('new', $a)
+  end
+
+  def test_can_pass_variable_instead_of_symbol
+    $a = 'old'
+    global_variable_set($a, 'new', :match_object => true)
+    assert_equal('new', $a)
+
+    $a = :already_a_symbol
+    assert_raise(NameError) { global_variable_set($a, expected = :a_symbol) }   # If the global ($a) contains a symbol, it will assume we want to set the global variable *named* :$already_a_symbol . Wrong! That's why the :match_object option was introduced.
+    assert_nothing_raised   { global_variable_set($a, expected = :a_symbol, :match_object => true) }
+    global_variable_set(:$a, expected = :a_symbol)
+    assert_equal(expected, $a)
+  end
+
+  def test_returns_name_of_variable
+    $a = 'old'
+    assert_equal(:$a, global_variable_set(:$a, 'new'))
+
+    $a = 'old'
+    assert_equal(:$a,  global_variable_set($a, 'new', :match_object => true))
+  end
+
+  def test_works_for_complex_data_types
+    $a = 'old'
+    global_variable_set(:$a, expected = {:a => 'a', :b => ['1', 2]})
+    assert_equal(expected, $a)
+
+    global_variable_set(:$a, expected = MyClass.new)
+    assert !expected.eql?( $a )  # :bug: The way we do it currently, they'll have different object_id's
+    assert_equal(expected, $a)
+
+    assert_raise(TypeError) { global_variable_set(:$a, expected = $stdout) } # "can't dump IO". 
+    assert_raise(TypeError) { global_variable_set(:$a, expected = StringIO.new) } # "no marshal_dump is defined for class StringIO". That's why the :eval_string option was introduced.
+    assert_nothing_raised   { global_variable_set(:$a, expected = "StringIO.new", :eval_string => true) }
+    assert $a.is_a?(StringIO)
+  end
+
+  def test_error
+    assert_raise(NameError) { global_variable_set(:a, 'new') }  # Must be :$a, not :a
+  end
+end
+=end
+

data/lib/qualitysmith_extensions/hash/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/hash/to_date.rb

@@ -0,0 +1,34 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes. Unless it is deemed not generally reusable enough. Also, only if we can get a Date.new(y,m,d) added to Facets.
+#++
+
+require "rubygems"
+require "active_support"
+
+class Hash
+  # Converts a <tt>{:year => ..., :month => ..., :day => ...}</tt> hash into an actual Date object.
+  # Useful for when you have a date element in your <tt>params</tt> hash.
+  def to_date
+    Date.new(fetch(:year).to_i, fetch(:month).to_i, fetch(:day).to_i)
+  end
+end
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+class TheTest < Test::Unit::TestCase
+  def test_Hash_to_date
+    assert_equal Date.new(2007, 1, 22), {:year => "2007", :month => "01", :day => 22}.to_date
+  end
+  def test_HashWithIndifferentAccess_to_date
+    assert_equal Date.new(2007, 1, 22), HashWithIndifferentAccess.new({:year => "2007", 'month' => 01, :day => 22}).to_date
+  end
+end
+=end