tap-test 0.1.0

data/lib/tap/test/utils.rb

@@ -0,0 +1,160 @@
+require 'tap/root'
+require 'fileutils'
+require 'tempfile'
+require 'tap/support/templater'
+
+module Tap
+
+  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::Utils.relative_path(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
+      
+      # Raised when no reference can be found for a reference path.
+      class DereferenceError < StandardError
+      end
+    end
+  end
+end

data/lib/tap/test.rb

@@ -0,0 +1,74 @@
+require 'tap/root'
+
+module Tap
+  
+  # Tap::Test provides several convenience methods for including and
+  # setting up Tap::Test modules.  The manual use of this module looks
+  # like this: 
+  #
+  #   class SampleTest < Test::Unit::TestCase
+  #     extend Tap::Test
+  #     acts_as_tap_test
+  #   end
+  #
+  # The 'tap/test/unit' file performs this setup for Test::Unit
+  # (ruby < 1.9) and Mini::Test (ruby >= 1.9); simply require it and
+  # call the setup methods as necessary.
+  #
+  module Test
+    autoload(:SubsetTest, 'tap/test/subset_test')
+    autoload(:FileTest, 'tap/test/file_test')
+    autoload(:ShellTest, 'tap/test/shell_test')
+    autoload(:TapTest, 'tap/test/tap_test')
+    autoload(:Utils, 'tap/test/utils')
+    
+    # Includes SubsetTest in the calling class.
+    def acts_as_subset_test
+      include Tap::Test::SubsetTest
+    end
+  
+    # Includes FileTest in the calling class and instantiating class_test_root
+    # (a Tap::Root).  Options may be used to configure the class_test_root.  
+    #
+    # 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
+      self.class_test_root = Tap::Root.new(options)
+    end
+    
+    # Includes ShellTest in the calling class.  Options are set as the default
+    # sh_test_options.
+    def acts_as_shell_test(options=nil)
+      include Tap::Test::ShellTest
+      self.sh_test_options = options
+    end
+    
+    # Includes TapTest in the calling class and calls acts_as_file_test with
+    # the options.
+    def acts_as_tap_test(options={})
+      options[:root] ||= test_root_dir
+      acts_as_file_test(options)
+      include Tap::Test::TapTest
+    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

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: tap-test
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Simon Chiang
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-25 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: tap
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.17.0
+    version: 
+description: 
+email: simon.a.chiang@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History
+- README
+- MIT-LICENSE
+files: 
+- lib/tap/test.rb
+- lib/tap/test/file_test.rb
+- lib/tap/test/file_test/class_methods.rb
+- lib/tap/test/shell_test.rb
+- lib/tap/test/shell_test/class_methods.rb
+- lib/tap/test/subset_test.rb
+- lib/tap/test/subset_test/class_methods.rb
+- lib/tap/test/tap_test.rb
+- lib/tap/test/unit.rb
+- lib/tap/test/utils.rb
+- tap.yml
+- History
+- README
+- MIT-LICENSE
+has_rdoc: true
+homepage: http://tap.rubyforge.org/tap-test/
+post_install_message: 
+rdoc_options: 
+- --main
+- README
+- -S
+- -N
+- --title
+- Tap-Test
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: tap
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: Test modules for Tap
+test_files: []
+