bahuvrihi-tap 0.10.4 → 0.10.5

data/lib/tap/test/file_methods_class.rb

@@ -1,26 +1,12 @@
 module Tap
   module Test
+    
+    # Class methods extending tests which include FileMethods.
     module FileMethodsClass
       
-      # Access the test root structure (a Tap::Root)
-      attr_accessor :trs
+      # The class-level test root (a Tap::Root).
+      attr_accessor :class_test_root
       
-      # Infers the test root directory from the calling file.  Ex:
-      #   'some_class.rb' => 'some_class'
-      #   'some_class_test.rb' => 'some_class'
-      def file_test_root
-        # the calling file is not the direct caller of +method_root+... this method is 
-        # only accessed from within another method call, hence the target caller is caller[1] 
-        # rather than caller[0].
-
-        # 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)}") 
-        calling_file.chomp("_test") 
-      end
     end
   end
 end

data/lib/tap/test/script_methods.rb

@@ -1,90 +1,76 @@
-require 'tap/test/subset_methods'
-require 'tap/test/script_methods/script_test'
-
-module Tap
-  module Test
-    module ScriptMethods
-      
-      def self.included(base)
-        super
-        base.send(:include, Tap::Test::SubsetMethods)  
-      end
-      
-      def assert_output_equal(a, b, msg)
-        a = a[1..-1] if a[0] == ?\n
-        if a == b
-          assert true
-        else
-          flunk %Q{
-#{msg}
-==================== expected output ====================
-#{a.gsub(/\t/, "\\t").gsub(/\r\n/, "\\r\\n\n").gsub(/\n/, "\\n\n")}
-======================== but was ========================
-#{b.gsub(/\t/, "\\t").gsub(/\r\n/, "\\r\\n\n").gsub(/\n/, "\\n\n")}
-=========================================================
-}
-        end
-      end
-      
-      def assert_alike(a, b, msg)
-        if b =~ a
-          assert true
-        else
-          flunk %Q{
-#{msg}
-================= expected output like ==================
-#{a}
-======================== but was ========================
-#{b.gsub(/\t/, "\\t").gsub(/\r\n/, "\\r\\n\n").gsub(/\n/, "\\n\n")}
-=========================================================
-}
-        end
-      end
-      
-      def with_argv(argv=[])
-        current_argv = ARGV.dup
-        begin
-          ARGV.clear
-          ARGV.concat(argv)
-          
-          yield
-          
-        ensure
-          ARGV.clear
-          ARGV.concat(current_argv)
-        end
-      end
-      
-      def default_command_path
-        nil
-      end
-      
-      def script_test(test_dir=method_root)
-        subset_test("SCRIPT", "s") do
-          cmd = ScriptTest.new(default_command_path)
-          yield(cmd)
-          
-          Tap::Root.chdir(test_dir, true) do
-            with_argv do
-              puts "\n# == #{method_name}"
-
-              cmd.run(env('stepwise')) do |expected, result, msg|
-                case expected
-                when String
-                  assert_output_equal(expected, result, msg)
-                when Regexp
-                  assert_alike(expected, result, msg)
-                end
-              end
-            end
-          end
-        end
-      end
-      
-    end
-  end
-end
-
-
-
-
+require 'tap/test/subset_methods'
+require 'tap/test/script_methods/script_test'
+
+module Tap
+  module Test
+    module ScriptMethods
+      
+      def self.included(base)
+        super
+        base.send(:include, Tap::Test::SubsetMethods)  
+      end
+      
+      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 ==================
+#{a}
+======================== but was ========================
+#{Utils.whitespace_escape(b)}
+=========================================================
+}
+        end
+      end
+      
+      def default_command_path
+        nil
+      end
+      
+      def script_test(test_dir=method_root.root)
+        subset_test("SCRIPT", "s") do
+          cmd = ScriptTest.new(default_command_path)
+          yield(cmd)
+          
+          Tap::Root.chdir(test_dir, true) do
+            Utils.with_argv do
+              puts "\n# == #{method_name}"
+
+              cmd.run(env('stepwise')) do |expected, result, msg|
+                case expected
+                when String
+                  assert_output_equal(expected, result, msg)
+                when Regexp
+                  assert_alike(expected, result, msg)
+                end
+              end
+            end
+          end
+        end
+      end
+      
+    end
+  end
+end
+
+
+
+

data/lib/tap/test/script_methods/regexp_escape.rb

