tap 0.8.0 → 0.9.0

data/lib/tap/generator/generators/task/templates/test.erb

@@ -1,24 +1,23 @@
 require File.join(File.dirname(__FILE__), '<%= '../' * class_nesting_depth %>tap_test_helper.rb') 
 require '<%= class_path.empty? ? file_name : File.join(class_path, file_name) %>'
 
-class <%= class_name_without_nesting %>Test < Test::Unit::TestCase
+class <%= class_name %>Test < Test::Unit::TestCase
   acts_as_tap_test 
   
   def test_<%= file_name %>
-    t = <%= class_name %>.new nil, :label => 'key'
+    t = <%= class_name %>.new nil, :key => 'value'
     
     # specify application options
-    with_options(:quiet => true) do	
+    with_options(:quiet => true, :debug => true) do  
       
       # run the task with some inputs
-      app.run(t, "one", "two")
-			
-			# check the configuration and outputs
-      assert_equal({:label => 'key'}, t.config)
-      assert_outputs(t => [
-        "key: one was processed", 
-        "key: two was processed"])
-    
+      t.enq("one")
+      app.run
+      
+      # check the configuration and outputs
+      assert_equal({:key  => 'value'}, t.config)
+      assert_audit_equal ExpAudit[[nil, "one"], [t, "one was processed with value"]], app._results(t).first
+
     end
   end
   

data/lib/tap/generator/generators/workflow/templates/task.erb

@@ -9,7 +9,7 @@ class <%= class_name_without_nesting %> < Tap::Workflow
   def workflow 
     # Define the workflow entry and exit points,
     # as well as the workflow logic.
-    self.entry_point = Task.new
+    self.entry_point = Tap::Task.new
       
     # app.sequence(entry_point, 'another/task')
   end

data/lib/tap/generator/generators/workflow/templates/test.erb

@@ -1,7 +1,7 @@
 require File.join(File.dirname(__FILE__), '<%= '../' * class_nesting_depth %>tap_test_helper.rb') 
 require '<%= class_path.empty? ? file_name : File.join(class_path, file_name) %>'
 
-class <%= class_name_without_nesting %>Test < Test::Unit::TestCase
+class <%= class_name %>Test < Test::Unit::TestCase
   acts_as_tap_test 
   
 end

data/lib/tap/patches/rake/rake_test_loader.rb

@@ -0,0 +1,8 @@
+# this is the same code as in rake/rake_test_loader.rb
+# except it duplicates ARGV before iterating over it.
+#
+# This prevents an error in Ruby 1.9 when one of the 
+# loaded files attempts to modify ARGV.  In that case
+# you get an error like: 'can't modify array during 
+# iteration (RuntimeError)'
+ARGV.dup.each { |f| load f unless f =~ /^-/  }

data/lib/tap/patches/rake/testtask.rb

@@ -0,0 +1,55 @@
+# NO idea why this prevents an error with @ruby_opts=nil,
+# or even how @ruby_opts could be nil, on ruby 1.9 with
+# rake test and tdoc.  It does, though.
+require 'pp'
+
+module Rake # :nodoc:
+
+  class TestTask < TaskLib # :nodoc:
+    
+    # Patch for TestTask#define in 'rake\testtask.rb'
+    #
+    # This patch lets you specify Windows-style paths in lib 
+    # (ie with spaces and slashes) and to do something like:
+    #
+    #   Rake::TestTask.new(:test) do |t|
+    #     t.libs = $:  << 'lib'
+    #   end
+    #
+    # Using this patch you can specify additional load paths 
+    # for the test from the command line using --lib-dir
+    #
+    def define
+      lib_opt = @libs.collect {|f| "-I\"#{File.expand_path(f)}\""}.join(' ')
+      desc "Run tests" + (@name==:test ? "" : " for #{@name}")
+      task @name do
+        run_code = ''
+        RakeFileUtils.verbose(@verbose) do
+          run_code =
+            case @loader
+            when :direct
+              "-e 'ARGV.each{|f| load f}'"
+            when :testrb
+              "-S testrb #{fix}"
+            when :rake
+              rake_loader
+            end
+          @ruby_opts.unshift(lib_opt)
+          @ruby_opts.unshift( "-w" ) if @warning
+          ruby @ruby_opts.join(" ") +
+            " \"#{run_code}\" " +
+            file_list.collect { |fn| "\"#{fn}\"" }.join(' ') +
+            " #{option_list}"
+        end
+      end
+      self
+    end
+    
+    # Loads in the patched rake_test_loader to avoid the ARGV 
+    # modification error, which arises within TDoc.
+    def rake_loader # :nodoc:
+      File.expand_path(File.join(File.dirname(__FILE__), 'rake_test_loader.rb'))
+    end
+  end
+  
+end

