tap 0.7.9 → 0.8.0

data/test/check/binding_eval.rb

@@ -0,0 +1,23 @@
+# this checks to see that you can unset and reset 
+# constants and retain the functionality of the
+# constant.
+
+module TestMod
+  CONST = 1
+  
+  module_function
+  
+  def function
+    puts "in function"
+  end
+end
+
+class Object
+  old_ruby_token = remove_const(:TestMod)
+  const_set(:NewName, old_ruby_token )
+end
+
+puts NewName::CONST
+puts NewName.function
+
+puts "done"

data/test/check/define_method_check.rb

@@ -0,0 +1,22 @@
+require 'test/unit'
+
+class ClassConfigurationTest < Test::Unit::TestCase
+  class A
+    class << self
+      def define_class_defined_method
+        define_method('class_defined_method') do
+          self
+        end
+      end
+    end
+    
+    define_class_defined_method
+  end
+
+  def test_self_in_define_method
+    a = A.new
+    
+    assert a.respond_to?(:class_defined_method)
+    assert_equal a, a.class_defined_method
+  end
+end

data/test/check/dependencies_check.rb

@@ -0,0 +1,175 @@
+require 'active_support'
+require 'fileutils'
+require 'test/unit'
+
+class DependenciesCheck < Test::Unit::TestCase
+  
+  def teardown
+    FileUtils.rm_r(dep_dir)
+  end
+  
+  def dep_dir
+    File.join( File.dirname(__FILE__), "dependencies" )
+  end
+  
+  #
+  # make files
+  #
+  
+  def filepath(class_name)
+    File.join(dep_dir, class_name.underscore + ".rb")
+  end
+  
+  def make_file(class_name, content)
+    path = filepath(class_name)
+    FileUtils.mkdir(File.dirname(path)) unless File.exists?(File.dirname(path))
+    File.open(path, "w") do |file|
+      file << content
+    end
+    class_name.underscore
+  end
+  
+  def make_module_file(class_name)
+    make_file class_name, %Q{
+module #{class_name.camelize}
+end}
+  end
+  
+  def make_unloadable_file(class_name)
+    make_file class_name, %Q{
+module #{class_name.camelize}
+  unloadable
+end}
+  end
+  
+  #
+  # dependencies check
+  #
+  
+  def test_dependencies
+    pre_load = make_module_file "PreLoad"
+    pre_load_unloadable = make_unloadable_file "PreLoadUnloadable"
+    pre_loader = make_file("PreLoader", "require 'pre_load_required'\nrequire 'pre_load_required_unloadable'")
+    pre_load_required = make_module_file "PreLoadRequired"
+    pre_load_required_unloadable = make_unloadable_file "PreLoadRequiredUnloadable"
+    pre_load_consts = ["PreLoad", "PreLoadUnloadable", "PreLoadRequired", "PreLoadRequiredUnloadable"]
+    
+    post_load = make_module_file "PostLoad"
+    post_load_unloadable = make_unloadable_file "PostLoadUnloadable"
+    post_loader = make_file("PostLoader", "require 'post_load_required'\nrequire 'post_load_required_unloadable'")
+    post_load_required = make_module_file "PostLoadRequired"
+    post_load_required_unloadable = make_unloadable_file "PostLoadRequiredUnloadable"
+    post_load_consts = ["PostLoad", "PostLoadUnloadable", "PostLoadRequired", "PostLoadRequiredUnloadable"]
+    
+    assert_equal 10, Dir.glob( File.join( dep_dir, "*") ).length
+    
+    # can't load if not on load path
+    assert_raise(MissingSourceFile) do
+      require pre_load
+    end
+    
+    $:.unshift dep_dir
+    assert_nothing_raised do
+      require pre_load
+      require pre_load_unloadable
+      require pre_loader
+    end
+    
+    pre_load_consts.each {|const| assert Object.const_defined?(const)}
+    post_load_consts.each {|const| assert !Object.const_defined?(const)}
+
+    # now set Dependencies to load from dep_dir
+    Dependencies.load_paths << dep_dir
+    
+    # PostLoad constants will be autoloaded as missing constants by Dependencies
+    assert PostLoad
+    assert PostLoadUnloadable
+    assert PostLoadRequired
+    assert PostLoadRequiredUnloadable
+    
+    pre_load_consts.each {|const| assert Object.const_defined?(const)}
+    post_load_consts.each {|const| assert Object.const_defined?(const)}
+    
+    # post load modules are cleared, and pre-unloadable modules.
+    # other modules are not cleared 
+    Dependencies.clear
+    
+    ["PreLoad", "PreLoadRequired"].each {|const| assert Object.const_defined?(const)}
+    ["PreLoadUnloadable", "PreLoadRequiredUnloadable"].each {|const| assert !Object.const_defined?(const)}
+    post_load_consts.each {|const| assert !Object.const_defined?(const)}
+
+    # calling the missing modules reloads them
+    assert PreLoadUnloadable
+    assert PreLoadRequiredUnloadable
+    
+    assert PostLoad
+    assert PostLoadUnloadable
+    assert PostLoadRequired
+    assert PostLoadRequiredUnloadable
+    
+    pre_load_consts.each {|const| assert Object.const_defined?(const)}
+    post_load_consts.each {|const| assert Object.const_defined?(const)}
+    
+    # As before, post load modules should be cleared, and pre-unloadable modules
+    Dependencies.clear
+    
+    ["PreLoad", "PreLoadRequired"].each {|const| assert Object.const_defined?(const)}
+    ["PreLoadUnloadable", "PreLoadRequiredUnloadable"].each {|const| assert !Object.const_defined?(const)}
+    post_load_consts.each {|const| assert !Object.const_defined?(const)}
+    
+    # requiring files will NOT restore pre-loads by themselves... 
+    # but it will restore post load requires, because they haven't 
+    # been required yet
+    assert_nothing_raised do
+      require pre_load
+      require pre_load_unloadable
+      require pre_loader
+      
+      require post_load
+      require post_load_unloadable
+      require post_loader
+    end
+    
+    ["PreLoad", "PreLoadRequired"].each {|const| assert Object.const_defined?(const)}
+    ["PreLoadUnloadable", "PreLoadRequiredUnloadable"].each {|const| assert !Object.const_defined?(const)}
+    post_load_consts.each {|const| assert Object.const_defined?(const)}
+    
+    # Now, ONLY unloadable modules will be cleared -- the others were loaded
+    # using require, and NOT Dependencies autoloading
+    Dependencies.clear
+    
+    ["PreLoad", "PreLoadRequired"].each {|const| assert Object.const_defined?(const)}
+    ["PreLoadUnloadable", "PreLoadRequiredUnloadable"].each {|const| assert !Object.const_defined?(const)}
+    ["PostLoad", "PostLoadRequired"].each {|const| assert Object.const_defined?(const)}
+    ["PostLoadUnloadable", "PostLoadRequiredUnloadable"].each {|const| assert !Object.const_defined?(const)}
+    
+    # Now, requiring files will NOT restore any modules because 
+    # the files have already been required
+    assert_nothing_raised do
+      require pre_load
+      require pre_load_unloadable
+      require pre_loader
+      
+      require post_load
+      require post_load_unloadable
+      require post_loader
+    end
+    
+    ["PreLoad", "PreLoadRequired"].each {|const| assert Object.const_defined?(const)}
+    ["PreLoadUnloadable", "PreLoadRequiredUnloadable"].each {|const| assert !Object.const_defined?(const)}
+    ["PostLoad", "PostLoadRequired"].each {|const| assert Object.const_defined?(const)}
+    ["PostLoadUnloadable", "PostLoadRequiredUnloadable"].each {|const| assert !Object.const_defined?(const)}
+    
+    # but again... calling the missing modules reloads them, so even
+    # though the require doesn't work, you shold be good because you
+    # won't be accessing the module without calling it.  (right?)
+    assert PreLoadUnloadable
+    assert PreLoadRequiredUnloadable
+    assert PostLoadUnloadable
+    assert PostLoadRequiredUnloadable
+    
+    pre_load_consts.each {|const| assert Object.const_defined?(const)}
+    post_load_consts.each {|const| assert Object.const_defined?(const)}
+  end
+  
+end

