bahuvrihi-tap 0.10.1 → 0.10.2

data/lib/tap/support/command_line/parser.rb

@@ -0,0 +1,121 @@
+module Tap
+  module Support
+    module CommandLine
+      class Parser
+        class << self
+          def parse_sequence(str, count=0)
+             seq = []
+             seq << count if str[0] == ?:
+             str.split(/:+/).each do |n| 
+               seq << n.to_i unless n.empty?
+             end
+             seq << count + 1 if str[-1] == ?:
+             seq
+          end
+          
+          def bracket_regexp(l, r)
+            /\A--(\d*)#{Regexp.escape(l)}([\d,]*)#{Regexp.escape(r)}\z/
+          end
+          
+          def parse_bracket(lead, str, count=0)
+             bracket = []
+             str.split(/,+/).each do |n| 
+               bracket << n.to_i unless n.empty?
+             end
+
+             [lead.empty? ? count : lead.to_i, bracket]
+          end
+          
+          # Parses the input string as YAML, if the string matches the YAML document 
+          # specifier (ie it begins with "---\s*\n").  Otherwise returns the string.
+          #
+          #   str = {'key' => 'value'}.to_yaml       # => "--- \nkey: value\n"
+          #   Tap::Script.parse_yaml(str)            # => {'key' => 'value'}
+          #   Tap::Script.parse_yaml("str")          # => "str"
+          def parse_yaml(str)
+            str =~ /\A---\s*\n/ ? YAML.load(str) : str
+          end
+
+          def shift_arg(argv)
+            index = nil
+            argv.each_with_index do |arg, i|
+              if arg !~ /\A-/
+                index = i 
+                break
+              end
+            end
+            index == nil ? nil : argv.delete_at(index)
+          end
+        end
+        
+        ROUND = /\A--(\+(\d+)|\+*)\z/
+        SEQUENCE = /\A--(\d*(:\d*)+)\z/
+        FORK = bracket_regexp("[", "]")
+        MERGE = bracket_regexp("{", "}")
+        SYNC_MERGE = bracket_regexp("(", ")")
+        INVALID =  /\A--(\z|[^A-Za-z])/
+        
+        attr_reader :rounds
+        attr_reader :sequences
+        attr_reader :forks
+        attr_reader :merges
+        attr_reader :sync_merges
+        
+        def initialize(argv)
+          @sequences = []
+          @forks = []
+          @merges = []
+          @sync_merges = []
+          
+          current = []
+          current_round = []
+          count = 0
+          @rounds = [current_round]
+          
+          argv.each do |arg|
+            unless arg =~ INVALID
+              current << arg
+              next
+            end
+            
+            # for peformance split to match
+            # most arguments just once.
+            current_round << current unless current.empty?
+            current = []
+
+            case arg
+            when ROUND
+              current_round = (@rounds[$2 ? $2.to_i : $1.length] ||= [])
+            when SEQUENCE
+              @sequences << Parser.parse_sequence($1, count)
+            when FORK
+              @forks << Parser.parse_bracket($1, $2, count)
+            when MERGE
+              @merges << Parser.parse_bracket($1, $2, count)
+            when SYNC_MERGE
+              @sync_merges << Parser.parse_bracket($1, $2, count)
+            else 
+              raise ArgumentError, "invalid argument: #{arg}"
+            end
+            
+            count += 1
+          end
+          
+          current_round << current unless current.empty?
+          @rounds.delete_if {|round| round.nil? || round.empty? }
+        end
+        
+        def targets
+          targets = []
+          sequences.each {|sequence| targets.concat(sequence[1..-1]) }
+          forks.each {|fork| targets.concat(fork[1]) }
+          targets.concat merges.collect {|target, sources| target }
+          targets.concat sync_merges.collect {|target, sources| target }
+          
+          targets.uniq.sort
+        end
+        
+      end
+    end
+  end
+end

data/lib/tap/support/configurable_class.rb

@@ -57,7 +57,7 @@ module Tap
         caller.each_with_index do |line, index|
           case line
           when /\/configurable.rb/ then next
-          when /^(([A-z]:)?[^:]+):(\d+)/
+          when Lazydoc::CALLER_REGEXP
             base.instance_variable_set(:@source_file, File.expand_path($1))
             break
           end
@@ -71,7 +71,7 @@ module Tap
       # the configurations of the parent class.
       def inherited(child)
         unless child.instance_variable_defined?(:@source_file)
-          caller.first =~ /^(([A-z]:)?[^:]+):(\d+)/
+          caller.first =~ Lazydoc::CALLER_REGEXP
           child.instance_variable_set(:@source_file, File.expand_path($1)) 
         end
         