data/lib/tap/patches/ruby19/backtrace_filter.rb

@@ -0,0 +1,51 @@
+module Test
+  module Unit
+    module Util # :nodoc:
+      module BacktraceFilter # :nodoc:
+        
+        if method_defined?(:filter_backtrace)
+          alias :tap_original_filter_backtrace :filter_backtrace
+        end
+        
+        # This is a slightly-modified version of the default BacktraceFilter
+        # provided in the Ruby 1.9 distribution.  It solves the issue documented
+        # below, and hopefully will not be necessary when Ruby 1.9 is stable.
+        #
+        def filter_backtrace(backtrace, prefix=nil)
+          return ["No backtrace"] unless(backtrace)
+          split_p = if(prefix)
+            prefix.split(TESTUNIT_FILE_SEPARATORS)
+          else
+            TESTUNIT_PREFIX
+          end
+          match = proc do |e|
+            split_e = e.split(TESTUNIT_FILE_SEPARATORS)[0, split_p.size]
+            next false unless(split_e[0..-2] == split_p[0..-2])
+            split_e[-1].sub(TESTUNIT_RB_FILE, '') == split_p[-1]
+          end
+          
+          # The Ruby 1.9 issue is that sometimes backtrace is a String
+          # and String is no longer Enumerable (hence it doesn't respond
+          # respond to detect).  Arrayify to solve.
+          backtrace = [backtrace] unless backtrace.kind_of?(Array)
+          
+          return backtrace unless(backtrace.detect(&match))
+          found_prefix = false
+          new_backtrace = backtrace.reverse.reject do |e|
+            if(match[e])
+              found_prefix = true
+              true
+            elsif(found_prefix)
+              false
+            else
+              true
+            end
+          end.reverse
+          new_backtrace = (new_backtrace.empty? ? backtrace : new_backtrace)
+          new_backtrace = new_backtrace.reject(&match)
+          new_backtrace.empty? ? backtrace : new_backtrace
+        end
+      end
+    end
+  end
+end

data/lib/tap/patches/ruby19/parsedate.rb

@@ -0,0 +1,16 @@
+require 'date/format'
+
+# Taken directly from the Ruby 1.8.6 standard library.  Ruby 1.9 has apparently
+# eliminated this class, but it is currently (2008-02-08) required by ActiveSupport.
+#
+# Making this file available to ActiveSupport allows testing under Ruby 1.9,
+# but this patch should be unnecessary when ActiveSupport upgrades and becomes
+# compatible with Ruby 1.9
+module ParseDate # :nodoc:
+  def parsedate(str, comp=false)
+    Date._parse(str, comp).
+      values_at(:year, :mon, :mday, :hour, :min, :sec, :zone, :wday)
+  end
+
+  module_function :parsedate
+end

data/lib/tap/root.rb

@@ -1,4 +1,5 @@
 require 'tap/support/versions'
+autoload(:FileUtils, 'fileutils')
 
 module Tap
   