data/test/check/inheritance_check.rb

@@ -0,0 +1,22 @@
+require 'active_support'
+require 'test/unit'
+
+class ClassConfigurationTest < Test::Unit::TestCase
+  class A
+    write_inheritable_attribute(:hash, {})  
+    class_inheritable_reader(:hash)
+  
+    self.hash[:one] = 'one'
+  end
+
+  class B < A
+    self.hash[:one] = 1
+  end
+
+  def test_inheritance
+    assert_not_equal A.hash, B.hash
+    
+    assert_equal 'one', A.hash[:one]
+    assert_equal 1, B.hash[:one]
+  end
+end

data/test/file_task_test.rb

@@ -21,20 +21,134 @@ class FileTaskTest < Test::Unit::TestCase
   end
   
   def test_touch_file
-    non_existant_file = infer_filepath(:output, "non_existant_file.txt")
+    non_existant_file = method_filepath(:output, "non_existant_file.txt")
     assert !File.exists?(non_existant_file)
     touch_file(non_existant_file)
     assert File.exists?(non_existant_file)
     assert File.file?(non_existant_file)
     assert_equal "", File.read(non_existant_file)
     
-    non_existant_file = infer_filepath(:output, "non_existant_file2.txt")
+    non_existant_file = method_filepath(:output, "non_existant_file2.txt")
     assert !File.exists?(non_existant_file)
     touch_file(non_existant_file, "content")
     assert File.exists?(non_existant_file)
     assert File.file?(non_existant_file)
     assert_equal "content", File.read(non_existant_file)
   end
+  
+  #
+  # doc tests
+  #
+  
+  def test_documentation
+    file_one = method_filepath(:output, "file.txt")
+    file_two = method_filepath(:output, "path/to/file.txt")
+    dir = method_filepath(:output, "some/dir")
+    FileUtils.mkdir_p( method_filepath(:output) )
+    
+    File.open(file_one, "w") {|f| f << "original content"}
+    t = Tap::FileTask.new do |task, inputs|
+      task.mkdir(dir)                      
+      task.prepare([file_one, file_two]) 
+      
+      File.open(file_one, "w") {|f| f << "new content"}
+      FileUtils.touch(file_two)
+  
+      raise "error!"
+    end
+  
+    begin
+      assert !File.exists?(dir)        
+      assert !File.exists?(file_two)        
+      t.execute(nil)
+      flunk "no error raised"
+    rescue
+      assert_equal "error!", $!.message
+      assert !File.exists?(dir)        
+      assert !File.exists?(file_two) 
+      assert_equal "original content", File.read(file_one)  
+    end
+  end
+
+  #
+  # open tests
+  #
+  
+  def test_open_doc
+    FileUtils.mkdir_p(method_filepath(:output))
+    one_filepath = method_filepath(:output, "one.txt")
+    two_filepath = method_filepath(:output, "two.txt")
+  
+    Tap::FileTask.open([one_filepath, two_filepath], "w") do |one, two|
+      one << "one"
+      two << "two"
+    end
+    
+    assert_equal "one", File.read(one_filepath)
+    assert_equal "two", File.read(two_filepath)
+    
+    #
+    filepath = method_filepath(:output, "file.txt")
+    Tap::FileTask.open(filepath, "w") do |array|
+      array.first << "content"
+    end
+  
+    assert_equal "content", File.read(filepath) 
+  end
+  
+  def test_open_opens_each_file
+    FileUtils.mkdir_p(method_filepath(:output))
+    
+    list = [0, 1].collect do |n| 
+      path = method_filepath(:output, "#{n}.txt")
+      File.open(path, "w") {|f| f << n.to_s}
+      path
+    end
+    
+    Tap::FileTask.open(list) do |files|
+      files.each_with_index do |file, n|
+        assert_equal File, file.class
+        assert_equal n.to_s, file.read
+      end
+    end    
+  end
+  
+  def test_open_opens_with_input_mode
+    FileUtils.mkdir_p(method_filepath(:output))
+    
+    list = [0, 1].collect do |n| 
+      path = method_filepath(:output, "#{n}.txt")
+      path
+    end
+    
+    Tap::FileTask.open(list, "w") do |files|
+      files.each_with_index do |file, n|
+        assert_equal File, file.class
+        file << n.to_s
+      end
+    end  
+    
+    list.each_with_index do |file, n|
+      assert_equal n.to_s, File.read(file)
+    end  
+  end
+  
+  def test_open_returns_open_files_if_no_block_is_given
+    FileUtils.mkdir_p(method_filepath(:output))
+    
+    list = [0, 1].collect do |n| 
+      path = method_filepath(:output, "#{n}.txt")
+      File.open(path, "w") {|f| f << n.to_s}
+      path
+    end
+    
+    open_files = Tap::FileTask.open(list)
+    open_files.each_with_index do |file, n|
+      assert_equal File, file.class
+      assert_equal n.to_s, file.read
+      file.close
+    end
+  end
 	
 	#
 	# dirname tests
@@ -72,54 +186,64 @@ class FileTaskTest < Test::Unit::TestCase
 	end
 	
 	#
-	# infer_filepath tests
+	# filepath tests
 	#
 
-	def test_infer_filepath_passes_app_dir_dirname_and_path_to_block
+	def test_filepath_passes_app_dir_dirname_and_path_to_block
 	  t.inference do |root, dir, path|
 	    [root, dir, path]
 	  end
 	  
 	  assert_equal "tap/file_task", t.dirname
-	  assert_equal [app[:dir], "tap/file_task", "path"], t.infer_filepath(:dir, "path")
+	  assert_equal [app[:dir], "tap/file_task", "path"], t.filepath(:dir, "path")
 	end
 	
-	def test_infer_filepath_with_multiple_paths
+	def test_filepath_with_multiple_paths
 	  t.inference do |root, dir, *paths|
 	    [root, dir, paths]
 	  end
-	  assert_equal [app[:dir], "tap/file_task", ["path", "to", "file"]], t.infer_filepath(:dir, "path", "to", "file")
+	  assert_equal [app[:dir], "tap/file_task", ["path", "to", "file"]], t.filepath(:dir, "path", "to", "file")
 	end
 	
-	def test_infer_filepath_with_multiple_paths_but_single_path_given
+	def test_filepath_with_multiple_paths_but_single_path_given
 	  t.inference do |root, dir, *paths|
 	    [root, dir, paths]
 	  end
-	  assert_equal [app[:dir], "tap/file_task", ["path"]], t.infer_filepath(:dir, "path")
+	  assert_equal [app[:dir], "tap/file_task", ["path"]], t.filepath(:dir, "path")
 	  
 	  t.inference(true) do |root, dir, path_a, path_b|
 	    [root, dir, path_a, path_b]
 	  end