@@ -250,7 +250,7 @@ module Tap
         caller.each do |line|
           case line
           when /in .config.$/ then next
-          when /^(([A-z]:)?[^:]+):(\d+)/
+          when Lazydoc::CALLER_REGEXP
             options[:desc] = Lazydoc.register($1, $3.to_i - 1)
             break
           end

data/lib/tap/support/declarations.rb

@@ -49,7 +49,7 @@ module Tap
       def config(key, value=nil, options={}, &block)
         caller.each do |line|
           case line
-          when /^(([A-z]:)?[^:]+):(\d+)/
+          when Lazydoc::CALLER_REGEXP
             options[:desc] = Support::Lazydoc.register($1, $3.to_i - 1)
             break
           end
@@ -61,7 +61,7 @@ module Tap
       def config_attr(key, value=nil, options={}, &block)
         caller.each do |line|
           case line
-          when /^(([A-z]:)?[^:]+):(\d+)/
+          when Lazydoc::CALLER_REGEXP
             options[:desc] = Support::Lazydoc.register($1, $3.to_i - 1)
             break
           end

data/lib/tap/support/framework_class.rb

@@ -13,7 +13,7 @@ module Tap
         caller.each do |line|
           case line
           when /\/framework.rb/ then next
-          when /^(([A-z]:)?[^:]+):(\d+)/
+          when Lazydoc::CALLER_REGEXP
             base.instance_variable_set(:@source_file, File.expand_path($1))
             break
           end
@@ -24,7 +24,7 @@ module Tap
       
       def inherited(child)
         unless child.instance_variable_defined?(:@source_file)
-          caller.first =~ /^(([A-z]:)?[^:]+):(\d+)/
+          caller.first =~ Lazydoc::CALLER_REGEXP
           child.instance_variable_set(:@source_file, File.expand_path($1)) 
         end
         
@@ -64,7 +64,7 @@ module Tap
         caller.each_with_index do |line, index|
           case line
           when /\/tap\/support\/declarations.rb/ then next
-          when /^(([A-z]:)?[^:]+):(\d+)/
+          when Lazydoc::CALLER_REGEXP
             subclass.source_file = File.expand_path($1)
             lzd = subclass.lazydoc(false)
             lzd[const_name, false]['manifest'] = lzd.register($3.to_i - 1)            
@@ -162,8 +162,10 @@ module Tap
           end
           path_configs = path_configs[0]
         end
+        
+        argv = (argv + use_args).collect {|str| str =~ /\A---\s*\n/ ? YAML.load(str) : str }
 
-        [obj.reconfigure(path_configs).reconfigure(config), argv + use_args]
+        [obj.reconfigure(path_configs).reconfigure(config), argv]
       end
       
       def lazydoc(resolve=true)

data/lib/tap/support/gems/rake.rb

@@ -59,9 +59,9 @@ module Tap
           super
         end
       
-        def have_rakefile(indir=nil)
-          return super() if indir == nil
-          Tap::Root.indir(indir) { super() }
+        def have_rakefile(dir=nil)
+          return super() if dir == nil
+          Tap::Root.chdir(dir) { super() }
         end
 
         protected
@@ -86,5 +86,5 @@ end
 end
 
 Rake.application.extend Tap::Support::Gems::Rake
-Tap::Env.manifests[:rakefiles] = Tap::Support::RakeManifest
+Tap::Env.manifests[:rakefiles] = Tap::Support::Gems::RakeManifest
 

data/lib/tap/support/lazydoc.rb

@@ -122,7 +122,7 @@ module Tap
     #
     class Lazydoc
       
-      # A regexp matching an attribute start or end.  For the match:
+      # A regexp matching an attribute start or end.  After a match:
       #
       # $1:: const_name
       # $3:: key
@@ -133,6 +133,15 @@ module Tap
       # A regexp matching constants from the ATTRIBUTE_REGEXP leader
       CONSTANT_REGEXP = /#.*?([A-Z][A-z]*(::[A-Z][A-z]*)*)?$/
       
+      # A regexp matching a caller line, to extract the calling file
+      # and line number.  After a match:
+      #
+      # $1:: file
+      # $3:: line number (as a string, obviously)
+      #
+      # Note that line numbers in caller start at 1, not 0.
+      CALLER_REGEXP = /^(([A-z]:)?[^:]+):(\d+)/
+      
       class << self
         
         # A hash of (source_file, lazydoc) pairs tracking the

data/lib/tap/test.rb

@@ -1,4 +1,4 @@
-require 'tap/test/tap_methods'
+require 'test/unit'
 
 module Test # :nodoc:
   module Unit # :nodoc:
@@ -19,6 +19,84 @@ module Test # :nodoc:
     #--
     #See the TestTutorial for more information.
     class TestCase
+      class << self
+        
+        def inherited(child)
+          child.instance_variable_set(:@skip_messages, [])
+          child.instance_variable_set(:@run_test_suite, true)
+        end
+        
+        #
+        # Methods for skipping a test suite
+        #
+        
+        attr_accessor :run_test_suite
+
+        # Causes a test suite to be skipped.  If a message is given, it will
+        # print and notify the user the test suite has been skipped.
+        def skip_test(msg=nil)
+          self.run_test_suite = false
+
+          # experimental -- perhaps use this so that a test can be skipped
+          # for multiple reasons?
+          @skip_messages << msg
+        end
+
+        alias :original_suite :suite
+
+        # Modifies the default suite method to include/exclude tests based on platform.
+        def suite # :nodoc:
+          if run_test_suite
+            original_suite
+          else
+            skip_message = @skip_messages.compact.join(', ')
+            puts "Skipping #{name}#{skip_message.empty? ? '' : ': ' + skip_message}"
+            Test::Unit::TestSuite.new(name)
+          end
+        end
+        
+        # Causes a TestCase to act as a file test, by instantiating a class Tap::Root 
+        # (trs), and including FileMethods.  The root and directories used to 
+        # instantiate trs can be specified as options.  By default file_test_root
+        # and the directories {:input => 'input', :output => 'output', :expected => 'expected'} 
+        # will be used.
+        #
+        # Note: file_test_root determines a root directory <em>based on the calling file</em>.  
+        # Be sure to specify the root directory explicitly if you call acts_as_file_test
+        # from a file that is NOT meant to be test file.
+        def acts_as_file_test(options={})
+          include Tap::Test::FileMethods
+          
+          options = {
+            :root => file_test_root,
+            :directories => {:input => 'input', :output => 'output', :expected => 'expected'}
+          }.merge(options)
+          self.trs = 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:  Unless otherwise specified, <tt>acts_as_tap_test</tt> infers a root directory
+        # based on the calling file. Be sure to specify the root directory explicitly 
+        # if you call acts_as_file_test from a file that is NOT meant to be 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 => file_test_root}.merge(options))
+        end
+
+        def acts_as_script_test(options={})
+          include Tap::Test::FileMethods
+          include Tap::Test::ScriptMethods
+          
+          acts_as_file_test({:root => file_test_root}.merge(options))
+        end
+      end
     end
   end
 end
@@ -29,6 +107,9 @@ module Tap
   # 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')
   end
 end
 

data/lib/tap/test/env_vars.rb

@@ -22,7 +22,7 @@ module Tap
       
       # Returns true if the env_var(var) is set and matches /^true$/i
       def env_true?(var)
-        env(var) && env(var) =~ /^true$/i
+        (env(var) && env(var) =~ /^true$/i) ? true : false
       end
     end
   end

data/lib/tap/test/file_methods.rb

@@ -1,57 +1,6 @@
-require 'tap/root'
+require 'tap/test/utils'
 require 'tap/test/env_vars'
-require 'test/unit'
-require 'fileutils'
-
-module Test # :nodoc:
-  module Unit # :nodoc:
-    class TestCase
-      class << self
-        
-        # Access the test root structure (a Tap::Root)
-        attr_accessor :trs
-        
-        # Causes a TestCase to act as a file test, by instantiating a class Tap::Root 
-        # (trs), and including FileMethods.  The root and directories used to 
-        # instantiate trs can be specified as options.  By default file_test_root
-        # and the directories {:input => 'input', :output => 'output', :expected => 'expected'} 
-        # will be used.
-        #
-        # Note: file_test_root determines a root directory <em>based on the calling file</em>.  
-        # Be sure to specify the root directory explicitly if you call acts_as_file_test
-        # from a file that is NOT meant to be test file.
-        def acts_as_file_test(options={})
-          options = {
-            :root => file_test_root,
-            :directories => {:input => 'input', :output => 'output', :expected => 'expected'}
-          }.merge(options)
-
-          directories = options[:directories]
-          self.trs = Tap::Root.new(options[:root], directories)
-      
-          include Tap::Test::FileMethods
-        end
-    
-        # 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
-end
+require 'tap/test/file_methods_class'
 
 module Tap
   module Test  
@@ -141,7 +90,12 @@ module Tap
     # See {Test::Unit::TestCase}[link:classes/Test/Unit/TestCase.html] for documentation of the class methods added by FileMethods.
     module FileMethods
       include Tap::Test::EnvVars