@@ -0,0 +1,92 @@
+require 'tap/test/utils'
+
+module Tap
+  module Test
+    module ScriptMethods
+      
+      # 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 format the original string upon to_s, to simplify their use in 
+      # tests.
+      #
+      #   r = RegexpEscape.new %q{
+      #   a multiline
+      #   :...:
+      #   example}
+      #
+      #   r =~ %q{
+      #   a multiline
+      #   matching
+      #   example}  # => true
+      #
+      #   r !~ %q{
+      #   a failing multiline
+      #   example}  # => true
+      #
+      #   r.to_s 
+      #   # => %q{\n
+      #   # a multiline\n
+      #   # :...:\n
+      #   # example}
+      #
+      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
+
+            splits = str.split(ESCAPE_SEQUENCE).collect do |split|
+              super(split)
+            end
+            splits << "" if splits.empty?
+            splits.zip(substituents).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, but with
+        # whitespace escaped as in Utils#whitespace_escape
+        def to_s
+          Utils.whitespace_escape(@original_str)
+        end
+      end
+    end
+  end
+end

data/lib/tap/test/script_methods/script_test.rb

@@ -1,4 +1,5 @@
 require 'tap/support/shell_utils'
+require 'tap/test/script_methods/regexp_escape'
 
 module Tap
   module Test
@@ -47,10 +48,11 @@ module Tap
         def time(msg, command)
           commands << [command, msg, nil, nil]
         end
-
-        def check(msg, command, &validation)
+        
+        def check(msg, command, use_regexp_escapes=true, &validation)
           new_commands = split(command) 
           new_commands.each_with_index do |(cmd, expected), i|
+            expected = RegexpEscape.new(expected) if expected && use_regexp_escapes
             commands << [cmd, (new_commands.length > 1 ? "#{msg} (#{i})" : msg), expected, validation]
           end
         end

data/lib/tap/test/subset_methods.rb

@@ -4,17 +4,11 @@ require 'tap/test/subset_methods_class'
 module Tap
   module Test
     
-    # Ideally you always run all of your tests and they all run and pass everywhere. In 
-    # practice it's useful to suppress the execution of some tests -- long running tests, 
-    # tests specific for a given platform, or tests that depend on some condition, such 
-    # as the version of some optional third-party software your code interacts with.
+    # SubsetMethods provides methods to conditionally run tests, or to skip a 
+    # test suite entirely.
     # 
-    # SubsetMethods extends TestCase with methods for defining conditions that can be 
-    # used to conditionally perform some action, or skip a test suite entirely.  When 
-    # you include SubsetMethods within a specific TestCase, additional methods are 
-    # made available for filtering tests.
-    # 
-    #   require 'tap/test/subset_methods'
+    #   require 'tap/test'
+    #
     #   class Test::Unit::TestCase
     #     # only true if running on windows
     #     condition(:windows) { match_platform?('mswin') }
@@ -27,8 +21,9 @@ module Tap
     #     skip_test unless satisfied?(:windows)
     #   end
     # 
-    # WindowsOnlyTest will only run on a Windows platform. These conditions can be used 
-    # in specific tests, when only some tests need to be skipped.
+    # Here the WindowsOnlyTest will only run on a Windows platform. Conditions
+    # like these may be targeted at specific tests when only some tests need 
+    # to be skipped.
     # 
     #   class RunOnlyAFewTest < Test::Unit::TestCase
     #     include SubsetMethods
@@ -57,32 +52,31 @@ module Tap
     #     end
     #   end
     # 
-    # In the example, the ENV variables EXTENDED, BENCHMARK, and CUSTOM act as flags
-    # to run specific tests.  If you're running your test using Rake, ENV variables 
-    # can be set from the command line like so:
+    # In the example, the ENV variables EXTENDED, BENCHMARK, and CUSTOM act as
+    # flags to run specific tests.  If you're running your test using Rake, ENV
+    # variables can be set from the command line like so:
     # 
     #   % rake test EXTENDED=true
     #   % rake test BENCHMARK=true
     # 
-    # Since tap can run rake tasks as well, these are equivalent:
+    # Since tap and rap can run rake tasks as well, these are equivalent:
     #
     #   % tap run test EXTENDED=true
-    #   % tap run test BENCHMARK=true
+    #   % rap test BENCHMARK=true
     #
     # In so far as SubsetMethods is concerned, the environment variables are 