-	  assert_equal [app[:dir], "tap/file_task", "path", nil], t.infer_filepath(:dir, "path")
+	  assert_equal [app[:dir], "tap/file_task", "path", nil], t.filepath(:dir, "path")
 	end
 	
-	def test_infer_filepath_with_single_path_but_multiple_paths_given
+	def test_filepath_with_single_path_but_multiple_paths_given
 	  t.inference do |root, dir, path|
 	    [root, dir, path]
 	  end
-	  assert_equal [app[:dir], "tap/file_task", "path"], t.infer_filepath(:dir, "path", "to", "file")
+	  assert_equal [app[:dir], "tap/file_task", "path"], t.filepath(:dir, "path", "to", "file")
 	end
 	
-	def test_infer_filepath_constructs_path_using_app_filepath_when_inference_block_is_not_set
+	def test_filepath_constructs_path_using_app_filepath_when_inference_block_is_not_set
 	  assert_nil t.inference_block
 	  assert_equal(
 	    app.filepath(:dir, "tap/file_task", "path", "to", "file"),
-	    t.infer_filepath(:dir, "path", "to", "file"))
+	    t.filepath(:dir, "path", "to", "file"))
 	end
 
   #
   # backup_filepath test
   #
+  
+  def btest_backup_filepath_documentation
+  
+    t = FileTask.new("dir/name", :backup_dir => :backup, :backup_timestamp => "%Y%m%d")
+    t.app[:backup]                                 # => "/backup"
+    Date.today.to_s                                # => "2007-08-08"
+  
+    t.backup_filepath("path/to/folder/file.txt")   # => "/backup/file_20070808.txt"
+    t.backup_filepath("dir/name/folder/file.txt")  # => "/backup/folder/file_20070808.txt"
+  end
 
   def prepare_backup_filepath_with_output_and_timestamp
     timestamp_format = "%Y%m%d"
@@ -176,7 +300,8 @@ class FileTaskTest < Test::Unit::TestCase
       t.backup_filepath("path/to/file.txt"))
   end
   
-  def test_backup_filepath_does_not_mistake_files_as_folders_when_checking_if_input_is_relative_to_dirname
+  # the SciTE text editor whines and fails for 'words' this long... hence the last part of the test name is commented out
+  def test_backup_filepath_does_not_mistake_files_as_folders#_when_checking_if_input_is_relative_to_dirname
     timestamp = prepare_backup_filepath_with_output_and_timestamp
 
     t.inference do |root, dir, path|
@@ -188,71 +313,13 @@ class FileTaskTest < Test::Unit::TestCase
       t.backup_filepath("folder/tap/file_task.txt"))
   end
   
-  #
-  # open tests
-  #
-  
-  def test_open_opens_each_file
-    FileUtils.mkdir_p(infer_filepath(:output))
-    
-    list = [0, 1].collect do |n| 
-      path = infer_filepath(:output, "#{n}.txt")
-      File.open(path, "w") {|f| f << n.to_s}
-      path
-    end
-    
-    t.open(list) do |files|
-      files.each_with_index do |file, n|
-        assert_equal File, file.class
-        assert_equal n.to_s, file.read
-      end
-    end    
-  end
-  
-  def test_open_opens_with_input_mode
-    FileUtils.mkdir_p(infer_filepath(:output))
-    
-    list = [0, 1].collect do |n| 
-      path = infer_filepath(:output, "#{n}.txt")
-      path
-    end
-    
-    t.open(list, "w") do |files|
-      files.each_with_index do |file, n|
-        assert_equal File, file.class
-        file << n.to_s
-      end
-    end  
-    
-    list.each_with_index do |file, n|
-      assert_equal n.to_s, File.read(file)
-    end  
-  end
-  
-  def test_open_returns_open_files_if_no_block_is_given
-    FileUtils.mkdir_p(infer_filepath(:output))
-    
-    list = [0, 1].collect do |n| 
-      path = infer_filepath(:output, "#{n}.txt")
-      File.open(path, "w") {|f| f << n.to_s}
-      path
-    end
-    
-    open_files = t.open(list)
-    open_files.each_with_index do |file, n|
-      assert_equal File, file.class
-      assert_equal n.to_s, file.read
-      file.close
-    end
-  end
-  
 	#
 	# uptodate tests
 	#
 
 	def uptodate_test_setup(output_str='')
-		of1 = ifs.filepath(:root, 'old_file_one.txt')
-		of2 = ifs.filepath(:root, 'old_file_two.txt')
+		of1 = trs.filepath(:root, 'old_file_one.txt')
+		of2 = trs.filepath(:root, 'old_file_two.txt')
 		
 		nf1 = tempfile('new_file_one.txt')
 		File.open(nf1, "w") {|file| file << output_str}
@@ -277,7 +344,7 @@ class FileTaskTest < Test::Unit::TestCase
 	def test_uptodate
 		of1, of2, nf1, nf2 = uptodate_test_setup
 		
-		non = ifs.filepath(:output, "non_existant_file.txt")
+		non = trs.filepath(:output, "non_existant_file.txt")
     assert !File.exists?(non)
     
     assert t.uptodate?(nf1)
@@ -300,7 +367,7 @@ class FileTaskTest < Test::Unit::TestCase
     
     of1, of2, nf1, nf2 = uptodate_test_setup
 		
-		non = ifs.filepath(:output, "non_existant_file.txt")
+		non = trs.filepath(:output, "non_existant_file.txt")
     assert !File.exists?(non)
     
     assert t.uptodate?(nf1)
@@ -319,7 +386,7 @@ class FileTaskTest < Test::Unit::TestCase
   end
   
   def test_uptodate_with_out_of_date_config_file
-    filepath = ifs.filepath(:config, "configured-0.1.yml")
+    filepath = trs.filepath(:config, "configured-0.1.yml")
     assert !File.exists?(filepath)
     begin
       of1, of2, nf1, nf2 = uptodate_test_setup
@@ -350,9 +417,32 @@ class FileTaskTest < Test::Unit::TestCase
 	# backup tests
 	#
 	
+	def test_backup_restore_doc
+	  FileUtils.mkdir_p(method_filepath(:output))
+	  FileUtils.mkdir_p(method_filepath(:output))
+	  
+	  file = method_filepath(:output, "file.txt")
+    File.open(file, "w") {|f| f << "file content"}
+    
+    t = Tap::FileTask.new
+    t.app[:backup, true] = method_filepath(:backup)
+    backed_up_file = t.backup(file).first   
+
+    assert !File.exists?(file)                     
+    assert File.exists?(backed_up_file)            
+    assert_equal "file content", File.read(backed_up_file)         
+    
+    File.open(file, "w") {|f| f << "new content"}
+    t.restore(file)
+    
+    assert File.exists?(file)                
+    assert !File.exists?(backed_up_file)      
+    assert_equal "file content", File.read(file)                 
+	end
+	
 	def backup_test_setup
-	  existing_file = infer_filepath(:output, "file.txt")
-	  backup_file = infer_filepath(:output, "backup.txt")
+	  existing_file = method_filepath(:output, "file.txt")
+	  backup_file = method_filepath(:output, "backup.txt")
 	  
     touch_file(existing_file, "existing content")
     # assure backup_filepath will return backup_file 
@@ -371,34 +461,39 @@ class FileTaskTest < Test::Unit::TestCase
     assert_equal backup_file, t.backup_filepath(existing_file)
 	end
 	
-	def test_backup_copies_filepath_to_backup_filepath
+	def test_backup_moves_filepath_to_backup_filepath
     existing_file, backup_file = backup_test_setup
     
     t.backup(existing_file)
     