-  
+      
+      def self.included(base)
+        super
+        base.extend FileMethodsClass
+      end
+      
       # Convenience accessor for the test root structure
       def trs
         self.class.trs
@@ -163,7 +117,7 @@ module Tap
         super
         @method_tempfiles = []
         clear_method_dir(:output)
-        try_remove_dir(method_root)
+        Utils.try_remove_dir(method_root)
       end
     
       # Teardown deletes the the output directories unless flagged otherwise.  Note 
@@ -182,8 +136,8 @@ module Tap
           end
         end
         
-        try_remove_dir(method_root)
-        try_remove_dir(trs.root)
+        Utils.try_remove_dir(method_root)
+        Utils.try_remove_dir(trs.root)
       end 
       
       # Returns method_name as a string (Ruby 1.9 symbolizes method_name)
@@ -241,18 +195,6 @@ module Tap
         dir_path = method_dir(dir, method_name_str)
         FileUtils.rm_r(dir_path) if File.exists?(dir_path)
       end
-      
-      # Attempts to remove the specified directory.  The root 
-      # will not be removed if the directory does not exist, or
-      # is not empty.  
-      def try_remove_dir(dir)
-        # Remove the directory if possible
-        begin
-          FileUtils.rmdir(dir) if File.exists?(dir) && Dir.glob(File.join(dir, "*")).empty?
-        rescue
-          # rescue cases where there is a hidden file, for example .svn
-        end
-      end
     
       # Generates a temporary filepath formatted like "output_dir\filename.pid.n.ext" where n 
       # is a counter that will be incremented from until a non-existant filepath is achieved.
@@ -277,36 +219,22 @@ module Tap
         filepath
       end
       
-      # Yields to the input block for each pair of entries in the input 
-      # arrays.  An error is raised if the input arrays do not have equal 
-      # numbers of entries.
-      def each_pair(a, b, &block) # :yields: entry_a, entry_b,
-        each_pair_with_index(a,b) do |entry_a, entry_b, index|
-          yield(entry_a, entry_b)
-        end
-      end
-      
-      # Same as each_pair but yields the index of the entries as well.
-      def each_pair_with_index(a, b, &block) # :yields: entry_a, entry_b, index
-        a = [a] unless a.kind_of?(Array)
-        b = [b] unless b.kind_of?(Array)
-      
-        raise ArgumentError, "The input arrays must have an equal number of entries." unless a.length == b.length
-        0.upto(a.length-1) do |index|
-          yield(a[index], b[index], index)
-        end
-      end
-      
-      # assert_files runs a file-based test that feeds all files in method_dir(:input) 
+      # assert_files runs a file-based test that feeds all files from input_dir
       # to the block, then compares the resulting files (which should be relative to 
-      # method_dir(:output)) with all the files in method_dir(:expected).  Note that
-      # since only the files returned by the block are used in the comparison,
-      # additional files in the output directory are effectively ignored.
+      # output_dir) with all the files in expected_dir.  Only the files returned by 
+      # the block are used in the comparison; additional files in the output directory 
+      # are effectively ignored.
       #
       # A variety of options can be specified to adjust the behavior:
       # 
-      #   :input_files                    specify the input files to pass to the block
-      #   :expected_files                 specify the expected files used in comparison
+      #   :input_dir                      specify the directory to glob for input files
+      #                                     (default method_dir(:input))
+      #   :output_dir                     specify the output directory
+      #                                     (default method_dir(:output))
+      #   :expected_dir                   specify the directory to glob for expected files
+      #                                     (default method_dir(:expected))
+      #   :input_files                    directly specify the input files to pass to the block
+      #   :expected_files                 directly specify the expected files used for comparison
       #   :include_input_directories      specifies directories to be included in the 
       #                                     input_files array (by default dirs are excluded)
       #   :include_expected_directories   specifies directories to be included in the
@@ -318,60 +246,122 @@ module Tap
       # not specified in the options and no files were found in method_dir(:expected).  
       # This tries to prevent silent false-positive results when you forget to put 
       # expected files in their place.
