bahuvrihi-tap 0.10.6 → 0.10.7

data/lib/tap/test.rb

@@ -1,20 +1,26 @@
 require 'test/unit'
 $:.unshift File.expand_path("#{File.dirname(__FILE__)}/..")
+require 'tap/test/extensions'
 
 module Test # :nodoc:
   module Unit # :nodoc:
     
     # Methods extending TestCase. For more information see:
-    # - Tap::Test::SubsetMethods
-    # - Tap::Test::FileMethods
-    # - Tap::Test::TapMethods
+    # - Tap::Test::SubsetTest
+    # - Tap::Test::FileTest
+    # - Tap::Test::TapTest
     #   
     #--
     #See the TestTutorial for more information.
     class TestCase
+      extend Tap::Test::Extensions
+      
       class << self
+        alias tap_original_test_case_inherited inherited
         
         def inherited(child)
+          super
+          tap_original_test_case_inherited(child)
           child.instance_variable_set(:@skip_messages, [])
           child.instance_variable_set(:@run_test_suite, true)
         end
@@ -52,86 +58,7 @@ module Test # :nodoc:
             Test::Unit::TestSuite.new(name)
           end
         end
-        
-        # Causes a TestCase to act as a file test, by including FileMethods and
-        # instantiating class_test_root (a Tap::Root).  The root and directories 
-        # used by class_test_root may be specified as options.  
-        #
-        # Note: by default acts_as_file_test determines a root directory 
-        # <em>based on the calling file</em>.  Be sure to specify the root 
-        # directory manually if you call acts_as_file_test from a file that 
-        # isn't the test file.
-        def acts_as_file_test(options={})
-          include Tap::Test::FileMethods
-          
-          options = {
-            :root => test_root_dir,
-            :directories => {
-              :input => 'input',
-              :output => 'output',
-              :expected => 'expected'}
-          }.merge(options)
-          
-          self.class_test_root = Tap::Root.new(options[:root], options[:directories])
-        end
-
-        # Causes a unit test to act as a tap test -- resulting in the following:
-        # - setup using acts_as_file_test
-        # - inclusion of Tap::Test::SubsetMethods
-        # - inclusion of Tap::Test::InstanceMethods 
-        #
-        # Note: by default acts_as_tap_test determines a root directory 
-        # <em>based on the calling file</em>.  Be sure to specify the root 
-        # directory manually if you call acts_as_file_test from a file that 
-        # isn't the test file.
-        def acts_as_tap_test(options={})
-          include Tap::Test::SubsetMethods
-          include Tap::Test::FileMethods
-          include Tap::Test::TapMethods
-          
-          acts_as_file_test({:root => test_root_dir}.merge(options))
-        end
-
-        def acts_as_script_test(options={})
-          include Tap::Test::FileMethods
-          include Tap::Test::ScriptMethods
-          
-          acts_as_file_test({:root => test_root_dir}.merge(options))
-        end
-        
-        private
-        
-        # Infers the test root directory from the calling file.
-        #   'some_class.rb' => 'some_class'
-        #   'some_class_test.rb' => 'some_class'
-        def test_root_dir # :nodoc:
-          # caller[1] is considered the calling file (which should be the test case)
-          # note that the output of calller.first is like:
-          #   ./path/to/file.rb:10
-          #   ./path/to/file.rb:10:in 'method'
-          calling_file = caller[1].gsub(/:\d+(:in .*)?$/, "")
-          calling_file.chomp(File.extname(calling_file)).chomp("_test") 
-        end
-         
       end
     end
   end
 end
-
-module Tap
-  
-  # Modules facilitating testing.  TapMethods are specific to
-  # Tap, but SubsetMethods and FileMethods are more general in 
-  # their utility.
-  module Test
-    autoload(:SubsetMethods, 'tap/test/subset_methods')
-    autoload(:FileMethods, 'tap/test/file_methods')
-    autoload(:TapMethods, 'tap/test/tap_methods')
-    autoload(:ScriptMethods, 'tap/test/script_methods')
-    autoload(:Utils, 'tap/test/utils')
-  end
-end
-
-
-
-

data/lib/tap/test/assertions.rb