-    assert File.exists?(existing_file)
+    assert !File.exists?(existing_file)
     assert File.exists?(backup_file)
-    assert FileUtils.compare_file(existing_file, backup_file)
+    assert_equal "existing content", File.read(backup_file)
 	end
 	
-	def test_backup_moves_filepath_to_backup_filepath_unless_copy_is_true
+	def test_backup_copies_filepath_to_backup_filepath_if_backup_using_copy_is_true
 	  existing_file, backup_file = backup_test_setup
     
-    t.backup(existing_file, false)
+    t.backup(existing_file, true)
     
-    assert !File.exists?(existing_file)
+    assert File.exists?(existing_file)
     assert File.exists?(backup_file)
-    assert_equal "existing content", File.read(backup_file)
+    assert FileUtils.compare_file(existing_file, backup_file)
 	end
 	
 	def test_backup_registers_expanded_filepath_and_backup_filepath_in_backed_up_files
 	  existing_file, backup_file = backup_test_setup
 	  
-	  assert_not_equal existing_file, File.expand_path(existing_file)
+	  relative_filepath = Tap::Root.relative_filepath(Dir.pwd, existing_file)
+	  assert_not_equal existing_file, relative_filepath
+	  
+	  assert_equal existing_file, File.expand_path(existing_file)
+	  assert_equal existing_file, File.expand_path(relative_filepath)
+	  assert_equal backup_file, File.expand_path(backup_file)
 	  
     assert_equal({}, t.backed_up_files)
-    t.backup(existing_file)
-    assert_equal({File.expand_path(existing_file) => File.expand_path(backup_file)}, t.backed_up_files)
+    t.backup(relative_filepath)
+    assert_equal({existing_file => backup_file}, t.backed_up_files)
 	end
 	
   def test_backup_does_nothing_if_filepath_does_not_exist
@@ -417,10 +512,10 @@ class FileTaskTest < Test::Unit::TestCase
   end
   
   def test_backup_acts_on_list_and_returns_backup_files
-	  existing_file0 = infer_filepath(:output, "file0.txt")
-	  existing_file1 = infer_filepath(:output, "file1.txt")
-	  backup_file0 = infer_filepath(:output, "backup0.txt")
-	  backup_file1 = infer_filepath(:output, "backup1.txt")
+	  existing_file0 = method_filepath(:output, "file0.txt")
+	  existing_file1 = method_filepath(:output, "file1.txt")
+	  backup_file0 = method_filepath(:output, "backup0.txt")
+	  backup_file1 = method_filepath(:output, "backup1.txt")
 	  
     touch_file(existing_file0)
     touch_file(existing_file1)
@@ -439,7 +534,7 @@ class FileTaskTest < Test::Unit::TestCase
   
   def test_backup_raises_error_if_backup_for_file_already_exists
     existing_file, backup_file = backup_test_setup
-    t.backup(existing_file)
+    t.backup(existing_file, true)
     
     assert_raise(RuntimeError) { t.backup(existing_file) }
   end
@@ -449,8 +544,8 @@ class FileTaskTest < Test::Unit::TestCase
   #
   
   def test_restore_restores_backed_up_file_to_original_location_as_listed_in_backed_up_files
-    original_file = File.expand_path(infer_filepath(:output, 'original/file.txt'))
-    backup_file = File.expand_path(infer_filepath(:output, 'backup/file.txt'))
+    original_file = File.expand_path(method_filepath(:output, 'original/file.txt'))
+    backup_file = File.expand_path(method_filepath(:output, 'backup/file.txt'))
 
     FileUtils.mkdir_p( File.dirname(original_file) )
     touch_file(backup_file)
@@ -467,8 +562,8 @@ class FileTaskTest < Test::Unit::TestCase
   end
   
   def test_restore_creates_dirs_as_needed_to_restore_file
-    original_file = File.expand_path(infer_filepath(:output, 'original/file.txt'))
-    backup_file = File.expand_path(infer_filepath(:output, 'backup/file.txt'))
+    original_file = File.expand_path(method_filepath(:output, 'original/file.txt'))
+    backup_file = File.expand_path(method_filepath(:output, 'backup/file.txt'))
 
     touch_file(backup_file)
     
@@ -483,14 +578,16 @@ class FileTaskTest < Test::Unit::TestCase
     assert !File.exists?(backup_file)
   end
   
-  def test_restore_raises_error_if_the_input_file_is_not_backed_up
+  def test_restore_does_nothing_if_the_input_file_is_not_backed_up
+    assert !File.exists?("original_file")
     assert t.backed_up_files.empty?
-    assert_raise(RuntimeError) { t.restore("original_file") }
+    assert_equal [], t.restore("original_file")
+    assert !File.exists?("original_file")
   end
   
   def test_restore_removes_backup_dir_using_rmdir
-    original_file = File.expand_path(infer_filepath(:output, 'original/file.txt'))
-    backup_file = File.expand_path(infer_filepath(:output, 'backup/file.txt'))
+    original_file = File.expand_path(method_filepath(:output, 'original/file.txt'))
+    backup_file = File.expand_path(method_filepath(:output, 'backup/file.txt'))
     backup_dir = File.dirname(backup_file)
     
     t.mkdir(backup_file)
@@ -505,10 +602,10 @@ class FileTaskTest < Test::Unit::TestCase
   end
   
   def test_restore_acts_on_list_and_returns_restored_files
-	  existing_file0 = File.expand_path(infer_filepath(:output, "file0.txt"))
-	  existing_file1 = File.expand_path(infer_filepath(:output, "file1.txt"))
-	  backup_file0 = File.expand_path(infer_filepath(:output, "backup0.txt"))
-	  backup_file1 = File.expand_path(infer_filepath(:output, "backup1.txt"))
+	  existing_file0 = File.expand_path(method_filepath(:output, "file0.txt"))
+	  existing_file1 = File.expand_path(method_filepath(:output, "file1.txt"))
+	  backup_file0 = File.expand_path(method_filepath(:output, "backup0.txt"))
+	  backup_file1 = File.expand_path(method_filepath(:output, "backup1.txt"))
 	  
     touch_file(backup_file0)
     touch_file(backup_file1)
@@ -529,8 +626,34 @@ class FileTaskTest < Test::Unit::TestCase
 	# mkdir tests
 	#
 	
+	def test_mkdir_documentation
+	  dir_one = method_filepath(:output, "path/to/dir")
+	  dir_two = method_filepath(:output, "path/to/another")
+	  
+    t = Tap::FileTask.new do |task, inputs|
+      assert !File.exists?(method_filepath(:output, "path"))  
+  
+      task.mkdir(dir_one)             
+      assert File.exists?(dir_one)           
+  
+      FileUtils.mkdir(dir_two)   
+      assert File.exists?(dir_two)    
+  
+      raise "error!"
+    end
+  
+    begin
+      t.execute(nil)
+      flunk "no error raised"
+    rescue
+      assert_equal "error!", $!.message     
+      assert !File.exists?(dir_one)  
+      assert File.exists?(dir_two)    
+    end
+	end
+	
 	def test_mkdir_creates_dir_if_it_does_not_exist
-	  dir = infer_filepath(:output, 'path/to/non_existant_folder')
+	  dir = method_filepath(:output, 'path/to/non_existant_folder')
 	  FileUtils.mkdir_p(File.dirname(dir))
   	assert !File.exists?(dir)
   	
@@ -539,36 +662,37 @@ class FileTaskTest < Test::Unit::TestCase
 	end
 	
 	def test_mkdir_creates_parent_dirs_if_they_do_not_exist
