tap 0.12.4 → 0.17.0

data/lib/tap/test/subset_test_class.rb

@@ -1,99 +0,0 @@
-require 'tap/test/env_vars'
-
-module Tap
-  module Test
-    
-    # Class methods extending tests which include SubsetTest.
-    module SubsetTestClass
-      include Tap::Test::EnvVars
-      
-      # Passes conditions to subclass
-      def inherited(child) # :nodoc:
-        super
-        dup = {}
-        conditions.each_pair {|key, value| dup[key] = value.dup }
-        child.instance_variable_set(:@conditions, dup)
-      end
-      
-      # Initialize conditions.
-      def self.extended(base) # :nodoc:
-        base.instance_variable_set(:@conditions, {})
-      end
-      
-      # A hash of [name, [msg, condition_block]] pairs defined by condition.
-      attr_reader :conditions
-    
-      # Defines a condition block and associated message.  
-      # Raises an error if no condition block is given.
-      def condition(name, msg=nil, &block)
-        raise ArgumentError, "no condition block given" unless block_given?
-        conditions[name] = [msg, block]
-      end
-      
-      # Returns true if the all blocks for the specified conditions return true.
-      #
-      #   condition(:is_true) { true }
-      #   condition(:is_false) { false }
-      #   satisfied?(:is_true)              # => true
-      #   satisfied?(:is_true, :is_false)   # => false
-      #
-      # Yields the name and message for each unsatisfied condition to the
-      # block, if given.
-      def satisfied?(*names) # :yields: name-of-unsatisfied-condition, msg
-        unsatisfied = unsatisfied_conditions(*names)
-        
-        unsatisfied.each do |name| 
-          yield(name, condition[name][0])
-        end if block_given?
-          
-        unsatisfied.empty?
-      end
-        
-      # Returns an array of the unsatified conditions.  Raises 
-      # an error if a condition has not been defined.
-      #
-      #   condition(:is_true) { true }
-      #   condition(:is_false) { false }
-      #   unsatisfied_conditions(:is_true, :is_false)   # => [:is_false]
-      #
-      def unsatisfied_conditions(*condition_names)
-        condition_names = conditions.keys if condition_names.empty?
-        unsatified = []
-        condition_names.each do |name|
-          unless condition = conditions[name]
-            raise ArgumentError, "Unknown condition: #{name}"
-          end
-          
-          unsatified << name unless condition.last.call
-        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_test.rb