@@ -10,14 +11,17 @@ module Tap
   #  r = Root.new '/root_dir', :input => 'in', :output => 'out'
   #  
   #  # work with directories
-  #  r[:in]                                      # => '/root_dir/in'
-  #  r[:out]                                     # => '/root_dir/out'
-  #  r[:implicit]                                # => '/root_dir/implicit'
+  #  r[:input]                                   # => '/root_dir/in'
+  #  r[:output]                                  # => '/root_dir/out'
+  #  r['implicit']                               # => '/root_dir/implicit'
+  #
+  #  # expanded paths are returned unchanged
+  #  r[File.expand_path('expanded')]             # => File.expand_path('expanded')
   #
   #  # work with filepaths
-  #  fp = r.filepath(:in, 'path/to/file.txt')    # => '/root_dir/in/path/to/file.txt'
-  #  r.relative_filepath(:in, fp)                # => 'path/to/file.txt'
-  #  r.translate(fp, :in, :out)                  # => '/root_dir/out/path/to/file.txt'
+  #  fp = r.filepath(:input, 'path/to/file.txt') # => '/root_dir/in/path/to/file.txt'
+  #  r.relative_filepath(:input, fp)             # => 'path/to/file.txt'
+  #  r.translate(fp, :input, :output)            # => '/root_dir/out/path/to/file.txt'
   #  
   #  # version filepaths
   #  r.version('path/to/config.yml', 1.0)        # => 'path/to/config-1.0.yml'
@@ -29,50 +33,52 @@ module Tap
   #  r.filepath(:abs, "to", "file.txt")          # => '/absolute/path/to/file.txt'
   #
   # By default, Roots are initialized to the present working directory (Dir.pwd).
-  # As in the ':implicit' example, whenever Root needs to resolve an alias that is 
-  # not explicitly set, Root infers a path relative to the root directory.  
+  # As in the 'implicit' example, Root infers a path relative to the root directory
+  # whenever it needs to resolve an alias that is not explicitly set.  The only 
+  # exceptions to this are fully expanded paths.  These are returned unchanged.
   #
   # === Implementation Notes
   #
-  # Internally Root stores expanded paths for both subdirectories and absolute paths in a 
-  # hash, 'paths', for quick lookup using the da (directory alias) keys. Expanding paths 
-  # ensures they remain constant even when the present working directory (Dir.pwd) changes.
+  # Internally Root stores expanded paths all aliased paths in the 'paths' hash.  
+  # Expanding paths ensures they remain constant even when the present working 
+  # directory (Dir.pwd) changes.
   #
-  # Root keeps a separate hash mapping aliases to the subdirectory paths, 'directories'.  
-  # These relative filepaths allow reassignment of the expanded paths if and when the 
-  # root directory changes.  By contrast, there is no separate data structure storing the 
-  # absolute paths. An absolute path can be distinguished from a subdirectory path by 
-  # aliases present in 'paths' but not 'directories'.
+  # Root keeps a separate 'directories' hash mapping aliases to their subdirectory paths.  
+  # This hash allow reassignment if and when the root directory changes.  By contrast, 
+  # there is no separate data structure storing the absolute paths. An absolute path 
+  # thus has an alias in 'paths' but not 'directories', whereas subdirectory paths
+  # have aliases in both.
   #
   # These features may be important to note when subclassing Root:
   # - root and all filepaths in 'paths' are expanded
-  # - directory aliases and subdirectory paths are stored in 'directories'
+  # - subdirectory paths are stored in 'directories'
   # - absolute paths are present in 'paths' but not in 'directories'
   #
-  class Root  
+  class Root
+    # Regexp to match a windows-style root filepath.
+    WIN_ROOT_PATTERN = /^[A-z]:\//
+    
     class << self
       include Support::Versions
       
       # Returns the filepath of path relative to dir.  Both dir and path are