-	  dir = infer_filepath(:output, 'path/to/non_existant_folder')
-  	assert !File.exists?(infer_filepath(:output))
+	  dir = method_filepath(:output, 'path/to/non_existant_folder')
+  	assert !File.exists?(method_filepath(:output))
   	
   	t.mkdir(dir)
   	assert File.exists?(dir)
 	end
 	
-	def test_mkdir_registers_expanded_dir_and_all_non_existing_parent_dirs_in_made_files
-	  dir = infer_filepath(:output, 'path/to/non_existant_folder')
-	  assert_equal [], t.made_files
-	  assert_not_equal dir, File.expand_path(dir)
+	def test_mkdir_registers_expanded_dir_and_all_non_existing_parent_dirs_in_added_files
+	  dir = method_filepath(:output, 'path/to/non_existant_folder')
+	  assert_equal [], t.added_files
 	  
-	  t.mkdir(dir)
+	  relative_dir = Tap::Root.relative_filepath(Dir.pwd, dir)
+	  assert_not_equal dir, relative_dir
+	  assert_equal dir, File.expand_path(relative_dir)
+	  
+	  t.mkdir(relative_dir)
 	  
 	  expected = [
-	    infer_root,
-	    infer_filepath(:output),
-	    infer_filepath(:output, 'path'),
-	    infer_filepath(:output, 'path/to'),
-	    infer_filepath(:output, 'path/to/non_existant_folder')
-	  ].collect do |dir|
-	    File.expand_path(dir)
-	  end
+	    method_root,
+	    method_filepath(:output),
+	    method_filepath(:output, 'path'),
+	    method_filepath(:output, 'path/to'),
+	    method_filepath(:output, 'path/to/non_existant_folder')
+	  ]
 	    
-	  assert_equal expected, t.made_files
+	  assert_equal expected, t.added_files
 	end
 	
 	def test_mkdir_acts_on_and_returns_list
-    dir = infer_filepath(:output, 'path')
-    another = infer_filepath(:output, 'another')
+    dir = method_filepath(:output, 'path')
+    another = method_filepath(:output, 'another')
     
     assert !File.exists?(dir)
     assert !File.exists?(another)
@@ -583,9 +707,26 @@ class FileTaskTest < Test::Unit::TestCase
   # rmdir tests
   #
   
+  def test_rmdir_documentation
+    dir_one = method_filepath(:output, 'path')
+    dir_two = method_filepath(:output, 'path/to/dir')
+    FileUtils.mkdir_p( method_filepath(:output) )
+    
+    t = Tap::FileTask.new
+    assert !File.exists?(dir_one)            
+    FileUtils.mkdir(dir_one)         
+  
+    t.mkdir(dir_two)           
+    assert File.exists?(dir_two)     
+  
+    t.rmdir(dir_two)                
+    assert File.exists?(dir_one)           
+    assert !File.exists?(method_filepath(:output, 'path/to'))    
+  end
+  
   def test_rmdir_removes_dir_if_made_by_the_task
-	  dir = infer_filepath(:output, 'path/to/non_existant_folder')
-	  existing_dir = infer_filepath(:output, 'path/to')
+	  dir = method_filepath(:output, 'path/to/non_existant_folder')
+	  existing_dir = method_filepath(:output, 'path/to')
 	  
 	  FileUtils.mkdir_p(existing_dir)
 	  assert File.exists?(existing_dir)
@@ -600,9 +741,9 @@ class FileTaskTest < Test::Unit::TestCase
 	end
 	
 	def test_rmdir_removes_parent_dirs_if_made_by_the_task
-	  dir = infer_filepath(:output, 'path/to/non/existant/folder')
-	  root_parent_dir = infer_filepath(:output, 'path/to')
-	  existing_dir = infer_filepath(:output, 'path')
+	  dir = method_filepath(:output, 'path/to/non/existant/folder')
+	  root_parent_dir = method_filepath(:output, 'path/to')
+	  existing_dir = method_filepath(:output, 'path')
 	  
 	  FileUtils.mkdir_p(existing_dir)
 	  assert File.exists?(existing_dir)
@@ -617,7 +758,7 @@ class FileTaskTest < Test::Unit::TestCase
 	end
 
   def test_rmdir_does_not_remove_if_dir_was_not_made_by_task
-	  dir = infer_filepath(:output, 'path/to/non_existant_folder')
+	  dir = method_filepath(:output, 'path/to/non_existant_folder')
 
 	  FileUtils.mkdir_p(dir)
     assert File.exists?(dir)
@@ -627,8 +768,8 @@ class FileTaskTest < Test::Unit::TestCase
 	end
 
 	def test_rmdir_does_not_remove_if_folder_is_not_empty
-	  dir = infer_filepath(:output, 'path/to/folder')
-	  not_empty_dir = infer_filepath(:output, 'path/to')
+	  dir = method_filepath(:output, 'path/to/folder')
+	  not_empty_dir = method_filepath(:output, 'path/to')
 
 	  t.mkdir(dir)
   	assert File.exists?(dir)
@@ -641,8 +782,8 @@ class FileTaskTest < Test::Unit::TestCase
 	end
 	
 	def test_rmdir_checks_for_hidden_files_as_well_as_regular_files
-	  dir = infer_filepath(:output, 'path/to/folder')
-	  not_empty_dir = infer_filepath(:output, 'path/to')
+	  dir = method_filepath(:output, 'path/to/folder')
+	  not_empty_dir = method_filepath(:output, 'path/to')
 
 	  t.mkdir(dir)
   	assert File.exists?(dir)
@@ -654,73 +795,93 @@ class FileTaskTest < Test::Unit::TestCase
   	assert !File.exists?(dir)
 	end
 
-	def test_rmdir_clears_made_files_of_removed_dirs
-	  dir = infer_filepath(:output, 'path/to/folder')
+	def test_rmdir_clears_added_files_of_removed_dirs
+	  dir = method_filepath(:output, 'path/to/folder')
 
-	  FileUtils.mkdir_p(infer_filepath(:output))
-	  assert_equal [], t.made_files
+	  FileUtils.mkdir_p(method_filepath(:output))
+	  assert_equal [], t.added_files
   
 	  t.mkdir(dir)
   	assert_equal [
-  	  File.expand_path(infer_filepath(:output, 'path')),
-  	  File.expand_path(infer_filepath(:output, 'path/to')),
-  	  File.expand_path(infer_filepath(:output, 'path/to/folder'))], t.made_files
+  	  File.expand_path(method_filepath(:output, 'path')),
+  	  File.expand_path(method_filepath(:output, 'path/to')),
+  	  File.expand_path(method_filepath(:output, 'path/to/folder'))], t.added_files
   	
   	# touch a file so the 'path' folder isn't removed
-  	touch_file infer_filepath(:output, 'path/file.txt')
+  	touch_file method_filepath(:output, 'path/file.txt')
   	
   	t.rmdir(dir)
   	assert_equal [
-  	  File.expand_path(infer_filepath(:output, 'path'))], t.made_files
+  	  File.expand_path(method_filepath(:output, 'path'))], t.added_files
 	end
 
 	def test_rmdir_acts_on_and_returns_expanded_list_of_removed_dirs
-    dir = infer_filepath(:output, 'path')
-    another = infer_filepath(:output, 'another')
-    not_removed = infer_filepath(:output, 'not')
-    removed = infer_filepath(:output, 'not/removed')
+    dir = method_filepath(:output, 'path')
+    another = method_filepath(:output, 'another')
+    not_removed = method_filepath(:output, 'not')
+    removed = method_filepath(:output, 'not/removed')
     
     t.mkdir([dir, another, not_removed, removed])
     # touch a file so the not_removed folder isn't removed