@@ -0,0 +1,38 @@
+require 'tap/test/utils'
+
+module Tap
+  module Test
+    module Assertions
+      def assert_output_equal(a, b, msg=nil)
+        a = a[1..-1] if a[0] == ?\n
+        if a == b
+          assert true
+        else
+          flunk %Q{
+#{msg}
+==================== expected output ====================
+#{Utils.whitespace_escape(a)}
+======================== but was ========================
+#{Utils.whitespace_escape(b)}
+=========================================================
+}
+        end
+      end
+
+      def assert_alike(a, b, msg=nil)
+        if b =~ a
+          assert true
+        else
+          flunk %Q{
+#{msg}
+================= expected output like ==================
+#{Utils.whitespace_escape(a)}
+======================== but was ========================
+#{Utils.whitespace_escape(b)}
+=========================================================
+}
+        end
+      end
+    end
+  end
+end

data/lib/tap/test/extensions.rb

@@ -0,0 +1,78 @@
+module Tap
+  
+  # Modules facilitating testing.  TapTest are specific to
+  # Tap, but SubsetTest and FileTest are more general in 
+  # their utility.
+  module Test
+    autoload(:SubsetTest, 'tap/test/subset_test')
+    autoload(:FileTest, 'tap/test/file_test')
+    autoload(:TapTest, 'tap/test/tap_test')
+    autoload(:ScriptTest, 'tap/test/script_test')
+
+    module Extensions
+      def acts_as_subset_test
+        include Tap::Test::SubsetTest
+      end
+    
+      # Causes a TestCase to act as a file test, by including FileTest and
+      # instantiating class_test_root (a Tap::Root).  The root and directories 
+      # used by class_test_root may be specified as options.  
+      #
+      # Note: by default acts_as_file_test determines a root directory 
+      # <em>based on the calling file</em>.  Be sure to specify the root 
+      # directory manually if you call acts_as_file_test from a file that 
+      # isn't the test file.
+      def acts_as_file_test(options={})
+        include Tap::Test::FileTest
+      
+        options = {
+          :root => test_root_dir,
+          :directories => {
+            :input => 'input',
+            :output => 'output',
+            :expected => 'expected'}
+        }.merge(options)
+      
+        self.class_test_root = Tap::Root.new(options[:root], options[:directories])
+      end
+
+      # Causes a unit test to act as a tap test -- resulting in the following:
+      # - setup using acts_as_file_test
+      # - inclusion of Tap::Test::SubsetTest
+      # - inclusion of Tap::Test::InstanceMethods 
+      #
+      # Note: by default acts_as_tap_test determines a root directory 
+      # <em>based on the calling file</em>.  Be sure to specify the root 
+      # directory manually if you call acts_as_file_test from a file that 
+      # isn't the test file.
+      def acts_as_tap_test(options={})
+        acts_as_subset_test
+        acts_as_file_test({:root => test_root_dir}.merge(options))
+      
+        include Tap::Test::TapTest
+      end
+
+      def acts_as_script_test(options={})
+        acts_as_file_test({:root => test_root_dir}.merge(options))
+      
+        include Tap::Test::ScriptTest
+      end
+    
+      private
+    
+      # Infers the test root directory from the calling file.
+      #   'some_class.rb' => 'some_class'
+      #   'some_class_test.rb' => 'some_class'
+      def test_root_dir # :nodoc:
+        # caller[1] is considered the calling file (which should be the test case)
+        # note that caller entries are like this:
+        #   ./path/to/file.rb:10
+        #   ./path/to/file.rb:10:in 'method'
+        
+        calling_file = caller[1].gsub(/:\d+(:in .*)?$/, "")
+        calling_file.chomp(File.extname(calling_file)).chomp("_test") 
+      end
+    end
+  end
+end
+

data/lib/tap/test/{file_methods.rb → file_test.rb}

@@ -1,19 +1,19 @@
-require 'tap/test/utils'
 require 'tap/test/env_vars'
-require 'tap/test/file_methods_class'
+require 'tap/test/assertions'
+require 'tap/test/regexp_escape'
+require 'tap/test/file_test_class'
 
 module Tap
   module Test  
     
-
-    # FileMethods facilitates access and utilization of test-specific files and
-    # directories. FileMethods provides each test method is setup with a Tap::Root 
+    # FileTest facilitates access and utilization of test-specific files and
+    # directories. FileTest provides each test method is setup with a Tap::Root 
     # (method_root) specific for the method, and defines a new assertion method 
     # (assert_files) to facilitate tests which involve the production and/or 
     # modification of files.
     #