-      # expanded before the relative filepath is determined.  If strict=true 
-      # (the default), then relative_filepath raises an error if the path is 
-      # not relative to dir.  Otherwise, the expanded path will be returned.
+      # expanded before the relative filepath is determined.  An error is 
+      # raised if the path is not relative to dir.
       #
       #   Root.relative_filepath('dir', "dir/path/to/file.txt")  # => "path/to/file.txt"
       #
-      def relative_filepath(dir, path, strict=true)
-        dir = File.expand_path(dir)
-        expanded = File.expand_path(path)
+      def relative_filepath(dir, path, dir_string=Dir.pwd)
+        expanded_dir = File.expand_path(dir, dir_string)
+        expanded_path = File.expand_path(path, dir_string)
   
-        unless expanded[0...dir.length] == dir
-          raise "\n#{expanded}\nis not relative to:\n#{dir}" if strict
-          return expanded
+        unless expanded_path.index(expanded_dir) == 0
+          raise "\n#{expanded_path}\nis not relative to:\n#{expanded_dir}"
         end
       
         # use dir.length + 1 to remove a leading '/'.   If dir.length + 1 >= expanded.length 
         # as in: relative_filepath('/path', '/path') then the first arg returns nil, and an 
         # empty string is returned
-        expanded[(dir.length+1)..-1] || ""
+        expanded_path[( expanded_dir.chomp("/").length + 1)..-1] || ""
       end
     
       # Lists all unique paths matching the input glob patterns.  
@@ -94,14 +100,86 @@ module Tap
           results
         end.flatten.uniq
       end
+      
+      # Executes the block in the specified directory.  Makes the directory, if
+      # necessary when mkdir is specified.  Otherwise, indir raises an error 
+      # for non-existant directories, as well as non-directory inputs.
+      def indir(dir, mkdir=false)
+        unless File.directory?(dir)
+          if !File.exists?(dir) && mkdir
+            FileUtils.mkdir_p(dir)
+          else
+            raise "non a directory: #{dir}"
+          end
+        end
+
+        pwd = Dir.pwd
+        begin
+          Dir.chdir(dir)
+          yield
+        ensure
+          Dir.chdir(pwd)
+        end
+      end
+      
+      # The path root type indicating windows, *nix, or some unknown
+      # style of filepaths (:win, :nix, :unknown).
+      def path_root_type
+        @path_root_type ||= case
+        when RUBY_PLATFORM =~ /mswin/ && File.expand_path(".") =~ WIN_ROOT_PATTERN then :win 
+        when File.expand_path(".")[0] == ?/ then :nix
+        else :unknown
+        end
+      end
+      
+      # Returns true if the input path appears to be an expanded path,
+      # based on Root.path_root_type.  
+      #
+      # If root_type == :win returns true if the path matches 
+      # WIN_ROOT_PATTERN.
+      #
+      #   Root.expanded_path?('C:/path')  # => true
+      #   Root.expanded_path?('c:/path')  # => true
+      #   Root.expanded_path?('D:/path')  # => true
+      #   Root.expanded_path?('path')     # => false
+      #
+      # If root_type == :nix, then expanded? returns true if 
+      # the path begins with '/'.
+      #
+      #   Root.expanded_path?('/path')  # => true
+      #   Root.expanded_path?('path')   # => false
+      #
+      # Otherwise expanded_path? always returns nil.
+      def expanded_path?(path, root_type=path_root_type)
+        case root_type
+        when :win 
+          path =~ WIN_ROOT_PATTERN ? true : false
+        when :nix  
+          path[0] == ?/
+        else
+          nil
+        end
+      end
     end
   
     include Support::Versions
-    attr_reader :root, :directories, :paths
     