-  	touch_file infer_filepath(:output, 'not/file.txt')
+  	touch_file method_filepath(:output, 'not/file.txt')
   	
   	expected = [dir, another, removed].collect {|d| File.expand_path(d)}
     assert_equal expected, t.rmdir([dir, another, not_removed, removed])
   end
 
   #
-  # make tests
+  # prepare tests
   #
   
-  def test_make_acts_on_and_returns_list
-    filepath = "file.txt"
-    another = "another.txt"
-    assert_equal [filepath, another], t.make([filepath, another])
-  end
+  def test_prepare_documentation
+    file_one = method_filepath(:output, "file.txt")
+    file_two = method_filepath(:output, "path/to/file.txt")
+    FileUtils.mkdir_p( method_filepath(:output) )
+    
+    File.open(file_one, "w") {|f| f << "original content"}
+    t = Tap::FileTask.new do |task, inputs|
+      assert !File.exists?(method_filepath(:output, "path"))
   
-  def test_make_yields_list_if_block_given
-    was_in_make = false
-    t.make("file.txt") do |list|
-      was_in_make = true
-      assert_equal ["file.txt"], list
+      # backup... prepare parent dirs... prepare for restore     
+      task.prepare([file_one, file_two]) 
+  
+      File.open(file_one, "w") {|f| f << "new content"}
+      FileUtils.touch(file_two)
+  
+      raise "error!"
     end
-    assert was_in_make
+  
+    begin
+      t.execute(nil)
+      flunk "no error raised"
+    rescue
+      assert_equal "error!", $!.message
+      assert File.exists?(file_one)           
+      assert_equal "original content", File.read(file_one) 
+      assert !File.exists?(method_filepath(:output, "path"))   
+    end
+  end
+  
+  def test_prepare_acts_on_and_returns_list
+    filepath = "file.txt"
+    another = "another.txt"
+    assert_equal [filepath, another], t.prepare([filepath, another])
   end
   
-  def test_make_backs_up_existing_files_and_creates_non_existant_dirs
-    existing_file = infer_filepath(:output, "path/to/existing/file.txt")
-    non_existant_file = infer_filepath(:output, "path/to/non/existant/file.txt")
+  def test_prepare_backs_up_existing_files_and_creates_non_existant_dirs
+    existing_file = method_filepath(:output, "path/to/existing/file.txt")
+    non_existant_file = method_filepath(:output, "path/to/non/existant/file.txt")
     touch_file(existing_file, "existing content")
     
     # be sure inference leads files to an output dir, for cleanup
-    removal_path = infer_filepath(:output, 'removal')
+    removal_path = method_filepath(:output, 'removal')
     t.inference {|root, dir, path| removal_path}
 
     assert File.exists?(existing_file)
     assert !File.exists?(non_existant_file)
 
     files = [existing_file, non_existant_file]
-    t.make(files) 
+    t.prepare(files) 
     
     # check neither of the files exist at this point
     # and the parent dirs all exist
@@ -734,50 +895,68 @@ class FileTaskTest < Test::Unit::TestCase
     assert_equal "existing content", File.read(removal_path)
   end
   
-  def test_make_adds_list_to_made_files
-    existing_file = infer_filepath(:output, "path/to/existing/file.txt")
-    non_existant_file = infer_filepath(:output, "path/to/non/existant/file.txt")
+  def test_prepare_adds_list_to_added_files
+    existing_file = method_filepath(:output, "path/to/existing/file.txt")
+    non_existant_file = method_filepath(:output, "path/to/non/existant/file.txt")
     touch_file(existing_file)
     
     # be sure inference leads files to an output dir, for cleanup
-    removal_path = infer_filepath(:output, 'removal')
+    removal_path = method_filepath(:output, 'removal')
     t.inference {|root, dir, path| File.join(removal_path, path) }
 
-    assert_equal([], t.made_files)
+    assert_equal([], t.added_files)
     assert File.exists?(existing_file)
     assert !File.exists?(non_existant_file)
     assert !File.exists?(removal_path)
     
     files = [existing_file, non_existant_file]
-    t.make(files) 
+    t.prepare(files) 
     
 	  expected = [
 	    removal_path,  # added by backup of existing_file
-	    existing_file, # added by make
-	    infer_filepath(:output, 'path/to/non'), # added by mkdir
-	    infer_filepath(:output, 'path/to/non/existant'), # added by mkdir
-	    non_existant_file # added by make
+	    method_filepath(:output, 'path/to/non'), # added by mkdir
+	    method_filepath(:output, 'path/to/non/existant'), # added by mkdir
+	    existing_file, # added by prepare
+	    non_existant_file # added by prepare
 	  ].collect do |dir|
 	    File.expand_path(dir)
 	  end
 	  
-	  assert_equal expected, t.made_files
+	  assert_equal expected, t.added_files
   end
   
   #
   # rm tests
   #
   
+  def test_rm_documentation
+    dir = method_filepath(:output, 'path')
+    file = method_filepath(:output, 'path/to/file.txt')
+    FileUtils.mkdir_p( method_filepath(:output) )
+    
+    t = Tap::FileTask.new
+    assert !File.exists?(dir)            
+    FileUtils.mkdir(dir)         
+  
+    t.prepare(file)        
+    FileUtils.touch(file)   
+    assert File.exists?(file)     
+  
+    t.rm(file)                
+    assert File.exists?(dir)           
+    assert !File.exists?(method_filepath(:output, 'path/to'))    
+  end
+  
   def test_rm_removes_file_and_parent_dirs_if_made_by_the_task
-	  file = infer_filepath(:output, 'path/to/file.txt')
-	  parent_dir = infer_filepath(:output, 'path/to')
-	  existing_dir = infer_filepath(:output, 'path')
+	  file = method_filepath(:output, 'path/to/file.txt')
+	  parent_dir = method_filepath(:output, 'path/to')
+	  existing_dir = method_filepath(:output, 'path')
 	  FileUtils.mkdir_p existing_dir
 	  
 	  assert File.exists?(existing_dir)
 	  assert !File.exists?(file)
 	  
-	  t.make file
+	  t.prepare file
 	  touch_file(file)
 	  assert File.exists?(file)
 	  
@@ -788,15 +967,15 @@ class FileTaskTest < Test::Unit::TestCase
 	end
 	
 	def test_rm_removes_parent_dirs_even_if_file_does_not_exist
-	  file = infer_filepath(:output, 'path/to/file.txt')
-	  parent_dir = infer_filepath(:output, 'path/to')
-	  existing_dir = infer_filepath(:output, 'path')
+	  file = method_filepath(:output, 'path/to/file.txt')
+	  parent_dir = method_filepath(:output, 'path/to')
+	  existing_dir = method_filepath(:output, 'path')
 	  FileUtils.mkdir_p existing_dir
 	  
 	  assert File.exists?(existing_dir)
 	  assert !File.exists?(file)
 	  
-	  t.make file
+	  t.prepare file
 	  assert !File.exists?(file)
 	  
 	  t.rm(file)
@@ -805,7 +984,7 @@ class FileTaskTest < Test::Unit::TestCase
 	end
 	
 	def test_rm_does_not_remove_file_if_not_made_by_the_task
-	  file = infer_filepath(:output, 'path/to/file.txt')
+	  file = method_filepath(:output, 'path/to/file.txt')
 
 	  touch_file(file)
 	  assert File.exists?(file)
