bahuvrihi-tap 0.10.1 → 0.10.2

data/lib/tap/test/file_methods_class.rb

@@ -0,0 +1,26 @@
+module Tap
+  module Test
+    module FileMethodsClass
+      
+      # Access the test root structure (a Tap::Root)
+      attr_accessor :trs
+      
+      # 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,32 +1,15 @@
-require 'test/unit'
-require 'tap/test/file_methods'
 require 'tap/test/subset_methods'
 require 'tap/test/script_methods/script_test'
 
-module Test # :nodoc:
-  module Unit # :nodoc:
-    class TestCase
-      class << self
-
-        def acts_as_script_test(options={})
-          options = options.inject({:root => file_test_root}) do |hash, (key, value)|
-            hash[key.to_sym || key] = value
-            hash
-          end
-          acts_as_file_test(options)
-          include Tap::Test::SubsetMethods
-          include Tap::Test::ScriptMethods
-        end
-        
-      end
-    end
-  end
-end
-
 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
@@ -81,7 +64,7 @@ module Tap
           cmd = ScriptTest.new(default_command_path)
           yield(cmd)
           
-          Tap::Root.indir(test_dir, true) do
+          Tap::Root.chdir(test_dir, true) do
             with_argv do
               puts "\n# == #{method_name}"
 

data/lib/tap/test/subset_methods.rb

@@ -1,167 +1,5 @@
-require 'test/unit'
 require 'benchmark'
-require 'pp'
-require 'tap/test/env_vars'
-
-module Test # :nodoc:
-  module Unit # :nodoc:
-    class TestCase 
-      class << self
-        include Tap::Test::EnvVars
-        
-        # Passes conditions to subclass
-        def inherited(subclass) # :nodoc:
-          super
-          subclass_conditions = conditions.inject({}) do |memo, (key, value)|
-            memo.update(key => (value.dup rescue value))
-          end
-          subclass.instance_variable_set(:@conditions, subclass_conditions)
-          subclass.instance_variable_set(:@run_test_suite, nil)
-          subclass.instance_variable_set(:@skip_messages, [])
-          
-      #    subclass_inputs = prompt_inputs.inject({}) do |memo, (key, value)|
-      #      memo.update(key => (value.dup rescue value))
-      #    end
-      #    subclass.instance_variable_set("@prompt_inputs", subclass_inputs)
-        end
-        
-        # Experimental -- The idea is to provide a way to prompt once for inputs
-        # that get used multiple times in a test.  Perhaps create accessors
-        # automatically?
-        
-      #  def prompt_inputs
-      #    @prompt_inputs ||= {}
-      #  end
-        
-      #  def require_inputs(*keys, &block)
-      #    if run_subset?("PROMPT")
-      #      puts "\n#{name} requires inputs -- Enter values or 'skip'."
-            
-      #      argv = ARGV.dup
-      #      begin
-      #        ARGV.clear
-      #        keys.collect do |key|
-      #          print "#{key}: "
-      #          value = gets.strip
-      #          if value =~ /skip/i
-      #            skip_test "missing inputs"
-      #            break
-      #          end
-      #          prompt_inputs[key] = value
-      #        end
-      #      ensure
-      #        ARGV.clear
-      #        ARGV.concat(argv)
-      #      end
-      #    else
-      #      skip_test "prompt test"
-      #    end
-      #  end 
-        
-        #
-        # conditions
-        #
-
-        # A hash of defined conditions
-        def conditions
-          @conditions ||= {}
-        end
-      
-        # Defines a condition block and associated message.  
-        # Raises an error if no condition block is given.
-        def condition(name, msg=nil, &block)
-          raise "no condition block given" unless block_given?
-          conditions[name.to_sym] = [msg, block]
-        end
-        
-        # Returns true if the all blocks for the named conditions return true.
-        #
-        #   condition(:is_true) { true }
-        #   condition(:is_false) { false }
-        #   satisfied?(:is_true)              # => true
-        #   satisfied?(:is_true, :is_false)   # => false
-        #
-        def satisfied?(*conditions)
-          unsatisfied_conditions(*conditions).empty?
-        end
-          
-        # Returns an array of the unsatified conditions.  Raises 
-        # an error if the named condition has not been defined.
-        #
-        #   condition(:is_true) { true }
-        #   condition(:is_false) { false }
-        #   unsatisfied_conditions(:is_true, :is_false)   # => [:is_false]
-        #
-        def unsatisfied_conditions(*conditions)
-          conditions = self.conditions.keys if conditions.empty?
-          unsatified = []
-          conditions.each do |condition|
-            raise "Unknown condition: #{condition}" unless self.conditions.has_key?(condition)
-            unsatified << condition unless (self.conditions[condition.to_sym].last.call() ? true : false)
-          end
-          unsatified
-        end
-        
-        # Returns true if RUBY_PLATFORM matches one of the specfied
-        # platforms.  Use the prefix 'non_' to specify any plaform 
-        # except the specified platform (ex: 'non_mswin').  Returns
-        # true if no platforms are specified.
-        #
-        # Some common platforms:
-        #   mswin    Windows
-        #   darwin   Mac
-        def match_platform?(*platforms)
-          platforms.each do |platform|
-            platform.to_s =~ /^(non_)?(.*)/
-
-            non = true if $1
-            match_platform = !RUBY_PLATFORM.index($2).nil?
-            return false unless (non && !match_platform) || (!non && match_platform)
-          end
-
-          true
-        end
-        
-        # Returns true if the subset type or 'ALL' is specified in ENV
-        def run_subset?(type)
-          env_true?(type) || env_true?("ALL") ? true : false
-        end
-
-        #
-        # Methods for skipping a test suite
-        #
-        attr_accessor :run_test_suite
-        
-        # Returns run_test_suite, or true if run_test_suite is not set.
-        def run_test_suite?
-          run_test_suite.nil? ? true : run_test_suite
-        end
-        
-        # 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 unless msg.nil?
-        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
-            puts "Skipping #{name}: #{@skip_messages.join(', ')}" unless @skip_messages.empty?
-            Test::Unit::TestSuite.new(name)
-          end
-        end
-      end      
-    end
-  end
-end
+require 'tap/test/subset_methods_class'
 
 module Tap
   module Test