-    # Creates a new Root with the given root, directories, and absolute
-    # paths.  By default root is the current working directory and no
-    # directories or absolute paths are specified.  
+    # The root directory
+    attr_reader :root
+    
+    # A hash of (alias, relative path) pairs for aliased subdirectories
+    attr_reader :directories
+    
+    # A hash of (alias, expanded path) pairs for aliased subdirectories and absolute paths.
+    attr_reader :paths
+    
+    # The filesystem root, inferred from self.root
+    # (ex '/' on *nix or something like 'C:/' on Windows).
+    attr_reader :path_root
+    
+    # Creates a new Root with the given root directory, aliased directories
+    # and absolute paths.  By default root is the present working directory 
+    # and no aliased directories or absolute paths are specified.  
     def initialize(root=Dir.pwd, directories={}, absolute_paths={})
       assign_paths(root, directories, absolute_paths)
     end
@@ -112,13 +190,21 @@ module Tap
     end
   
     # Sets the directories to those provided.  'root' and :root are reserved  
-    # directory keys and cannot be set using this method (use root= instead).
+    # and cannot be set using this method (use root= instead).
+    #
+    #   r['alt']                               # => File.join(r.root, 'alt')
+    #   r.directories = {'alt' => 'dir'}
+    #   r['alt']                               # => File.join(r.root, 'dir')
     def directories=(dirs)
       assign_paths(root, dirs, absolute_paths)
     end
     
     # Sets the absolute paths to those provided. 'root' and :root are reserved  
     # directory keys and cannot be set using this method (use root= instead).
+    #
+    #   r['abs']                               # => File.join(r.root, 'abs')
+    #   r.absolute_paths = {'abs' => '/path/to/dir'}
+    #   r['abs']                               # => '/path/to/dir'
     def absolute_paths=(paths)
       assign_paths(root, directories, paths)
     end
@@ -132,9 +218,10 @@ module Tap
       abs_paths
     end
 
-    # Sets a directory alias (da) for the path relative to the root directory.  
-    # The root directory cannot be set with this method (use root= instead). 
-    # Absolute filepaths can be set using the second syntax.  
+    # Sets an alias for the subdirectory relative to the root directory.  
+    # The aliases 'root' and :root cannot be set with this method 
+    # (use root= instead).  Absolute filepaths can be set using the 
+    # second syntax.  
     #
     #  r = Root.new '/root_dir'
     #  r[:dir] = 'path/to/dir'
@@ -144,13 +231,14 @@ module Tap
     #  r[:abs]       # => '/abs/path/to/dir'
     # 
     #--
+    # Implementation Notes:
     # The syntax for setting an absolute filepath requires an odd use []=.  
     # In fact the method recieves the arguments (:dir, true, '/abs/path/to/dir') 
     # rather than (:dir, '/abs/path/to/dir', true), meaning that internally path 
     # and absolute are switched when setting an absolute filepath.
     #++
-    def []=(da, path, absolute=false)
-      raise ArgumentError, "The directory key '#{da}' is reserved." if da.to_s == 'root'
+    def []=(dir, path, absolute=false)
+      raise ArgumentError, "The directory key '#{dir}' is reserved." if dir.to_s == 'root'
   
       # switch the paths if absolute was provided
       unless absolute == false
@@ -158,42 +246,49 @@ module Tap
         path = absolute
         absolute = switch
       end
-       
+      
       case
       when path.nil? 
-        @directories.delete(da)
-        @paths.delete(da)
+        @directories.delete(dir)
+        @paths.delete(dir)
       when absolute
-        @directories.delete(da)
-        @paths[da] = File.expand_path(path)
+        @directories.delete(dir)
+        @paths[dir] = File.expand_path(path)
       else
-        @directories[da] = path
-        @paths[da] = File.expand_path(File.join(root, path))
-      end  
+        @directories[dir] = path
+        @paths[dir] = File.expand_path(File.join(root, path))
+      end 
     end
   
     # Returns the expanded path for the specified alias.  If the alias 
-    # has not been set, then the path is inferred to be 'root/da'.
+    # has not been set, then the path is inferred to be 'root/dir' unless
+    # the path is relative to path_root.  These paths are returned 
+    # directly.
     #