@@ -814,50 +993,50 @@ class FileTaskTest < Test::Unit::TestCase
   	assert File.exists?(file)
 	end
 	
-	def test_rm_clears_made_files_of_removed_files
-	  file0 = infer_filepath(:output, 'file0.txt')
-	  file1 = infer_filepath(:output, 'file1.txt')
+	def test_rm_clears_added_files_of_removed_files
+	  file0 = method_filepath(:output, 'file0.txt')
+	  file1 = method_filepath(:output, 'file1.txt')
 
-	  FileUtils.mkdir_p(infer_filepath(:output))
-	  assert_equal [], t.made_files
+	  FileUtils.mkdir_p(method_filepath(:output))
+	  assert_equal [], t.added_files
   
-	  t.make([file0,file1])
+	  t.prepare([file0,file1])
   	assert_equal [
-  	  File.expand_path(infer_filepath(:output, 'file0.txt')),
-  	  File.expand_path(infer_filepath(:output, 'file1.txt'))], t.made_files
+  	  File.expand_path(method_filepath(:output, 'file0.txt')),
+  	  File.expand_path(method_filepath(:output, 'file1.txt'))], t.added_files
   	
   	t.rm(file0)
   	assert_equal [
-  	  File.expand_path(infer_filepath(:output, 'file1.txt'))], t.made_files
+  	  File.expand_path(method_filepath(:output, 'file1.txt'))], t.added_files
 	end
 	
 	def test_rm_acts_on_and_returns_expanded_list_of_removed_files_and_dirs
-    file = infer_filepath(:output, 'file.txt')
-    another = infer_filepath(:output, 'another.txt')
-    not_removed = infer_filepath(:output, 'not')
-    removed = infer_filepath(:output, 'not/removed.txt')
+    file = method_filepath(:output, 'file.txt')
+    another = method_filepath(:output, 'another.txt')
+    not_removed = method_filepath(:output, 'not')
+    removed = method_filepath(:output, 'not/removed.txt')
     
-    t.make([file, another, removed])
+    t.prepare([file, another, removed])
     # touch a file so the not_removed folder isn't removed
-  	touch_file infer_filepath(:output, 'not/file.txt')
+  	touch_file method_filepath(:output, 'not/file.txt')
   	
   	expected = [file, another, removed].collect {|f| File.expand_path(f)}
     assert_equal expected, t.rm([file, another, removed])
   end
   
   #
-  # process tests
+  # execute tests
   #
   
-  def setup_process_test(&block)
-    existing_file = infer_filepath(:output, "path/to/existing/file.txt")
-    non_existant_dir = infer_filepath(:output, "path/to/non/existing")
+  def setup_execute_test(&block)
+    existing_file = method_filepath(:output, "path/to/existing/file.txt")
+    non_existant_dir = method_filepath(:output, "path/to/non/existing")
     non_existant_file = File.join(non_existant_dir, "file.txt")
-    backup_file = infer_filepath(:output, "backup/file.txt")
+    backup_file = method_filepath(:output, "backup/file.txt")
     
     touch_file(existing_file, "original content")
 	  @t = Tap::FileTask.new do |task, input|
-	    task.make([existing_file, non_existant_file]) 
+	    task.prepare([existing_file, non_existant_file]) 
 
       block.call if block_given?
 	  end
@@ -869,8 +1048,8 @@ class FileTaskTest < Test::Unit::TestCase
 	  [existing_file, backup_file, non_existant_dir, non_existant_file]
   end
   
-  def test_setup_process_test
-    existing_file, backup_file, non_existant_dir, non_existant_file = setup_process_test do 
+  def test_setup_execute_test
+    existing_file, backup_file, non_existant_dir, non_existant_file = setup_execute_test do 
       assert !File.exists?(non_existant_file)
       assert File.exists?(non_existant_dir)
       assert File.exists?(backup_file)
@@ -879,109 +1058,163 @@ class FileTaskTest < Test::Unit::TestCase
     t.execute(nil)
   end
   
-  def test_process_restores_backups_and_removes_made_files_on_error
-    was_in_process = false
-    existing_file, backup_file, non_existant_dir, non_existant_file = setup_process_test do 
-      was_in_process = true
+  def test_execute_restores_backups_and_removes_added_files_on_error
+    was_in_execute = false
+    existing_file, backup_file, non_existant_dir, non_existant_file = setup_execute_test do 
+      was_in_execute = true
       raise "error"
     end
 
 	  assert_raise(RuntimeError) { t.execute(nil)  }
 
     # check the existing file was restored
-    assert was_in_process
+    assert was_in_execute
     assert File.exists?(existing_file)
     assert !File.exists?(non_existant_dir)
     assert !File.exists?(backup_file)
     assert_equal "original content", File.read(existing_file)
+    assert t.added_files.empty?
+    assert t.backed_up_files.empty?
   end
   
-  def test_process_does_not_restores_backups_if_restore_on_error_is_false
-    was_in_process = false
-    existing_file, backup_file, non_existant_dir, non_existant_file = setup_process_test do
-      was_in_process = true
+  def test_execute_does_not_restore_backups_if_rollback_on_error_is_false
+    was_in_execute = false
+    existing_file, backup_file, non_existant_dir, non_existant_file = setup_execute_test do
+      was_in_execute = true
       raise "error"
     end
 
-	  t.restore_on_error = false
+	  t.rollback_on_error = false
 	  assert_raise(RuntimeError) { t.execute(nil)  }
 
     # check the existing file was NOT restored
-    assert was_in_process
+    assert was_in_execute
     assert !File.exists?(existing_file)
     assert File.exists?(non_existant_dir)
     assert File.exists?(backup_file)
     assert_equal "original content", File.read(backup_file)
+    assert !t.added_files.empty?
+    assert !t.backed_up_files.empty?
   end
   
-  def test_process_removes_backed_up_files_if_remove_backed_up_files_is_true
-    was_in_process = false
-    existing_file, backup_file, non_existant_dir, non_existant_file = setup_process_test do
-      was_in_process = true
-      touch_file(existing_file, "new content")
-    end
-
-	  t.remove_backed_up_files = true
-	  t.execute(nil)
-
-    # check the backup file was removed and that
-    # there was no restore (no error was raised)
-    assert was_in_process
-    assert File.exists?(existing_file)
-    assert_equal "new content", File.read(existing_file)
-    assert !File.exists?(backup_file)
-    assert !File.exists?(File.dirname(backup_file))
-  end
+  # def test_execute_removes_backed_up_files_if_cleanup_after_execute_is_true
+  #   was_in_execute = false
+  #   existing_file, backup_file, non_existant_dir, non_existant_file = setup_execute_test do
+  #     was_in_execute = true
+  #     touch_file(existing_file, "new content")
+  #   end
+  # 
+  #     t.cleanup_after_execute = true
+  #     t.execute(nil)
+  # 
+  #   # check the backup file was removed and that
+  #   # there was no restore (no error was raised)
+  #   assert was_in_execute
+  #   assert File.exists?(existing_file)
+  #   assert_equal "new content", File.read(existing_file)
+  #   assert !File.exists?(backup_file)
+  #   assert !File.exists?(File.dirname(backup_file))
+  #   assert !t.added_files.empty?
+  #   assert !t.added_files.include?(backup_file)
+  #   assert t.backed_up_files.empty?
+  # end
   