-    # case-insensitive.  As in the example, additional ENV-variable-dependent 
-    # tests can be defined using the subset_test method. To run all tests that  
-    # get switched using an environment variable, set ALL=true.  
+    # case-insensitive.  As in the example, additional ENV-based tests can be 
+    # defined using the subset_test method. To run all tests that get switched 
+    # using an ENV variable, set ALL=true.  
     #
     #   # also runs benchmark tests
-    #   % tap run test BenchMark=true
+    #   % rap test BenchMark=true
     #
     #   # runs all tests
-    #   % tap run test all=true
+    #   % rap test all=true
     #
-    # === Class Methods
-    # 
-    # See {Test::Unit::TestCase}[link:classes/Test/Unit/TestCase.html] for documentation of the class methods added by SubsetMethods
+    # See {Test::Unit::TestCase}[link:classes/Test/Unit/TestCase.html] and
+    # SubsetMethodsClass for more information.
     module SubsetMethods
       include Tap::Test::EnvVars
       
@@ -90,12 +84,14 @@ module Tap
         super
         base.extend SubsetMethodsClass
       end
-  
-      def satisfied?(*conditions)
-        self.class.satisfied?(*conditions)
+      
+      # Returns true if the specified conditions are satisfied.
+      def satisfied?(*condition_names)
+        self.class.satisfied?(*condition_names)
       end
       
-      # Returns true if the subset type or 'ALL' is specified in ENV
+      # Returns true if the subset type (ex 'BENCHMARK') or 'ALL' is
+      # specified in ENV.
       def run_subset?(type)
         self.class.run_subset?(type)
       end
@@ -117,7 +113,7 @@ module Tap
       #     platform_test('mswin') { ... }
       #   end
       #
-      # See TestCase#match_platform? for matching details.
+      # See SubsetMethodsClass#match_platform? for matching details.
       def platform_test(*platforms)
         if self.class.match_platform?(*platforms)
           yield
@@ -126,9 +122,9 @@ module Tap
         end
       end
       
-      # Conditonal test.  Only runs if the named conditions are satisfied.
-      # If no conditons are explicitly set, only runs if all conditions 
-      # are satisfied.
+      # Conditonal test.  Only runs if the specified conditions are satisfied.
+      # If no conditons are explicitly set, condition_test only runs if ALL 
+      # conditions for the test are satisfied.
       # 
       #   condition(:is_true) { true }
       #   condition(:is_false) { false }
@@ -141,23 +137,23 @@ module Tap
       #     condition_test {  # does not run }
       #   end
       #
-      # See TestCase#condition for more details.
-      def condition_test(*conditions)
-        unsatisfied_conditions = self.class.unsatisfied_conditions(*conditions)
-        if unsatisfied_conditions.empty?
+      # See SubsetMethodsClass#condition for more details.
+      def condition_test(*condition_names)
+        if self.class.unsatisfied_conditions(*condition_names).empty?
           yield
         else
           print ' '
         end
       end
       
-      # Basic method for a subset test.  The provided block will run if:
-      # - The subset type is specified in ENV
-      # - The subset 'ALL' is specified in ENV
-      # - The test method name matches the regexp provided in the <TYPE>_TEST ENV variable
+      # Defines a subset test.  The provided block will only run if:
+      # - the subset type is specified in ENV
+      # - the subset 'ALL' is specified in ENV
+      # - the test method name matches the regexp provided in the 
+      #   <TYPE>_TEST ENV variable
       #  
-      # Otherwise the block will be skipped and +skip+ will be printed in the test output.  
-      # By default skip is the first letter of +type+.
+      # Otherwise the block will be skipped and +skip+ will be printed in the
+      # test output.  By default skip is the first letter of +type+.
       #
       # For example, with these methods:
       #
@@ -176,17 +172,18 @@ module Tap
       #   ENV['CUSTOM_TEST']=test_one  test_one
       #   ENV['CUSTOM']=nil            no tests get run
       # 
-      # If you're running your tests with Rake, ENV variables can be set from the 
-      # command line, so you might use these command line statements:
+      # If you're running your tests with rake (or rap), ENV variables may be
+      # set from the command line.
       #
       #   # all tests
-      #   % rake test all=true
+      #   % rap test all=true
       #
       #   # custom subset tests
-      #   % rake test custom=true
+      #   % rap test custom=true
       #
-      #   # just test_one
-      #   % rake test custom_test=test_one
+      #   # just test_one (it is the only test
+      #   # matching the '.est_on.' pattern)
+      #   % rap test custom_test=.est_on.
       #
       def subset_test(type, skip=type[0..0].downcase)
         type = type.upcase