qualitysmith_extensions 0.0.29 → 0.0.33

data/lib/qualitysmith_extensions/regexp/join.rb

@@ -0,0 +1,111 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes.
+# Developer notes::
+# * Names considered:
+#   * intersection (since there's already a Regexp#union), but unlike Regexp#union, it really doesn't seem like this method lends itself to a name from set theory. Mostly because unlike when dealing with sets (or unioned Regexps), *order matters* here.
+#   * merge, concat, sum, add, combines
+#   * join -- Settled on this because it's a lot like File.join: it combines the given pieces, *in order*, to make a whole.
+#++
+
+
+class Regexp
+  # Returns a Regexp that results from interpolating each of the given +elements+ into an empty regular expression.
+  #   /ab/ == Regexp.join(/a/, /b/)  # except spelled differently
+  # Accepts both strings and Regexp's as +elements+ to join together. Strings that are passed in will be escaped (so characters like '*' will lose all of the Regexp powers that they would otherwise have and are treated as literals).
+  #
+  # Serving suggestion: Use it to check if the +actual+ string in an <tt>assert_match</tt> contains certain literal strings, which may be separated by any number of characters or lines that we don't care about. In other words, use it to see if a string contains the necessary "keywords" or "key phrases"...
+  #   assert_match Regexp.join(
+  #     'keyword1',
+  #     /.*/m,
+  #     'keyword2'
+  #   ), some_method()
+  #   # where some_method() returns "keyword1 blah blah blah keyword2"
+  #
+  def self.join(*elements)
+    elements.inject(//) do |accumulator, element|
+      accumulator + element
+    end
+  end
+
+  # Pads the +elements+ (which may be strings or Regexp's) with /.*/ (match any number of characters) patterns.
+  # Pass :multi_line => true if you want /.*/m as the padding pattern instead.
+  def self.loose_join(*elements)
+    options = (if elements.last.is_a?(Hash) then elements.pop else {} end)
+    multi_line = options[:multi_line] || options[:m]
+    padding = (multi_line ? /.*/m : /.*/)
+    elements.inject(//) do |accumulator, element|
+      accumulator + padding + element
+    end
+  end
+
+  #   /a/ + /b/ == /ab/
+  # Actually, the way it's currently implemented, it is
+  #   /a/ + /b/ == /(?-mix:a)(?-mix:b)/
+  # But they seem to be functionally equivalent despite the different spellings.
+  def +(other)
+    other = Regexp.escape(other) if other.is_a?(String)
+    /#{self}#{other}/
+  end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+
+class TheTest < Test::Unit::TestCase
+  def test_1_simple_letters
+    assert_equal /(?-mix:)(?-mix:b)/,  // + /b/
+    assert_equal /(?-mix:)b/,          // + 'b'
+    assert_equal /(?-mix:a)(?-mix:b)/, /a/ + /b/
+    assert_equal /(?-mix:a)b/,         /a/ + 'b'
+    assert_equal /(?-mix:(?-mix:(?-mix:)a)b)c/, Regexp.join('a', 'b', 'c')
+    #assert_equal /(?-mix:(?-mix:(?-mix:)a)b)c/, Regexp.join(/a/, /b/, /c/)
+    assert_equal 2,   '__abc__' =~ Regexp.join('a', 'b', 'c')
+    assert_equal 2,   '__abc__' =~ Regexp.join(/a/, /b/, /c/)
+    assert_equal nil, '__a.c__' =~ Regexp.join('a', 'b', 'c')
+    assert_equal nil, '__a.c__' =~ Regexp.join(/a/, /b/, /c/)
+  end
+
+  def test_2_escaping
+    assert_equal /(?-mix:)\./,          // + '.'  # Escaped
+    assert_equal /(?-mix:)(?-mix:.)/,  // + /./   # Not escaped
+  end
+
+  def test_3
+    assert_match Regexp.join(
+      'keyword1',
+      /.*/m,
+      'keyword2'
+    ),
+'keyword1
+asuethausnthauesth
+blah blah blah
+keyword2'
+  end
+
+  def test_loose_join
+    regexp = Regexp.loose_join('keyword1', 'keyword2')
+    assert_match regexp, 'keyword1 blah blah blah keyword2'
+    assert_equal nil,    "keyword1 blah\nblah\nblah keyword2" =~ regexp
+  end
+  def test_loose_join_multiline
+    regexp = Regexp.loose_join('keyword1', 'keyword2', :m => true)
+    assert_match regexp, 'keyword1 blah blah blah keyword2'
+    assert_match regexp, "keyword1 blah\nblah\nblah keyword2"
+  end
+
+end
+=end
+
+

data/lib/qualitysmith_extensions/test/difference_highlighting.rb

@@ -5,7 +5,8 @@
 # Submit to Facets?::
 # Developer notes::
 #++
-
+# This file adds a bit of color to your failed string comparisons (assert_equal).
+# Differences will be highlighted for you in color so that you can instantly find them.
 
 require 'rubygems'
 gem 'colored'
@@ -19,6 +20,8 @@ require 'qualitysmith_extensions/module/bool_attr_accessor'
 require 'qualitysmith_extensions/module/guard_method'
 require 'qualitysmith_extensions/colored/toggleability'
 
+require 'test/unit'
+
 class String
   # For all of the next 3 methods, we will underline spaces so that they are actually visible on the screen.
   # Newlines will be replaced with '\n'"\n".
@@ -27,32 +30,32 @@ class String
   def highlight_commonality
     self.
       make_control_characters_visible.
-      underline_spaces.
-      green.
-      send_unless(self == ' ', :bold)     # spaces are not bold, '_'s (and everything else) are
+      make_spaces_visible(:green).
+      green.bold
+      #send_unless(self == ' ', :bold)     # spaces are not bold; '_'s (and everything else) are
   end
   # This is a (sub)string that is different between expected and actual
   def highlight_difference
     self.
       make_control_characters_visible.
-      underline_spaces.
-      red.
-      send_unless(self == ' ', :bold)     # spaces are not bold, '_'s (and everything else) are
+      make_spaces_visible(:red).
+      red.bold
+      #send_unless(self == ' ', :bold)     # spaces are not bold; '_'s (and everything else) are
   end
   # This is a (sub)string that exists only in *self*, not in the other string
   def highlight_unique
     self.
       make_control_characters_visible.
-      underline_spaces.
-      yellow
+      make_spaces_visible(:magenta).
+      magenta
   end
-  # This is a (sub)string that doesn't exist in self, only in the *other* string
+  # This is a (sub)string that doesn't exist in self, only in the *other* string. It's just a placeholder character (a space) that represents a *missing* character.
   def highlight_absence
-    self.white.on_yellow.bold
+    self.white.on_cyan.bold
   end
-  def underline_spaces
+  def make_spaces_visible(color)
     #:todo: Make this optional? Might be useful if you are comparing things with lots of spaces and underscores and you want to be able to tell the difference between them...?
-    self.gsub(' ', ' '.underline)
+    self.gsub(' ', ' '.send(:"on_#{color}"))
   end
   def make_control_characters_visible 
     self.gsub(/\n/, '\n'+"\n").   # Show '\n' in addition to actually doing the line break
@@ -61,9 +64,11 @@ class String
     #:todo: Add other control characters?
   end
 end
+
 module Test
   module Unit
     module Assertions
+
       class AssertionMessage
         @@inspect_strings = false
         mguard_method :inspect_strings!, :@@inspect_strings
@@ -87,7 +92,8 @@ module Test
           end
         end
         alias_method_chain :convert, :option_to_not_use_inspect_for_strings
-      end
+      end # class AssertionMessage
+
     end
   end
 end
@@ -98,26 +104,38 @@ module Test
       @@use_assert_equal_with_highlight = nil
       mguard_method :use_assert_equal_with_highlight!, :@@use_assert_equal_with_highlight
 
-      # Rather than showing the expected and the actual and asking the user to painstakingly compare the two and figure out the
-      # commonalities and differences himself, this method will highlight the differences for the user (in color), so that they
-      # can be spotted in less than an instant!
+      # The built-in behavior for <tt>assert_equal</tt> method is great for comparing small strings, but not so great for long strings.
+      # If both the strings you are dealing with are both 20 paragraphs long, for example, and they differ by only one character,
+      # the task of locating and identifying the one character that is off is akin to finding a (literal) needle in a 
+      # (literal) haystack (not fun!).
+      #
+      # link:include/assert_equal_with_difference_highlighting-wheres_waldo.png
+      #
+      # This replacement/wrapper for <tt>assert_equal</tt> aims to solve all of your string comparison woes (and eventually someday
+      # perhaps arrays and hashes as well), helping you to spot differences very quickly and to have fun doing it.
       #
-      # Strings:
-      #   Does a characterwise comparison between the two strings.
-      #   Common characters are displayed in green, different characters in red, and characters that exist in one but not the
-      #   other are displayed in yellow (a blank yellow background as placeholders for the string in which those characters
-      #   are missing).
-      # Arrays:
-      #   [:todo:] 
-      # Hashes:
-      #   [:todo:] 
+      # Rather than simply showing you the raw (<tt>inspect</tt>ed) +expected+ and +actual+ and expecting you, the poor user, to
+      # painstakingly compare the two and figure out exactly which characters are different by yourself this method will *highlight*
+      # the differences for you, allowing you to spot them an instant or less!!
       #
-      # Difference in method signature from assert_equal_without_difference_highlighting:
-      # * last argument is a hash (+options+) rather than message=nil, since I don't see the use in passing in a message if
-      #   the default message can be made useful enough.
-      # * If you really want to pass in a message, use <tt>:message => 'my message'</tt>
+      # link:include/assert_equal_with_difference_highlighting-there_he_is.png
       #
-      # By default, highlighting is only used when one or both of the strings being compared is long/multiline. You can override the default with the <tt>:higlight</tt> option:
+      # *Strings*:
+      # * Does a characterwise comparison between the two strings. That is, for each index, it will look at the character at that
+      #   index and decide if it is the same or different than the character at the same location in the other string. There are
+      #   3 1/2 cases:
+      #   * *Common* characters are displayed in _green_,
+      #   * *Different* characters in _red_,
+      #   * Characters that exist <b>in only one string</b> but not the other are displayed in _yellow_
+      #     * A _cyan_ <tt>~</tt> will appear that location in the _other_ string, as a placeholder for the <b>missing character</b>.
+      # *Arrays*:
+      # * [:todo:] 
+      # *Hashes*:
+      # * [:todo:] 
+      #
+      # <b>Disabling/enabling highlighting</b>:
+      #
+      # By default, highlighting is only used when one or both of the strings being compared is long or spans multiple lines. You can override the default with the <tt>:higlight</tt> option:
       #   assert_equal 'really long string', 'another really long string', :highlight => true
       # You can turn it on for all assert_equal assertions by calling
       #   Test::Unit::Assertions::use_assert_equal_with_highlight!
@@ -126,14 +144,26 @@ module Test
       #     assert_equal 'really long string', 'another really long string'
       #   end
       #
-      # * Spaces are displayed with an underline so that they are actually visible on the screen.
-      # * Newlines are displayed as the text '\n' followed by an actual newline.
+      # *Notes*:
+      # * Spaces are displayed as with a bright colored background so that they are actually visible on the screen (so you can distinguish an empty line from a line with spaces on it, for example).
+      # * Newlines are displayed as the text <tt>\n</tt> followed by the actual newline. Other control characters (<tt>\t</tt>, <tt>\r</tt>) are escaped as well so that you can tell what character it is.
       #
-      # Advanced:
-      # * If you want everything to be escaped (so you can see the color *codes* instead of the color itself, for example), use :inspect_strings => true
+      # <b>Difference in method signature</b> from <tt>assert_equal_without_difference_highlighting</tt> (the standard behavior):
+      # * The last argument (+options+) is expected to be a hash rather than message=nil, since I don't see the use in passing in a message if
+      #   the _default_ message can be made useful enough.
+      # * However, for compatibility with existing assert_equal calls, it will check if the 3rd argument is a string and if it is will use it as the failure message.
+      # * If you to pass in a message in combination with other options, use <tt>:message => 'my message'</tt>
+      #
+      # *Advanced*:
+      # * If you want everything to be escaped (so you can see the color _codes_ instead of the color itself, for example), use <tt>:inspect_strings => true</tt>
       #
       def assert_equal_with_highlighting(expected, actual, options = {})
-        message = options.delete(:message) || nil
+        if options.is_a?(String)
+          message = options 
+          options = {}
+        else
+          message = options.delete(:message) || nil
+        end
         highlight = options.delete(:highlight)
 
         Assertions.send_unless(highlight.nil?, :use_assert_equal_with_highlight!, highlight) do
@@ -151,11 +181,10 @@ module Test
                 act = actual[i]   ? actual[i].chr   : nil
                 if act.nil?
                   expected_with_highlighting << exp.highlight_unique
-                  actual_with_highlighting   << ' '.highlight_absence
+                  actual_with_highlighting   << '~'.highlight_absence
                 elsif exp.nil?
-                  expected_with_highlighting << ' '.highlight_absence
+                  expected_with_highlighting << '~'.highlight_absence
                   actual_with_highlighting   << act.highlight_unique
-
                 elsif exp != act
                   expected_with_highlighting << exp.highlight_difference
                   actual_with_highlighting   << act.highlight_difference
@@ -166,9 +195,9 @@ module Test
 
               end
               full_message = build_message(message, <<End, expected_with_highlighting, actual_with_highlighting)
-#{(' '*50 + ' Expected: ' + ' '*50).blue.on_white }
+#{(' '*50 + ' Expected: ' + ' '*50).blue.underline.on_white }
 ?
-#{(' '*50 + ' But was:  ' + ' '*50).yellow.on_red }
+#{(' '*50 + ' But was:  ' + ' '*50).yellow.underline.on_red }
 ?
 End
             end
@@ -182,7 +211,6 @@ End
         end # use_assert_equal_with_highlight!
 
       end # def assert_equal_with_highlighting
-      alias_method :assert_equal_with_difference_highlighting, :assert_equal_with_highlighting
       alias_method_chain :assert_equal, :highlighting
 
     end
@@ -210,11 +238,11 @@ require 'test/unit'
 # nice to capture the output of the failure and make an assertion against that. But I'm not sure how to do that...
 
 class TheTest < Test::Unit::TestCase
-  def test01_single_character_difference
+  def test01_single_character_differences
     assert_equal <<End, <<End
 Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Sed feugiat mi. In sagittis, augue non eleifend sodales, arcu urna congue sapien, aliquet molestie pede urna sit amet dolor. Etiam diam. Vestibulum ornare, felis et porta faucibus, magna sapien vulputate arcu, vel facilisis lectus ipsum et ipsum.
 
-Vivamus massa odio, lacinia eu, euismod vitae, lobortis eu, erat. Duis tincidunt, neque ac tincidunt convallis, nibh tellus sodales eros, ut tristique nunc purus in urna. Nullam semper. Fusce quis augue ut metus interdum congue. Duis id dolor eu mi pellentesque sagittis. Quisque imperdiet orci a odio.
+Vivamus massa odio, lacinia eu, euismod vitae, lobortis eu, erat. Duis tincidunt, neque ac_tincidunt convallis, nibh tellus sodales eros, ut tristique nunc purus in urna. Nullam semper. Fusce quis augue ut metus interdum congue. Duis id dolor eu mi pellentesque sagittis. Quisque imperdiet orci a odio.
 End
 Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Sed feugiat mi. In sagittis, augue non eleifend sodales, arcu urna congue sapien, aliquet molestie pede urna sit amet dolor. Etiam diam. Vestibulum ornare, felis et porta faucibus, magna sapien vulputate arcu, vel facilisis lectus ipsum et ipsum.
 
@@ -259,10 +287,8 @@ End
 
   def test07_underscores_versus_underlines
     assert_equal <<End, <<End
-If you look really closely, you'll see that underscores are a brighter color (bold), while spaces appear somewhaat faded, less visible:
 ___[Underscores]___[Underscores]   [Spaces] _ _ _ _ _ [Mix]
 End
-If you look really closely, you'll see that underscores are a brighter color (bold), while spaces appear somewhaat faded, less visible:
    [Spaces]     ___[Underscores]   [Spaces] _ _ __ _ _[Mix]     
 End
   end
@@ -283,6 +309,13 @@ End
       assert_equal 'really long string', 'another really long string'
     end
   end
+  def test12_compatibility__using_arg3_as_message
+    assert_equal 'really long string', 'another really long string', 'This is my message! Can you see it?'
+  end
+  def test13_that_assert_nil_still_works
+    # Exposed a bug that existed previously, where it tried to do "".delete(:message)
+    assert_nil nil
+  end
 
 end
 =end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.2
 specification_version: 1
 name: qualitysmith_extensions
 version: !ruby/object:Gem::Version 
-  version: 0.0.29
-date: 2007-04-30 00:00:00 -07:00
+  version: 0.0.33
+date: 2007-05-01 00:00:00 -07:00
 summary: A collection of reusable Ruby methods developed by QualitySmith.
 require_paths: 
 - lib
@@ -68,6 +68,7 @@ files:
 - lib/qualitysmith_extensions/date/month_ranges.rb
 - lib/qualitysmith_extensions/time/deprecated.rb
 - lib/qualitysmith_extensions/time/all.rb
+- lib/qualitysmith_extensions/regexp/join.rb
 - lib/qualitysmith_extensions/mutex/if_available.rb
 - lib/qualitysmith_extensions/console/command.rb
 - lib/qualitysmith_extensions/console/command.facets.1.8.54.rb