-  def test_process_restores_backups_on_error_even_if_remove_backed_up_files_is_true
-    was_in_process = false
-    existing_file, backup_file, non_existant_dir, non_existant_file = setup_process_test do
-      was_in_process = true
-      touch_file(existing_file, "new content")
-      raise "error"
-    end
+  # def test_execute_restores_backups_on_error_even_if_cleanup_after_execute_is_true
+  #   was_in_execute = false
+  #   existing_file, backup_file, non_existant_dir, non_existant_file = setup_execute_test do
+  #     was_in_execute = true
+  #     touch_file(existing_file, "new content")
+  #     raise "error"
+  #   end
+  # 
+  #     t.cleanup_after_execute = true
+  #     assert_raise(RuntimeError) { t.execute(nil) }
+  # 
+  #   # check the existing file was restored and
+  #   # backup file was removed
+  #   assert was_in_execute
+  #   assert File.exists?(existing_file)
+  #   assert_equal "original content", File.read(existing_file)
+  #   assert !File.exists?(backup_file)
+  #   assert !File.exists?(File.dirname(backup_file))
+  #   assert t.added_files.empty?
+  #   assert t.backed_up_files.empty?
+  # end
   
-	  t.remove_backed_up_files = true
-	  assert_raise(RuntimeError) { t.execute(nil) }
+  def test_execute_does_not_rollback_results_from_prior_successful_executions
+    existing_file = method_filepath(:output, "path/to/existing/file.txt")
+    non_existant_dir = method_filepath(:output, "path/to/non/existing")
+    non_existant_file = File.join(non_existant_dir, "file.txt")
+    backup_file = method_filepath(:output, "backup/file.txt")
+    
+    touch_file(existing_file, "original content")
+    count = 0
+	  @t = Tap::FileTask.new do |task, input|
+      if count > 0
+        count = 2
+        raise "error" 
+      else
+        count = 1
+        task.prepare([existing_file, non_existant_file]) 
+        touch_file(existing_file, "new content")
+      end
+	  end
+    
+    # inference leads to the backup_file
+    @t.inference do |root, dir, path|
+	    backup_file
+	  end
+  
+   # assert !t.cleanup_after_execute
+    
+    assert_nothing_raised { t.execute(nil)  }
+    assert_equal 1, count
+    assert File.exists?(existing_file)
+    assert_equal "new content", File.read(existing_file)   
+    assert File.exists?(non_existant_dir)
+    assert File.exists?(backup_file)
+    assert_equal "original content", File.read(backup_file)   
+    
+	  assert_raise(RuntimeError) { t.execute(nil)  }
 
-    # check the existing file was restored and
-    # backup file was removed
-    assert was_in_process
+    # check the existing file was NOT restored
+    assert_equal 2, count
     assert File.exists?(existing_file)
-    assert_equal "original content", File.read(existing_file)
-    assert !File.exists?(backup_file)
-    assert !File.exists?(File.dirname(backup_file))
+    assert_equal "new content", File.read(existing_file)   
+    assert File.exists?(non_existant_dir)
+    assert File.exists?(backup_file)
+    assert_equal "original content", File.read(backup_file)   
   end
   
   #
-  # test process with multiple files
+  # test execute with multiple files
   #
   
-  def setup_multiple_file_process_test(&block)
+  def setup_multiple_file_execute_test(&block)
     existing_files = [0,1].collect do |n|
-      path = infer_filepath(:output, "path/to/existing/file#{n}.txt")
+      path = method_filepath(:output, "path/to/existing/file#{n}.txt")
       touch_file path, n.to_s
       path
     end
     
     non_existant_files =  [0,1].collect do |n|
-      infer_filepath(:output, "path/to/non/existing/file#{n}.txt")
+      method_filepath(:output, "path/to/non/existing/file#{n}.txt")
     end
     
     @t = Tap::FileTask.new do |task, input|
-	    task.make(existing_files + non_existant_files) 
+	    task.prepare(existing_files + non_existant_files) 
 	    block.call if block_given?
 	  end
     # inference leads to an output_dir
     @t.inference do |root, dir, path|
-	    infer_filepath(:output, 'backup', path)
+	    method_filepath(:output, 'backup', path)
 	  end
 	  
 	  [existing_files, non_existant_files]
   end
   
-  def test_setup_multiple_file_process_test
-    existing_files, non_existant_files = setup_multiple_file_process_test do 
+  def test_setup_multiple_file_execute_test
+    existing_files, non_existant_files = setup_multiple_file_execute_test do 
       (existing_files + existing_files).each do |file|
 	      assert !File.exists?(file)
 	      assert File.exists?(File.dirname(file))
@@ -990,21 +1223,21 @@ class FileTaskTest < Test::Unit::TestCase
     t.execute(nil)
   end
   
-  def test_process_restore_and_removal_with_multiple_files
-    was_in_process = false
-    existing_files, non_existant_files = setup_multiple_file_process_test do
-      was_in_process = true
+  def test_execute_restore_and_removal_with_multiple_files
+    was_in_execute = false
+    existing_files, non_existant_files = setup_multiple_file_execute_test do
+      was_in_execute = true
 	    (existing_files + non_existant_files) .each do |file|
 	      touch_file file, "new content"
 	    end
 	    raise "error"
 	  end
 
-	  assert !File.exists?(infer_filepath(:output, 'backup'))
+	  assert !File.exists?(method_filepath(:output, 'backup'))
 	  assert_raise(RuntimeError) { t.execute(nil) }
 
     # check existing files were restored, made files and backups removed.
-    assert was_in_process
+    assert was_in_execute
     existing_files.each_with_index do |existing_file, n|
      assert File.exists?(existing_file)
      assert_equal n.to_s, File.read(existing_file)
@@ -1012,30 +1245,30 @@ class FileTaskTest < Test::Unit::TestCase
     non_existant_files.each do |non_existing_file|
       assert !File.exists?(non_existing_file)
     end
-    assert !File.exists?(infer_filepath(:output, 'backup'))
+    assert !File.exists?(method_filepath(:output, 'backup'))
   end
   
-  def test_process_remove_backed_up_files_with_multiple_files
-    was_in_process = false
-    existing_files, non_existant_files = setup_multiple_file_process_test do
-      was_in_process = true
-	    (existing_files + non_existant_files) .each do |file|
-	      touch_file file, "new content"
-	    end
-	  end
-
-	  assert !File.exists?(infer_filepath(:output, 'backup'))
-	  
-	  t.remove_backed_up_files = true
-	  t.execute(nil)
-
-    # check existing files were restored, made files and backups removed.
-    assert was_in_process
-    (existing_files + non_existant_files).each do |file|
-     assert File.exists?(file)
-     assert_equal "new content", File.read(file)
-    end
-    assert !File.exists?(infer_filepath(:output, 'backup'))
-  end
+  # def test_execute_cleanup_after_execute_with_multiple_files
+  #   was_in_execute = false
+  #   existing_files, non_existant_files = setup_multiple_file_execute_test do
+  #     was_in_execute = true
+  #       (existing_files + non_existant_files) .each do |file|
+  #         touch_file file, "new content"
+  #       end
+  #     end
+  # 
+  #     assert !File.exists?(method_filepath(:output, 'backup'))
+  #     
+  #     t.cleanup_after_execute = true
+  #     t.execute(nil)
+  # 
+  #   # check existing files were restored, made files and backups removed.
+  #   assert was_in_execute
+  #   (existing_files + non_existant_files).each do |file|
+  #    assert File.exists?(file)
+  #    assert_equal "new content", File.read(file)
+  #   end
+  #   assert !File.exists?(method_filepath(:output, 'backup'))
+  # end
 
 end