@@ -1,109 +0,0 @@
-require 'tap'
-
-module Tap
-  module Test
-
-    # Tap-specific testing methods to help with testing Tasks, such as the
-    # checking of audits and test-specific modification of application 
-    # configuration.
-    #
-    # === Class Methods
-    # 
-    # See {Test::Unit::TestCase}[link:classes/Test/Unit/TestCase.html] for documentation of the class methods added by TapTest.
-    module TapTest
-      
-      # Returns the test-method-specific application.
-      attr_reader :app
-      
-      # Setup creates a test-method-specific application that is initialized
-      # to the method_root, and uses the relative and absolute paths from
-      # trs (the test root structure, see Tap::Test::FileTest). 
-      #
-      # Also makes sure Tap::App.instance returns the test method app.
-      def setup
-        super
-        @app = Tap::App.new(app_config)
-        Tap::App.instance = @app
-      end
-      
-      # 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, msg=nil, &block)
-        assert_equal expected.length, audits.length, "expected <#{expected.length}> audits, but was <#{audits.length}>"
-        Utils.each_pair_with_index(expected, audits) do |exp, audit, index|
-          assert_audit_equal(exp, audit, &block)
-        end
-      end
-      
-      # Asserts that an audit trail matches the expected trail.  By default
-      # the expected trail should be composed of [key, value] arrays 
-      # representing each audit, but a block may be provided to collect other
-      # attributes.
-      #
-      # Simple assertion:
-      #
-      #   a = Audit.new(:a, 'a')
-      #   b = Audit.new(:b, 'b', a)
-      # 
-      #   e = [[:a, 'a'], [:b, 'b']]
-      #   assert_audit_equal(e, b)
-      #
-      # Assertion with merge:
-      #
-      #   a = Audit.new(:a, 'a')
-      #   b = Audit.new(:b, 'b', a)
-      # 
-      #   c = Audit.new(:c, 'c')
-      #   d = Audit.new(:d, 'd', c)
-      # 
-      #   e = Audit.new(:e, 'e')
-      #   f = Audit.new(:f, 'f', [b,d])
-      # 
-      #   eb = [[:a, "a"], [:b, "b"]]
-      #   ed = [[:c, "c"], [:d, "d"]]
-      #   e =  [[eb, ed], [:e, "e"], [:f, "f"]]
-      # 
-      #   assert_audit_equal(e, c)
-      #
-      def assert_audit_equal(expected, audit, msg=nil, &block)
-        block = lambda {|a| [a.key, a.value] } unless block
-        actual = audit.trail(&block)
-        assert_equal(expected, actual, msg)
-      end
-      
-      # The configurations used to initialize self.app
-      def app_config
-        {:quiet => true, :debug => true}
-      end
-      
-      # Reconfigures app with the input configurations for the 
-      # duration of the block.
-      #
-      #   app = Tap::App.new(:quiet => true, :debug => false)
-      #   with_config({:quiet => false}, app) do 
-      #     app.quiet                    # => false
-      #     app.debug                    # => false
-      #   end
-      #
-      #   app.quiet                      # => true
-      #   app.debug                      # => false
-      #
-      def with_config(config={}, app=self.app, &block)
-        begin
-          hold = app.config.to_hash
-          
-          app.reconfigure(config)
-          
-          yield block if block_given?
-        ensure
-          app.send(:initialize_config, hold)
-        end
-      end
-      
-    end
-  end
-end
-
-
-
-

data/lib/tap/test/utils.rb