-    #   [file_methods_doc_test.rb]
-    #   class FileMethodsDocTest < Test::Unit::TestCase
+    #   [file_test_doc_test.rb]
+    #   class FileTestDocTest < Test::Unit::TestCase
     #     acts_as_file_test
     # 
     #     def test_something
@@ -56,13 +56,14 @@ module Tap
     #   end
     #
     # See {Test::Unit::TestCase}[link:classes/Test/Unit/TestCase.html] and
-    # FileMethodsClass for more information.
-    module FileMethods
+    # FileTestClass for more information.
+    module FileTest
       include Tap::Test::EnvVars
+      include Tap::Test::Assertions
       
       def self.included(base)
         super
-        base.extend FileMethodsClass
+        base.extend FileTestClass
       end
       
       # Convenience method to access the class_test_root.
@@ -121,13 +122,19 @@ module Tap
       #   % rap test KEEP_FAILURES=true
       #
       # Be sure to call super when overriding this method.
-      def teardown     
+      def teardown
+        # check that method_root still exists (nil may
+        # indicate setup was overridden without super)
+        unless method_root
+          raise "teardown failure: method_root is nil"
+        end
+        
         # clear out the output folder if it exists, unless flagged otherwise
         unless env("KEEP_OUTPUTS") || (!@test_passed && env("KEEP_FAILURES"))
           begin
              Utils.clear_dir(method_root[:output])
           rescue
-            raise("teardown failure: could not remove output files")
+            raise("teardown failure: could not remove output files (#{$!.message})")
           end
         end
         
@@ -180,7 +187,7 @@ module Tap
       # Lets define a test that transforms input files into output files in a trivial 
       # way, simply by replacing 'input' with 'output' in the file.
       #
-      #   class FileMethodsDocTest < Test::Unit::TestCase
+      #   class FileTestDocTest < Test::Unit::TestCase
       #     acts_as_file_test
       # 
       #     def test_sub
@@ -201,7 +208,7 @@ module Tap
       #
       # Now say you had some input and expected files for the 'test_sub' method:
       #
-      #   file_methods_doc/test_sub
+      #   file_test_doc/test_sub
       #   |- expected
       #   |   |- one.txt
       #   |   `- two.txt
@@ -290,7 +297,7 @@ module Tap
       # for more details).
       #
       # === Keeping Outputs
-      # By default FileMethods sets teardown to cleans up the output directory. For 
+      # By default FileTest sets teardown to cleans up the output directory. For 
       # ease in debugging, ENV variable flags can be specified to keep all output 
       # files (KEEP_OUTPUTS) or to keep the output files for just the tests that fail 
       # (KEEP_FAILURES).  These flags can be specified from the command line if you're
@@ -303,7 +310,42 @@ module Tap
       # TODO:
       # * add debugging information to indicate, for instance,  
       #   when dereferencing is going on.
-      def assert_files(options={}) # :yields: input_files
+      def assert_files(options={}, &block) # :yields: input_files
+        transform_test(block, options) do |expected_file, output_file|
+          unless FileUtils.cmp(expected_file, output_file) 
+            flunk "<#{expected_file}> not equal to\n<#{output_file}>"
+          end
+        end
+      end
+      
+      def assert_files_alike(options={}, &block) # :yields: input_files
+        transform_test(block, options) do |expected_file, output_file|
+          regexp = RegexpEscape.new(File.read(expected_file)) 
+          str = File.read(output_file)
+          assert_alike(regexp, str, "<#{expected_file}> not equal to\n<#{output_file}>")
+        end
+      end
+      
+      # The default assert_files options
+      def default_assert_files_options
+        {
+          :input_dir => method_root[:input],
+          :output_dir => method_root[:output],
+          :expected_dir => method_root[:expected],
+          
+          :input_files => nil,
+          :expected_files => nil,
+          :include_input_directories => false,
+          :include_expected_directories => false,
+          
+          :reference_dir => nil,
+          :reference_extname => '.ref'
+        }
+      end
+      
+      private
+      
+      def transform_test(block, options={}) # :yields: expected_files, output_files
         make_test_directories
         
         options = default_assert_files_options.merge(options)
@@ -342,7 +384,7 @@ module Tap
           end
         
           # get output files from the block, expand and sort
-          output_files = [yield(input_files)].flatten.collect do |output_file| 
+          output_files = [block.call(input_files)].flatten.collect do |output_file| 
             File.expand_path(output_file)
           end.sort
         