+      #
+      # === File References
+      # Sometimes the same files will get used across multiple tests.  To prevent
+      # duplication, and allow separate management of test files, file references
+      # can be provided in place of test files.  For instance, with a test
+      # directory like:
+      #
+      #   method_root
+      #   |- expected
+      #   |   |- one.txt.ref
+      #   |   `- two.txt.ref
+      #   |- input
+      #   |   |- one.txt.ref
+      #   |   `- two.txt.ref
+      #   `- ref
+      #       |- one.txt
+      #       `- two.txt
+      #   
+      # The input and expected files (all references in this case) can be dereferenced 
+      # to the 'ref' filepaths like so:
+      #
+      #   assert_files :reference_dir => method_dir(:ref) do |input_files|
+      #     input_files # => ['method_root/ref/one.txt', 'method_root/ref/two.txt']
+      #
+      #     input_files.collect do |input_file|
+      #       output_file = method_filepath(:output, File.basename(input_file)
+      #       FileUtils.cp(input_file, output_file)
+      #       output_file
+      #     end
+      #   end
+      #
+      # Dereferencing occurs relative to the input_dir/expected_dir configurations; a
+      # reference_dir must be specified for dereferencing to occur (see dereference
+      # for more details).
+      #
+      #--
+      # TODO:
+      # * add debugging information to indicate, for instance,  
+      #   when dereferencing is going on.
       def assert_files(options={}) # :yields: input_files
         make_test_directories
         
-        options = {
-          :input_files => nil,
-          :expected_files => nil,
-
-          :include_input_directories => false,
-          :include_expected_directories => false
-        }.merge(options)
+        options = default_assert_files_options.merge(options)
+        input_dir = options[:input_dir]
+        output_dir = options[:output_dir] 
+        expected_dir = options[:expected_dir]
         
-        # Get the input and expected files in this manner:
-        # - look for manually specified files
-        # - glob for files if none were specified
-        # - expand paths and sort
-        # - remove directories unless specified not to do so
-        input_files, expected_files = [:input, :expected].collect do |key|
-          files = options["#{key}_files".to_sym]
-          files = method_glob(key) if files.nil?
-          files = [files].flatten.collect {|file| File.expand_path(file) }.sort
+        reference_dir = options[:reference_dir]
+        reference_extname = options[:reference_extname]
+        
+        Utils.dereference([input_dir, expected_dir], reference_dir, reference_extname) do
 
-          unless options["include_#{key}_directories".to_sym]
-            files.delete_if {|file| File.directory?(file)} 
-          end
+          # Get the input and expected files in this manner:
+          # - look for manually specified files
+          # - glob for files if none were specified
+          # - expand paths and sort
+          # - remove directories unless specified not to do so
+          input_files, expected_files = [:input, :expected].collect do |key|
+            files = options["#{key}_files".to_sym]
+            if files.nil?
+              pattern = File.join(options["#{key}_dir".to_sym], "**/*")
+              files = Dir.glob(pattern)
+            end
+            files = [files].flatten.collect {|file| File.expand_path(file) }.sort
+
+            unless options["include_#{key}_directories".to_sym]
+              files.delete_if {|file| File.directory?(file)} 
+            end
           
-          files
-        end
+            files
+          end
         
-        # check at least one expected file was found
-        if expected_files.empty? && options[:expected_files] == nil
-          flunk "No expected files specified."
-        end
-  
-        # get output files from the block, expand and sort
-        output_files = [yield(input_files)].flatten.collect do |output_file| 
-          output_file = File.expand_path(output_file)
-        end.sort
+          # check at least one expected file was found
+          if expected_files.empty? && options[:expected_files] == nil
+            flunk "No expected files specified."
+          end
         
-        # check that the expected and output filepaths are the same
-        translated_expected_files = expected_files.collect do |expected_file|
-          method_translate(expected_file, :expected, :output)
-        end
-        assert_equal translated_expected_files, output_files, "Missing, extra, or unexpected output files"
-
-        # check that the expected and output file contents are equal
-        errors = []
-        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}>"
+          # get output files from the block, expand and sort
+          output_files = [yield(input_files)].flatten.collect do |output_file| 
+            File.expand_path(output_file)
+          end.sort
+        
+          # check that the expected and output filepaths are the same
+          translated_expected_files = expected_files.collect do |expected_file|
+            Tap::Root.translate(expected_file, expected_dir, output_dir)
           end
+          assert_equal translated_expected_files, output_files, "Missing, extra, or unexpected output files"
+        
+          # check that the expected and output file contents are equal
+          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}>"
+            end
+          end
+          flunk "File compare failed:\n" + errors.join("\n") unless errors.empty?
         end
-        flunk "File compare failed:\n" + errors.join("\n") unless errors.empty?
       end
-
+      
+      # The default assert_files options
+      def default_assert_files_options
+        {
+          :input_dir => method_dir(:input),
+          :output_dir => method_dir(:output),
+          :expected_dir => method_dir(:expected),
+          
+          :input_files => nil,
+          :expected_files => nil,
+          :include_input_directories => false,
+          :include_expected_directories => false,
+          
+          :reference_dir => nil,
+          :reference_extname => '.ref'
+        }
+      end
+      
     end
   end
 end