-    #  r = Root.new '/root_dir'
-    #  r[:dir] = 'path/to/dir'
-    #  r[:dir]       # => '/root_dir/path/to/dir'
+    #  r = Root.new '/root_dir', :dir => 'path/to/dir'
+    #  r[:dir]                 # => '/root_dir/path/to/dir'
     #
-    #  r[:unset] = nil
-    #  r[:unset]     # => '/root_dir/unset'
+    #  r.path_root             # => '/'
+    #  r['relative/path']      # => '/root_dir/relative/path'
+    #  r['/expanded/path']     # => '/expanded/path'
     #
-    def [](da)
-      self.paths[da] || File.expand_path(File.join(root, da.to_s))
+    def [](dir)
+      path = self.paths[dir] 
+      return path unless path == nil
+      
+      dir = dir.to_s 
+      Root.expanded_path?(dir) ? dir : File.expand_path(File.join(root, dir))
     end
     
     # Constructs expanded filepaths relative to the path of the specified alias. 
-    def filepath(da, *filename)
-      File.expand_path(File.join(self[da], *filename))
+    def filepath(dir, *filename)
+      # TODO - consider filename.compact so nils will not raise errors
+      File.expand_path(File.join(self[dir], *filename))
     end
   
     # Retrieves the filepath relative to the path of the specified alias.  
-    def relative_filepath(da, filepath, strict=true)
-      Root.relative_filepath(self[da], filepath, strict)
+    def relative_filepath(dir, filepath)
+      Root.relative_filepath(self[dir], filepath)
     end
   
     # Generates a target filepath translated from the aliased input dir to 
@@ -202,23 +297,28 @@ module Tap
     # 
     #  fp = r.filepath(:in, 'path/to/file.txt')    # => '/root_dir/in/path/to/file.txt'
     #  r.translate(fp, :in, :out)                  # => '/root_dir/out/path/to/file.txt'
-    def translate(filepath, input_da, output_da)
-      filepath(output_da, relative_filepath(input_da, filepath))
+    def translate(filepath, input_dir, output_dir)
+      filepath(output_dir, relative_filepath(input_dir, filepath))
     end
   
     # Lists all files in the aliased dir matching the input patterns.  Patterns 
     # should be valid inputs for +Dir.glob+.  If no patterns are specified, lists 
     # all files/folders matching '**/*'.
-    def glob(da, *patterns)
+    def glob(dir, *patterns)
       patterns << "**/*" if patterns.empty?
-      patterns.collect! {|pattern| filepath(da, pattern)}
+      patterns.collect! {|pattern| filepath(dir, pattern)}
       Root.glob(*patterns)
     end
   
     # Lists all versions of filename in the aliased dir matching the version patterns.
     # If no patterns are specified, then all versions of filename will be returned.
-    def vglob(da, filename, *vpatterns)
-      Root.vglob(filepath(da, filename), *vpatterns)
+    def vglob(dir, filename, *vpatterns)
+      Root.vglob(filepath(dir, filename), *vpatterns)
+    end
+    
+    # Executes the provided block in the specified directory using Root.indir.
+    def indir(dir, mkdir=false)
+      Root.indir(self[dir], mkdir) { yield }
     end
     
     private
@@ -228,9 +328,14 @@ module Tap
       @root = File.expand_path(root)
       @directories = {}
       @paths = {'root' => @root, :root => @root}
-      
-      directories.each_pair {|da, path| self[da] = path }
-      absolute_paths.each_pair {|da, path| self[da, true] = path }
+
+      @path_root = File.dirname(@root)
+      while @path_root != (parent = File.dirname(@path_root))
+        @path_root = parent 
+      end
+    
+      directories.each_pair {|dir, path| self[dir] = path }
+      absolute_paths.each_pair {|dir, path| self[dir, true] = path }
     end  
 
   end