@@ -356,32 +398,17 @@ module Tap
           errors = []
           Utils.each_pair(expected_files, output_files) do |expected_file, output_file|
             unless (File.directory?(expected_file) && File.directory?(output_file)) || FileUtils.cmp(expected_file, output_file)
-              errors << "<#{expected_file}> not equal to\n<#{output_file}>"
+              begin
+                yield(expected_file, output_file)
+              rescue
+                errors << $!
+              end
             end
           end
           flunk "File compare failed:\n" + errors.join("\n") unless errors.empty?
         end
       end
       
-      # The default assert_files options
-      def default_assert_files_options
-        {
-          :input_dir => method_root[:input],
-          :output_dir => method_root[:output],
-          :expected_dir => method_root[:expected],
-          
-          :input_files => nil,
-          :expected_files => nil,
-          :include_input_directories => false,
-          :include_expected_directories => false,
-          
-          :reference_dir => nil,
-          :reference_extname => '.ref'
-        }
-      end
-      
-      private
-      
       # utility method for method_tempfile; increments index until the
       # path base.indexext does not exist.
       def next_indexed_path(base, index, ext) # :nodoc:

data/lib/tap/test/{file_methods_class.rb → file_test_class.rb}

@@ -1,8 +1,8 @@
 module Tap
   module Test
     
-    # Class methods extending tests which include FileMethods.
-    module FileMethodsClass
+    # Class methods extending tests which include FileTest.
+    module FileTestClass
       
       # The class-level test root (a Tap::Root).
       attr_accessor :class_test_root

data/lib/tap/test/regexp_escape.rb

@@ -0,0 +1,87 @@
+require 'tap/test/utils'
+
+module Tap
+  module Test
+
+    # RegexpEscape is a subclass of regexp that escapes all but the text in a
+    # special escape sequence.  This allows the creation of complex regexps
+    # to match, for instance, console output.
+    #
+    # The RegexpEscape.escape (or equivalently the quote) method does the
+    # work; all regexp-active characters are escaped except for characters
+    # enclosed by ':.' and '.:' delimiters.
+    #
+    #   RegexpEscape.escape('reg[exp]+ chars. are(quoted)')       # => 'reg\[exp\]\+\ chars\.\ are\(quoted\)'
+    #   RegexpEscape.escape('these are not: :.a(b*)c.:')          # => 'these\ are\ not:\ a(b*)c'
+    #
+    # In addition, all-period regexps are automatically upgraded to '.*?';
+    # use the '.{n}' notation to specify n arbitrary characters.
+    #
+    #   RegexpEscape.escape('_:..:_:...:_:....:')        # => '_.*?_.*?_.*?'
+    #   RegexpEscape.escape(':..{1}.:')                  # => '.{1}'
+    #
+    # RegexpEscape instances are initialized using the escaped input string
+    # and return the original string upon to_s.
+    #
+    #   str = %q{
+    #   a multiline
+    #   :...:
+    #   example}
+    #   r = RegexpEscape.new(str)
+    #
+    #   r =~ %q{
+    #   a multiline
+    #   matching
+    #   example}  # => true
+    #
+    #   r !~ %q{
+    #   a failing multiline
+    #   example}  # => true
+    #
+    #   r.to_s    # => str
+    #
+    class RegexpEscape < Regexp
+      
+      # matches the escape sequence
+      ESCAPE_SEQUENCE = /:\..*?\.:/
+      
+      class << self
+      
+        # Escapes regexp-active characters in str, except for character
+        # delimited by ':.' and '.:'.  See the class description for
+        # details.
+        def escape(str)
+          substituents = []
+          str.scan(ESCAPE_SEQUENCE) do
+            regexp_str = $&[2...-2]
+            regexp_str = ".*?" if regexp_str =~ /^\.*$/
+            substituents << regexp_str
+          end
+          substituents << ""
+
+          splits = str.split(ESCAPE_SEQUENCE).collect do |split|
+            super(split)
+          end
+          splits << "" if splits.empty?
+          
+          splits.zip(substituents).to_a.flatten.join
+        end
+        
+        # Same as escape.
+        def quote(str)
+          escape(str)
+        end
+      end
+      
+      def initialize(str)
+        super(RegexpEscape.escape(str))
+        @original_str = str
+      end
+      
+      # Returns the original string for self
+      def to_s
+        @original_str
+      end
+    end
+  end
+end