qualitysmith_extensions 0.0.3

data/lib/qualitysmith_extensions/date/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/date/deprecated.rb

@@ -0,0 +1,38 @@
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: No!
+
+# Depends on some niceties from ActiveSupport (which really should be in core Ruby but aren't)...
+require "rubygems"
+require "active_support"
+require "pp"
+
+class Date
+  # These should be moved elsewhere because they are subjective and depend on the context where they're used.
+  def date_for_report
+    strftime("%b %d, %Y")   # Example: "Jun 18, 2006"
+  end
+  def month_for_report
+    strftime("%B %Y")   # Example: "June 2006"
+  end
+end
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+class TheTest < Test::Unit::TestCase
+  def test_date_for_report
+    assert_equal 'Jun 18, 2006', Date.new(2006, 6, 18).date_for_report()
+    assert_equal 'Jun 03, 2006', Date.new(2006, 6,  3).date_for_report()
+  end
+
+  def test_month_for_report
+    assert_equal 'June 2006', Date.new(2006, 6).month_for_report()
+  end
+end
+=end

data/lib/qualitysmith_extensions/date/iso8601.rb

@@ -0,0 +1,29 @@
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes.
+
+require 'date'
+require 'rubygems'
+require 'facets/core/date/to_time'
+
+class Date
+  def iso8601
+    # Useful for SQL dates, among other things
+    to_time().iso8601()[0..9]
+  end
+end
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+class TheTest < Test::Unit::TestCase
+  def test_iso8601
+    assert_equal '2006-07-18', Date.civil(2006, 7, 18).iso8601()
+  end
+end
+=end

data/lib/qualitysmith_extensions/date/month_ranges.rb

@@ -0,0 +1,120 @@
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Not sure.
+
+# Depends on some niceties from ActiveSupport (which really should be in core Ruby but aren't)... Date.new(a, b, c)
+require "rubygems"
+require "active_support"
+
+# Attempts in part to make the Date class do everything (or at least some of the things) that the Time class can do (ActiveSupport::CoreExtensions::Time::Calculations).
+# Maybe that would be better accomplished with a method_missing() that calls to_time.send(:the_same_method) if Time.respond_to?(:that_method).
+class Date
+
+  # This is based on the implementation of Time.step. The main difference is that it uses 
+  # >>= (increment by 1 month) instead of += (increment by 1 day).
+  def month_step(max, step, &block)  # { |date| ...}
+    time = self
+    op = [:-,:<=,:>=][step<=>0]
+    while time.__send__(op, max)
+      block.call time
+      time >>= step
+    end
+    self
+  end
+
+  # Step forward one month at a time until we reach max (inclusive), yielding each date as we go
+  def months_upto(max, &block)  # { |date| ...}
+    month_step(max, +1, &block)
+  end
+
+  def to_month
+    Month.new(year, month)
+  end
+
+  def next_month
+    # Uses http://api.rubyonrails.org/classes/ActiveSupport/CoreExtensions/Time/Calculations.html#M000336
+    self.to_time.next_month
+  end
+
+end
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+class TheTest < Test::Unit::TestCase
+
+  #-------------------------------------------------------------------------------------------------
+  # Ranges, step, and upto for *days*
+  # (This is built-in behavior.)
+
+  def test_step
+    list = []
+    collect_as_array = lambda do |date|
+      list << date
+    end
+
+    list = []
+    Date.new(2006, 6, 1).step(Date.new(2006, 6, 3), 1, &collect_as_array)
+    assert_equal [
+        Date.new(2006, 6, 1), 
+        Date.new(2006, 6, 2), 
+        Date.new(2006, 6, 3)
+      ], 
+      list
+  end
+
+  def test_range
+    list = Date.new(2006, 6, 1)..Date.new(2006, 6, 3)
+    assert_equal Range.new(Date.new(2006, 6, 1), Date.new(2006, 6, 3)), list
+  end
+
+  #-------------------------------------------------------------------------------------------------
+  # Ranges, step, and upto for *months*
+  
+  def test_month_step
+    list = []
+    collect_as_array = lambda do |date|
+      list << date
+    end
+
+    list = []
+    Date.new(2006, 6, 1).month_step(Date.new(2006, 7, 1), 1, &collect_as_array)
+    assert_equal [
+        Date.new(2006, 6, 1), 
+        Date.new(2006, 7, 1)
+      ], 
+      list
+
+    # Test that it ignores days
+    list = []
+    Date.new(2006, 6, 1).month_step(Date.new(2006, 8, 31), 1, &collect_as_array)
+    assert_equal [
+        Date.new(2006, 6, 1), 
+        Date.new(2006, 7, 1),
+        Date.new(2006, 8, 1)
+      ], 
+      list
+  end
+
+  def test_months_upto
+    list = []
+    collect_as_array = lambda do |date|
+      list << date
+    end
+
+    list = []
+    Date.new(2006, 6, 1).months_upto(Date.new(2006, 7, 1), &collect_as_array)
+    assert_equal [
+        Date.new(2006, 6, 1), 
+        Date.new(2006, 7, 1)
+      ], 
+      list
+  end
+end
+=end
+

data/lib/qualitysmith_extensions/enumerable/enum.rb