@@ -247,6 +85,11 @@ module Tap
     # See {Test::Unit::TestCase}[link:classes/Test/Unit/TestCase.html] for documentation of the class methods added by SubsetMethods
     module SubsetMethods
       include Tap::Test::EnvVars
+      
+      def self.included(base)
+        super
+        base.extend SubsetMethodsClass
+      end
   
       def satisfied?(*conditions)
         self.class.satisfied?(*conditions)

data/lib/tap/test/subset_methods_class.rb

@@ -0,0 +1,128 @@
+require 'tap/test/env_vars'
+
+module Tap
+  module Test
+    module SubsetMethodsClass
+      include Tap::Test::EnvVars
+      
+      # Passes conditions to subclass
+      def inherited(subclass) # :nodoc:
+        super
+        subclass_conditions = conditions.inject({}) do |memo, (key, value)|
+          memo.update(key => (value.dup rescue value))
+        end
+        subclass.instance_variable_set(:@conditions, subclass_conditions)
+        subclass.instance_variable_set(:@run_test_suite, nil)
+        subclass.instance_variable_set(:@skip_messages, [])
+        
+    #    subclass_inputs = prompt_inputs.inject({}) do |memo, (key, value)|
+    #      memo.update(key => (value.dup rescue value))
+    #    end
+    #    subclass.instance_variable_set("@prompt_inputs", subclass_inputs)
+      end
+      
+      # Experimental -- The idea is to provide a way to prompt once for inputs
+      # that get used multiple times in a test.  Perhaps create accessors
+      # automatically?
+      
+    #  def prompt_inputs
+    #    @prompt_inputs ||= {}
+    #  end
+      
+    #  def require_inputs(*keys, &block)
+    #    if run_subset?("PROMPT")
+    #      puts "\n#{name} requires inputs -- Enter values or 'skip'."
+          
+    #      argv = ARGV.dup
+    #      begin
+    #        ARGV.clear
+    #        keys.collect do |key|
+    #          print "#{key}: "
+    #          value = gets.strip
+    #          if value =~ /skip/i
+    #            skip_test "missing inputs"
+    #            break
+    #          end
+    #          prompt_inputs[key] = value
+    #        end
+    #      ensure
+    #        ARGV.clear
+    #        ARGV.concat(argv)
+    #      end
+    #    else
+    #      skip_test "prompt test"
+    #    end
+    #  end 
+      
+      #
+      # conditions
+      #
+
+      # A hash of defined conditions
+      def conditions
+        @conditions ||= {}
+      end
+    
+      # Defines a condition block and associated message.  
+      # Raises an error if no condition block is given.
+      def condition(name, msg=nil, &block)
+        raise "no condition block given" unless block_given?
+        conditions[name.to_sym] = [msg, block]
+      end
+      
+      # Returns true if the all blocks for the named conditions return true.
+      #
+      #   condition(:is_true) { true }
+      #   condition(:is_false) { false }
+      #   satisfied?(:is_true)              # => true
+      #   satisfied?(:is_true, :is_false)   # => false
+      #
+      def satisfied?(*conditions)
+        unsatisfied_conditions(*conditions).empty?
+      end
+        
+      # Returns an array of the unsatified conditions.  Raises 
+      # an error if the named condition has not been defined.
+      #
+      #   condition(:is_true) { true }
+      #   condition(:is_false) { false }
+      #   unsatisfied_conditions(:is_true, :is_false)   # => [:is_false]
+      #
+      def unsatisfied_conditions(*conditions)
+        conditions = self.conditions.keys if conditions.empty?
+        unsatified = []
+        conditions.each do |condition|
+          raise "Unknown condition: #{condition}" unless self.conditions.has_key?(condition)
+          unsatified << condition unless (self.conditions[condition.to_sym].last.call() ? true : false)
+        end
+        unsatified
+      end
+      
+      # Returns true if RUBY_PLATFORM matches one of the specfied
+      # platforms.  Use the prefix 'non_' to specify any plaform 
+      # except the specified platform (ex: 'non_mswin').  Returns
+      # true if no platforms are specified.
+      #
+      # Some common platforms:
+      #   mswin    Windows
+      #   darwin   Mac
+      def match_platform?(*platforms)
+        platforms.each do |platform|
+          platform.to_s =~ /^(non_)?(.*)/
+
+          non = true if $1
+          match_platform = !RUBY_PLATFORM.index($2).nil?
+          return false unless (non && !match_platform) || (!non && match_platform)
+        end
+
+        true
+      end
+      
+      # Returns true if the subset type or 'ALL' is specified in ENV
+      def run_subset?(type)
+        env_true?(type) || env_true?("ALL") ? true : false
+      end
+    end
+    
+  end
+end

