quality_extensions 0.1.1

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,40 @@
+#--
+# 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,31 @@
+#--
+# 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,122 @@
+#--
+# 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/dir/each_child.rb

@@ -0,0 +1,58 @@
+#--
+# Author::    Nolan Cafferky
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes.
+#++
+
+
+class Dir
+  # Much like each(), except the "." and ".." special files
+  # are ignored.
+  def each_child
+    each do |file|
+      yield file if file != "." and file != ".."
+    end
+  end
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+require 'fileutils'
+
+class TheTest < Test::Unit::TestCase
+  def setup
+    @base_path = "dir_extensions_test_test_each_child"
+    make_test_files @base_path
+  end
+  def teardown
+    FileUtils.remove_entry_secure @base_path
+  end
+
+  def test_each_child
+    Dir.open(@base_path) do |d|
+      results = []
+      d.each_child { |file| results << file }
+      assert_equal 3, results.size
+      assert results.include?("foo")
+      assert results.include?("bar")
+      assert results.include?("foobar")
+    end
+  end
+
+  def make_test_files base_path
+    Dir.mkdir(      base_path)
+    FileUtils.touch(base_path + "/foo")
+    FileUtils.touch(base_path + "/bar")
+    Dir.mkdir(      base_path + "/foobar")
+    FileUtils.touch(base_path + "/foobar/baz")
+  end
+end
+=end

data/lib/qualitysmith_extensions/enumerable/enum.rb

@@ -0,0 +1,69 @@
+#--
+# 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;
+  # * <tt>enum_cons()</tt>
+  # * <tt>enum_slice()</tt>
+  # * <tt>enum_with_index()</tt>
+  # but for some reason they didn't provide a generic <tt>enum()</tt> method for the cases they didn't think of!
+  #
+  # +enum+ lets you turn *any* iterator into a general-purpose <tt>Enumerator</tt>, which, according to the RDocs, is 
+  # "A class which provides a method `<tt>each</tt>' to be used as an <tt>Enumerable</tt> object."
+  #
+  # This lets you turn any '<tt>each'-type</tt> iterator (<tt>each_byte</tt>, <tt>each_line</tt>, ...) into a
+  # '<tt>map</tt>'-type iterator (one that returns a collection), or into an array, etc.
+  #
+  # So if an object responds to <tt>:each_line</tt> but not to <tt>:map_lines</tt> or <tt>:lines</tt>, you could just do:
+  #   object.enum(:each_line).map { block }
+  #   object.enum(:each_line).min
+  #   object.enum(:each_line).grep /pattern/
+  #   lines = object.enum(:each_line).to_a
+  #
+  # If no iterator is specified, <tt>:each</tt> 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
+
+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/enumerable/select_until.rb

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

data/lib/qualitysmith_extensions/enumerable/select_while.rb

@@ -0,0 +1,109 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes.
+# Developer notes::
+# Changes::
+#++
+
+
+module Enumerable
+  # Returns an array containing all _consecutive_ elements of +enum+ for which +block+ is not false, starting at the first element.
+  # So it is very much like select, only it stops searching as soon as <tt>block</tt> ceases to be true. (That means it will stop searching immediately if the first element doesn't match.)
+  #
+  # This might be preferable to +select+, for example, if:
+  # * you have a very large collection of elements
+  # * the desired elements are expected to all be consecutively occuring and are all at the beginning of the collection
+  # * it would be costly to continue iterating all the way to the very end
+  #
+  # This is probably only useful for collections that have some kind of predictable ordering (such as Arrays).
+  #
+  # AKA: select_top_elements_that_match
+  #
+  def select_until(inclusive = false, &block)
+    selected = []
+    inclusive ? (
+      each do |item|
+        selected << item
+        break if block.call(item)
+      end
+    ) : (
+      each do |item|
+        break if block.call(item)
+        selected << item
+      end
+    )
+    selected
+  end
+
+  def select_while(&block)
+    selected = []
+    each do |item|
+      break if !block.call(item)
+      selected << item
+    end
+    selected
+  end
+end
+
+
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+
+class TheTest < Test::Unit::TestCase
+  def test_1
+    assert_equal [1, 2], (1..4).select_while {|i| i <= 2}
+    assert_equal [1, 2], (1..4).select_until {|i| i == 3}
+  end
+
+  def test_not_same_as_select
+    # Ah, yes, it behaves the same as select in *this* simple case:
+    assert_equal [1, 2], (1..4).select {|i| i <= 2}
+
+    # But what about _this_ one... hmm?
+    assert_equal [1, 2],       [1, 2, 3, 2, 1].select_while {|i| i <= 2}
+    assert_equal [1, 2, 2, 1], [1, 2, 3, 2, 1].select {|i| i <= 2}          # Not the same! Keyword: _consecutive_.
+
+    # Or _this_ one...
+    assert_equal [1, 2, 1],  [1, 2, 1, 99, 2].select_while {|i| i <= 2}
+    assert_equal [1, 2],     [1, 2, 1, 99, 2].select {|i| i <= 2}.uniq    # Even this isn't the same.
+  end
+
+  def test_inclusive_option
+    assert_equal [
+      'def cabbage',
+      '  :cabbage',
+    ], [
+      'def cabbage',
+      '  :cabbage',
+      'end',
+    ].select_until {|line| line =~ /end/}
+    # Not far enough. We actually want to *include* that last element.
+
+    assert_equal [
+      'def cabbage',
+      '  :cabbage',
+      'end',
+    ], [
+      'def cabbage',
+      '  :cabbage',
+      'end',
+      'def carrot',
+      '  :carrot',
+      'end',
+    ].select_until(true) {|line| line =~ /end/}
+  end
+end
+=end
+
+