@@ -0,0 +1,72 @@
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes!
+
+require 'enumerator'
+module Enumerable
+
+  # The core Enumerable module provides the following enumerator methods;
+  # * enum_cons()
+  # * enum_slice()
+  # * enum_with_index()
+  # but for some reason they didn't provide a generic enum() method for the cases they didn't think of!
+  #
+  # +enum+ lets you turn *any* iterator into a general-purpose Enumerator, which, according to the RDocs, is 
+  # "A class which provides a method `each' to be used as an Enumerable object."
+  #
+  # This lets you turn any 'each'-type iterator (each_byte, each_line, ...) into a 'map'-type iterator, or into an array, etc.
+  #
+  # So if an object responds to :each_line but not to :map_lines or :lines, you could just do:
+  #   object.enum(:each_line).map { block }
+  #   object.enum(:each_line).to_a
+  #   object.enum(:each_line).min
+  #   object.enum(:each_line).grep /pattern/
+  #
+  # If no iterator is specified, :each is assumed:
+  #   object.enum.map { block }
+  #
+  # More examples:
+  #   Dir.new('.').enum.to_a
+  #   #=> ['file1', 'file2']
+  #
+  #   "abc".enum(:each_byte).map{|byte| byte.chr.upcase}
+  #   #=> ["A", "B", "C"]
+  #   
+  def enum(iterator = :each)
+    Enumerable::Enumerator.new(self, iterator)
+  end
+  # Old version, which I don't think was accurate since enum requires obj to be Enumerable as a prerequisite!:
+  #
+  # Lets you add the methods available to Enumerables to any object that responds to :each (or any other iterator).
+  # +enum+ returns a general-purpose Enumerator, which, according to the RDocs, is "A class which provides a method `each' to be used as an Enumerable object."
+  #
+  # This lets you use 'map'-type iterator, for example, on an object that only provides an 'each'-type iterator.
+  # So if an object only responds to :each, but you want to send it :map, you could just do:
+end
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+
+class TheTest < Test::Unit::TestCase
+  def test_1
+#    @options.enum(:each).map { |key, value|
+#      values = [value].flatten
+#      key +
+#        (values.empty? ? " #{flatten.join(' ')}" : '')
+#    }.join(' ')
+
+    # Yes we could use the built-in Array#map method, but...not every class that provides iterators (each, ...) provides a map().
+    assert_equal ['A', 'B', 'C'], ['a', 'b', 'c'].enum(:each).map {|v| v.upcase}
+  end
+  def test_2
+    assert Dir.new('.').enum.to_a.size > 0
+  end
+end
+=end

data/lib/qualitysmith_extensions/file/exact_match_regexp.rb

@@ -0,0 +1,32 @@
+# 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,108 @@
+# 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/filter_output.rb

@@ -0,0 +1,107 @@
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes.
+# Developer notes:
+# * Move to kernel/?
+
+require 'stringio'
+
+# Applies +filter+ to any $stderr output that +block+ tries to generate.
+#
+# +filter+ should be a Proc that accepts +attempted_output+ as its parameter and returns the string that should _actually_ be output.
+#
+#   filter_stderr(lambda{''}) do
+#     noisy_command
+#   end
+def filter_stderr(filter, &block)
+  old_stderr = $stderr
+  $stderr = StringIO.new
+  begin
+    yield
+  ensure
+    what_they_tried_to_output = $stderr.string
+    $stderr = old_stderr
+    $stderr.print filter.call(what_they_tried_to_output)
+  end
+end
+def filter_stdout(filter, &block)
+  old_stderr = $stdout
+  $stdout = StringIO.new
+  begin
+    yield
+  ensure
+    what_they_tried_to_output = $stdout.string
+    $stdout = old_stderr
+    $stdout.print filter.call(what_they_tried_to_output)
+  end
+end
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+
+# Not sure whether it's better to duplicate for increased readability or metaprogram for decreased duplication...
+
+# Duplicate for increased readability:
+  def noisy_command
+    $stderr.puts "Some annoying error message"
+    $stderr.puts "Some error message that we actually care to see"
+  end
+  class TheTest < Test::Unit::TestCase
+    def setup
+      $stderr = StringIO.new
+    end
+    def test_simple_filter
+      filter_stderr(lambda{|input| ''}) do
+        noisy_command
+      end
+      assert_equal '', $stderr.string
+    end
+    def test_sub_filter
+      filter_stderr(Proc.new { |attempted_output|
+          attempted_output.sub(/^Some annoying error message\n/, '')
+        }
+      ) do
+        noisy_command
+      end
+      assert_equal "Some error message that we actually care to see\n", $stderr.string
+    end
+  end
+
+# Metaprogram for decreased duplication...
+  ['stdout', 'stderr'].each do |stream_name|
+    eval(%Q{
+    def noisy_command_#{stream_name}
+      $#{stream_name}.puts "Some annoying error message"
+      $#{stream_name}.puts "Some error message that we actually care to see"
+    end
+
+    class TheTest#{stream_name} < Test::Unit::TestCase
+      def setup
+        $#{stream_name} = StringIO.new
+      end
+      def test_simple_filter
+        filter_#{stream_name}(lambda{|input| ''}) do
+          noisy_command_#{stream_name}
+        end
+        assert_equal '', $#{stream_name}.string
+      end
+      def test_sub_filter
+        filter_#{stream_name}(Proc.new { |attempted_output|
+            attempted_output.sub(/^Some annoying error message\n/, '')
+          }
+        ) do
+          noisy_command_#{stream_name}
+        end
+        assert_equal "Some error message that we actually care to see\n", $#{stream_name}.string
+      end
+    end
+    })
+  end
+=end

data/lib/qualitysmith_extensions/global_variable_set.rb

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