@@ -1,231 +0,0 @@
-require 'tap/root'
-require 'fileutils'
-require 'tempfile'
-
-module Tap
-  module Support
-    autoload(:Templater, 'tap/support/templater')
-  end
-  
-  module Test
-    module Utils
-      module_function
-      
-      # Generates an array of [source, reference] pairs mapping source
-      # files to reference files under the source and reference dirs,
-      # respectively.  Only files under source dir matching the pattern
-      # will be mapped.  Mappings are either (in this order):
-      #
-      # - the path under reference_dir contained in the source file
-      # - a direct translation of the source file from the source to
-      #   the reference dir, minus the extname
-      #
-      # Notes:
-      # - Source files may contain comments but should otherwise
-      #   consist only of indentation (which is stripped) and
-      #   the reference path.
-      # - If a mapped path cannot be found, dereference raises  
-      #   a DereferenceError.
-      #
-      # === example
-      #
-      #   root
-      #   |- input
-      #   |   |- dir.ref
-      #   |   |- ignored.txt
-      #   |   |- one.txt.ref
-      #   |   `- two.txt.ref
-      #   `- ref
-      #       |- dir
-      #       |- one.txt
-      #       `- path
-      #           `- to
-      #               `- two.txt
-      #
-      # The 'two.txt.ref' file contains a reference path:
-      #
-      #  File.read('/root/input/two.txt.ref')    # => 'path/to/two.txt'
-      #
-      # Now:
-      #
-      #  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']]
-      #
-      # And since no path matches 'ignored.txt':
-      #
-      #  reference_map('/root/input', '/root/ref', '**/*.txt')     
-      #  # !> DereferenceError
-      #
-      def reference_map(source_dir, reference_dir, pattern='**/*.ref')
-        Dir.glob(File.join(source_dir, pattern)).sort.collect do |source|
-          # use the path specified in the source file
-          relative_path = File.read(source).gsub(/#.*$/, "").strip
-          
-          # use the relative filepath of the source file to the
-          # source dir (minus the extname) if no path is specified
-          if relative_path.empty?
-            relative_path = Tap::Root.relative_filepath(source_dir, source).chomp(File.extname(source))
-          end
-          
-          reference = File.join(reference_dir, relative_path)
-          
-          # raise an error if no reference file is found
-          unless File.exists?(reference)
-            raise DereferenceError, "no reference found for: #{source}"
-          end
-
-          [source, reference]
-        end
-      end
-      
-      # Dereferences source files with reference files for the duration
-      # of the block.  The mappings of source to reference files are
-      # determined using reference_map; dereferenced files are at the
-      # same location as the source files, but with the '.ref' extname
-      # removed.
-      #
-      # Notes:
-      # - The reference extname is implicitly specified in pattern;
-      #   the final extname of the source file is removed during
-      #   dereferencing regardless of what it is.
-      #
-      def dereference(source_dirs, reference_dir, pattern='**/*.ref', tempdir=Dir::tmpdir)
-        mapped_paths = []
-        begin
-          [*source_dirs].each do |source_dir|
-            reference_map(source_dir, reference_dir, pattern).each do |source, reference|
-              
-              # move the source file to a temporary location
-              tempfile = Tempfile.new(File.basename(source), tempdir)
-              tempfile.close
-              FileUtils.mv(source, tempfile.path)
-              
-              # copy the reference to the target
-              target = source.chomp(File.extname(source))
-              FileUtils.cp_r(reference, target)
-              
-              mapped_paths << [target, source, tempfile]
-            end
-          end unless reference_dir == nil
-          
-          yield
-          
-        ensure
-          mapped_paths.each do |target, source, tempfile|
-            # remove the target and restore the original source file
-            FileUtils.rm_r(target) if File.exists?(target)
-            FileUtils.mv(tempfile.path, source)
-          end
-        end
-      end
-      
-      # Uses a Tap::Support::Templater to template and replace the contents of path, 
-      # for the duration of the block.  The attributes will be available in the
-      # template context.
-      def template(paths, attributes={}, tempdir=Dir::tmpdir)
-        mapped_paths = []
-        begin
-          [*paths].each do |path|
-            # move the source file to a temporary location
-            tempfile = Tempfile.new(File.basename(path), tempdir)
-            tempfile.close
-            FileUtils.cp(path, tempfile.path)
-              
-            # template the source file
-            content = File.read(path)
-            File.open(path, "wb") do |file|
-              file << Support::Templater.new(content, attributes).build
-            end
-            
-            mapped_paths << [path, tempfile]
-          end
-
-          yield
-          
-        ensure
-          mapped_paths.each do |path, tempfile|
-            # restore the original source file
-            FileUtils.rm(path) if File.exists?(path)
-            FileUtils.mv(tempfile.path, path)
-          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, error_msg=nil, &block) # :yields: entry_a, entry_b, index
-        a = [a] unless a.kind_of?(Array)
-        b = [b] unless b.kind_of?(Array)
-        
-        unless a.length == b.length
-          raise ArgumentError, (error_msg || "The input arrays must have an equal number of entries.")
-        end
-        
-        0.upto(a.length-1) do |index|
-          yield(a[index], b[index], index)
-        end
-      end
-      
-      # Attempts to recursively remove the specified method directory and all 
-      # files within it.  Raises an error if the removal does not succeed.
-      def clear_dir(dir)
-        # clear out the folder if it exists
-        FileUtils.rm_r(dir) if File.exists?(dir)
-      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
-      
-      # Sets ARGV to the input argv for the duration of the block.
-      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 whitespace_escape(str)
-        str.to_s.gsub(/\s/) do |match|
-          case match
-          when "\n" then "\\n\n"
-          when "\t" then "\\t"
-          when "\r" then "\\r"
-          when "\f" then "\\f"
-          else match
-          end
-        end
-      end
-      
-      # Raised when no reference can be found for a reference path.
-      class DereferenceError < StandardError
-      end
-    end
-  end
-end