data/lib/tap/test/tap_methods.rb

@@ -1,35 +1,3 @@
-require 'test/unit'
-require 'tap/test/file_methods'
-require 'tap/test/subset_methods'
-
-module Test # :nodoc:
-  module Unit # :nodoc:
-    class TestCase
-      class << self
-        # 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={})
-          options = options.inject({:root => file_test_root}) do |hash, (key, value)|
-            hash[key.to_sym || key] = value
-            hash
-          end
-          acts_as_file_test(options)
-          
-          include Tap::Test::SubsetMethods
-          include Tap::Test::TapMethods
-        end
-        
-      end
-    end
-  end
-end
-
 module Tap
   module Test
 
@@ -97,7 +65,7 @@ module Tap
       # Asserts that an array of audits are all equal, basically feeding
       # each pair of audits to assert_audit_equal.
       def assert_audits_equal(expected, audits)
-        each_pair_with_index(expected, audits) do |exp, audit, index|
+        Utils.each_pair_with_index(expected, audits) do |exp, audit, index|
           assert_audit_equal(exp, audit, [index])
         end
       end

data/lib/tap/test/utils.rb

@@ -0,0 +1,118 @@
+require 'tap/root'
+require 'fileutils'
+
+module Tap
+  module Test
+    module Utils
+      module_function
+      
+      # Generates an array of [source, reference] pairs mapping source
+      # files to reference files under the source_dir and reference_dir,
+      # respectively.  Only files under source dir with the reference_extname
+      # will be mapped; mappings are either:
+      #
+      # - a direct translation from source_dir to reference_dir, minus
+      #   the extname
+      # - a path under reference_dir with a matching basename, minus
+      #   the extname, so long as the matched path is unique
+      #
+      # If a mapped path cannot be found, dereference raises an ArgumentError.
+      #
+      # === example
+      #
+      #   root
+      #   |- input
+      #   |   |- dir.ref
+      #   |   |- ignored.txt
+      #   |   |- one.txt.ref
+      #   |   `- two.txt.ref
+      #   `- ref
+      #       |- dir
+      #       |- one.txt
+      #       `- path
+      #           `- to
+      #               `- two.txt
+      #
+      #  reference_map('/root/input', '/root/ref')
+      #  # => [
+      #  # ['/root/input/dir.ref',     '/root/ref/dir'],
+      #  # ['/root/input/one.txt.ref', '/root/ref/one.txt'],
+      #  # ['/root/input/two.txt.ref', '/root/ref/path/to/two.txt']]
+      #
+      #  reference_map(:input, :ref, ".txt")  # !> ArgumentError
+      #
+      def reference_map(source_dir, reference_dir, reference_extname='.ref')
+        Dir.glob(File.join(source_dir, "**/*#{reference_extname}")).collect do |path|
+          relative_path = Tap::Root.relative_filepath(source_dir, path).chomp(reference_extname)
+          reference_path = File.join(reference_dir, relative_path)
+
+          unless File.exists?(reference_path)
+            matching_paths = Dir.glob(File.join(reference_dir, "**/#{File.basename(relative_path)}"))
+
+            reference_path = case matching_paths.length
+            when 0 then raise ArgumentError, "no reference found for: #{path}"
+            when 1 then matching_paths[0]
+            else raise ArgumentError, "multiple references found for: #{path} [#{matching_paths.join(', ')}]"
+            end
+          end
+
+          [path, reference_path]
+        end
+      end
+      
+      def dereference(source_dirs, reference_dir, extname='.ref')
+        mapped_paths = []
+        begin
+          [*source_dirs].each do |source_dir|
+            reference_map(source_dir, reference_dir, extname).each do |path, source|
+              FileUtils.rm_r(path)
+              target = path.chomp(extname)
+              FileUtils.cp_r(source, target)
+              mapped_paths << target
+            end
+          end unless reference_dir == nil
+          
+          yield
+          
+        ensure
+          mapped_paths.each do |path|
+            FileUtils.rm_r(path) if File.exists?(path)
+            FileUtils.touch(path + extname)
+          end
+        end
+      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
+      
+      # 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
+    end
+  end
+end