tap 0.7.9 → 0.8.0

data/test/root_test.rb

@@ -1,72 +1,54 @@
 require File.join(File.dirname(__FILE__), 'tap_test_helper.rb') 
 require 'tap/root'
 
-#SomeModule
-#[Object, :SomeModule, "some_module", nil]
-
-#Dependencies.load_paths << File.join(File.dirname(__FILE__), 'root', 'lib') 
-#puts Object.const_get "SomeModule"
-#Dependencies.clear
-#puts SomeModule
-
 class RootTest < Test::Unit::TestCase
 	include Tap::Test::SubsetMethods
 	
-	attr_reader :ifs, :rfs
+	attr_reader :r, :tr
 	
 	def setup
-		@ifs = Tap::Root.new "./root", {:dir => "dir"}, {:abs => '/abs/path'}
-		@rfs = Tap::Root.new root, {:lib => "lib"}
+	  # root
+		@r = Tap::Root.new "./root", {:dir => "dir"}, {:abs => '/abs/path'}
+		
+		# test root
+		@tr = Tap::Root.new test_root, {:lib => "lib"}
 	end
 	
-	def root 
-		File.join(File.dirname(__FILE__), 'root')
+	def test_root 
+		File.expand_path(File.join(File.dirname(__FILE__), 'root'))
 	end
 	
 	def test_documentation
-	  root = Tap::Root.new self.root, :input => 'in', :output => 'out'
+	  r = Tap::Root.new test_root, :input => 'in', :output => 'out'
 	  
     # work with directories
-    assert_equal self.root + '/in', root[:in]         
-    assert_equal self.root + '/out', root[:out]        
-    assert_equal self.root + '/implicit', root[:implicit]   
+    assert_equal test_root + '/in', r[:in]         
+    assert_equal test_root + '/out', r[:out]        
+    assert_equal test_root + '/implicit', r[:implicit]   
   
     #  # work with filepaths
-    assert_equal self.root + '/in/path/to/file.txt', fp = root.filepath(:in, 'path/to/file.txt')   
-    assert_equal 'path/to/file.txt', root.relative_filepath(:in, fp)               
-    assert_equal self.root + '/out/path/to/file.txt', root.translate(fp, :in, :out)                 
+    assert_equal test_root + '/in/path/to/file.txt', fp = r.filepath(:in, 'path/to/file.txt')   
+    assert_equal 'path/to/file.txt', r.relative_filepath(:in, fp)               
+    assert_equal test_root + '/out/path/to/file.txt', r.translate(fp, :in, :out)                 
      
     #  # version filepaths
-    assert_equal 'path/to/config-1.0.yml', root.version('path/to/config.yml', 1.0)           
-    assert_equal 'path/to/config-1.1.yml', root.increment('path/to/config-1.0.yml', 0.1)     
-    assert_equal ['path/to/config.yml', "1.1"], root.deversion('path/to/config-1.1.yml')          
-     
-    #  # work with modules...
-    #assert_equal self.root + '/lib/some/module.rb', mp = root.module_filepath(:lib, 'Some::Module')   
-     
-    #  # loading them...
-    #assert_equal false, Some.const_defined?('Module')   # differs from example because Some is defined in another test    
-    #assert_equal root.lookup_module('Some::Module'), Some::Module        
-    #assert_equal true, Some.const_defined?('Module')                 
+    assert_equal 'path/to/config-1.0.yml', r.version('path/to/config.yml', 1.0)           
+    assert_equal 'path/to/config-1.1.yml', r.increment('path/to/config-1.0.yml', 0.1)     
+    assert_equal ['path/to/config.yml', "1.1"], r.deversion('path/to/config-1.1.yml')          
     
-    #  # and unloading them!
-    #assert_equal ["Some::Module"], root.unload_modules                         
-    #assert_equal false, Some.const_defined?('Module')  # differs from example because Some is defined in another test      
-    
-    ##
-    assert_equal "path/to/file.txt", Tap::Root.relative_filepath('dir', "dir/path/to/file.txt")  
-    
-    #assert_equal 'some/module_name.rb', Tap::Root.module_filepath('Some::ModuleName')     
-    #assert_equal 'some/module_name.rb', Tap::Root.module_filepath('some/module_name.rb')  
-  
-    #assert_equal 'Some::ModuleName', Tap::Root.module_name('some/module_name.rb')  
-    #assert_equal 'Some::ModuleName', Tap::Root.module_name('Some::ModuleName')     
+    #  # absolute paths can also be aliased. 
+    r[:abs, true] = "/absolute/path"      
+    assert_equal File.expand_path('/absolute/path/to/file.txt'), r.filepath(:abs, "to", "file.txt")
 	end
 	
 	#
 	# Tap::Root relative filepath test
 	#
 	
+	def test_relative_filepath_documentation
+    assert_equal "path/to/file.txt", Tap::Root.relative_filepath('dir', "dir/path/to/file.txt")  
+  end
+	
 	def test_class_relative_filepath
 		assert_equal "file.txt", Tap::Root.relative_filepath('./root/dir', "./root/dir/file.txt")
 		assert_equal "nested/file.txt", Tap::Root.relative_filepath('./root/dir', "./root/dir/nested/file.txt")
@@ -82,46 +64,85 @@ class RootTest < Test::Unit::TestCase
 		assert_raise(RuntimeError) { Tap::Root.relative_filepath('dir', "./root/file.txt") }
 	end
 	
-	def test_class_relative_filepath_returns_path_if_path_is_not_relative_to_dir_and_not_strict
-		assert_equal "./root/file.txt", Tap::Root.relative_filepath('dir', "./root/file.txt", false)
+	def test_class_relative_filepath_returns_expanded_path_if_path_is_not_relative_to_dir_and_not_strict
+		assert_equal test_root + "/root/file.txt", Tap::Root.relative_filepath('dir', test_root + "/root/folder/.././file.txt", false)
+	end
+	
+	#
+	# Tap::Root glob test
+	#
+	
+	def test_class_glob_returns_all_unique_files_matching_input_patterns
+	  files = [test_root + "/glob/one.txt", test_root + "/glob/two.txt"]
+	  
+    assert_equal files, Tap::Root.glob(test_root + "/glob/**/*")  
+    assert_equal files, Tap::Root.glob(test_root + "/glob/one.txt", test_root + "/glob/two.txt")  
+    assert_equal files, Tap::Root.glob(test_root + "/glob/**/*", test_root + "/glob/one.txt", test_root + "/glob/two.txt") 
+    assert_equal [], Tap::Root.glob(test_root + "/glob/three.txt")
+    assert_equal [], Tap::Root.glob()
+  end
+
+  #
+	# Tap::Root vglob test
+	#
+	
+	def test_class_vglob_returns_all_versions_matching_file_and_version_pattern
+    assert_equal 4, Dir.glob(File.join(test_root, 'versions/*')).length
+
+    assert_equal 3, Dir.glob(File.join(test_root, 'versions/file*.yml')).length
+    assert_equal Dir.glob(test_root + '/versions/file*.yml').sort, Tap::Root.vglob(test_root + '/versions/file.yml', '*').sort
+    
+    assert_equal 2, Dir.glob(File.join(test_root, 'versions/file-0.1*.yml')).length
+    assert_equal Dir.glob(test_root + '/versions/file-0.1*.yml').sort, Tap::Root.vglob(test_root + '/versions/file.yml', '0.1*').sort
+   
+    assert_equal 1, Dir.glob(File.join(test_root, 'versions/file-0.1.yml')).length
+    assert_equal Dir.glob(test_root + '/versions/file-0.1.yml').sort, Tap::Root.vglob(test_root + '/versions/file.yml', '0.1').sort
+    
+    assert_equal 0, Dir.glob(File.join(test_root, 'versions/file-2.yml')).length
+    assert_equal [], Tap::Root.vglob(test_root + '/versions/file.yml', '2')
 	end
   
+  def test_class_default_vglob_pattern_is_all_versions
+	  expected = Dir.glob(File.join(test_root + '/versions/file*.yml'))
+		assert_equal expected.sort, Tap::Root.vglob(test_root + '/versions/file.yml').sort
+	end
+	
 	#
 	# initialize tests
 	#
 	
-	def test_defualt_root_is_dir_pwd
-		ifs = Tap::Root.new
+	def test_default_root_is_expanded_dir_pwd
+		r = Tap::Root.new
 		
-		assert_equal Dir.pwd, ifs.root
-		assert_equal({}, ifs.directories)
+		assert_equal File.expand_path(Dir.pwd), r.root
+		assert_equal({}, r.directories)
 	end
 	
 	def test_initialize_root
-		ifs = Tap::Root.new "./root", {:dir => "dir", :temp => "tmp"}, {:abs => "/abs/path"}
+		r = Tap::Root.new "./root", {:dir => "dir", :temp => "tmp"}, {:abs => "/abs/path"}
 		
-		assert_equal "./root", ifs.root
-		assert_equal({:dir => "dir", :temp => "tmp"}, ifs.directories)
-		assert_equal({:abs => "/abs/path"}, ifs.absolute_paths)
+		assert_equal File.expand_path("./root"), r.root
+		assert_equal({:dir => "dir", :temp => "tmp"}, r.directories)
+		assert_equal({:abs => File.expand_path("/abs/path")}, r.absolute_paths)
 		assert_equal({
-		  'root' => "./root", 
-		  :root => "./root", 
-		  :dir => "./root/dir", 
-		  :temp => "./root/tmp", 
-		  :abs => "/abs/path"}, 
-		ifs.paths)
+		  'root' => File.expand_path("./root"), 
+		  :root =>  File.expand_path("./root"), 
+		  :dir =>   File.expand_path("./root/dir"), 
+		  :temp =>  File.expand_path( "./root/tmp"), 
+		  :abs =>   File.expand_path("/abs/path")}, 
+		r.paths)
 	end
 	
-	def test_initialize_can_use_any_object_as_key
-		ifs = Tap::Root.new("./root", 'dir' => "str_dir",	:dir => 'sym_dir', 1 => 'n_dir')
+	def test_any_object_can_be_used_as_a_directory_alias
+		r = Tap::Root.new("./root", 'dir' => "str_da",	:dir => 'sym_da', 1 => 'n_da')
 		
 		assert_equal({
-		  'root' => "./root", 
-		  :root => "./root", 
-			'dir' => "./root/str_dir", 
-			:dir => "./root/sym_dir", 
-			1 => "./root/n_dir"}, 
-		ifs.paths)
+		  'root' => File.expand_path("./root"), 
+		  :root =>  File.expand_path("./root"), 
+			'dir' =>  File.expand_path("./root/str_da"), 
+			:dir =>   File.expand_path("./root/sym_da"), 
+			1 =>      File.expand_path("./root/n_da")}, 
+		r.paths)
 	end
 	
 	#
@@ -129,50 +150,60 @@ class RootTest < Test::Unit::TestCase
 	#
 	
 	def test_set_root_resets_paths
-		ifs.root = './another'
+		r.root = './another'
 		
-		assert_equal "./another", ifs.root
-		assert_equal({:dir => "dir"}, ifs.directories)
+		assert_equal File.expand_path("./another"), r.root
+		assert_equal({:dir => "dir"}, r.directories)
 		assert_equal({
-		  'root' => "./another", 
-		  :root => "./another", 
-		  :dir => "./another/dir", 
-		  :abs => "/abs/path"}, 
-		ifs.paths)
+		  'root' => File.expand_path("./another"), 
+		  :root =>  File.expand_path("./another"), 
+		  :dir =>   File.expand_path("./another/dir"), 
+		  :abs =>   File.expand_path("/abs/path")}, 
+		r.paths)
 	end
 	
 	def test_root_cannot_be_set_through_index
-		assert_raise(ArgumentError) { ifs['root'] = './another' }
+		assert_raise(ArgumentError) { r['root'] = './another' }
 	end
 	
 	#
 	# set directories tests
 	#
-		
+	
 	def test_set_directories
-		ifs.directories = {:alt => "dir"}
+		r.directories = {:alt => "dir"}
 
-		assert_equal({:alt => "dir"}, ifs.directories)
-		assert_equal({'root' => "./root", :root => "./root", :alt => "./root/dir", :abs => "/abs/path"}, ifs.paths)
+		assert_equal({:alt => "dir"}, r.directories)
+		assert_equal({
+		  'root' => File.expand_path("./root"), 
+		  :root =>  File.expand_path("./root"), 
+		  :alt =>   File.expand_path("./root/dir"), 
+		  :abs =>   File.expand_path("/abs/path")}, 
+		r.paths)
 	end
 	
 	def test_raise_error_when_trying_to_set_root_through_directories
-		assert_raise(ArgumentError) { ifs.directories = {'root' => "another"} }
+		assert_raise(ArgumentError) { r.directories = {'root' => "another"} }
 	end
 	
 	#
 	# set absolute paths test
 	#
-	
+
 	def test_set_absolute_paths
-		ifs.absolute_paths = {:absolute => "/absolute/path"}
+		r.absolute_paths = {:absolute => "/absolute/path"}
 
-		assert_equal({:dir => "dir"}, ifs.directories)
-		assert_equal({'root' => "./root", :root => "./root", :dir => "./root/dir", :absolute => "/absolute/path"}, ifs.paths)
+		assert_equal({:dir => "dir"}, r.directories)
+		assert_equal({
+		  'root' =>    File.expand_path("./root"), 
+		  :root =>     File.expand_path("./root"), 
+		  :dir =>      File.expand_path("./root/dir"), 
+		  :absolute => File.expand_path("/absolute/path")}, 
+		r.paths)
 	end
 	
 	def test_raise_error_when_trying_to_set_root_through_absolute_paths
-		assert_raise(ArgumentError) { ifs.absolute_paths = {'root' => "another"} }
+		assert_raise(ArgumentError) { r.absolute_paths = {'root' => "another"} }
 	end
 	
 	#
@@ -180,124 +211,194 @@ class RootTest < Test::Unit::TestCase
 	#
 	
 	def test_absolute_paths_returns_all_non_root_paths_with_no_directory
-	  assert_equal({:abs => "/abs/path"}, ifs.absolute_paths)
+	  assert_equal({:abs => File.expand_path("/abs/path")}, r.absolute_paths)
 	  
-	  ifs.paths[:another] = "/another/path"
-	  assert_equal({:abs => "/abs/path", :another => "/another/path"}, ifs.absolute_paths)
+	  r.paths[:another] = File.expand_path("/another/path")
+	  assert_equal({
+      :abs =>     File.expand_path("/abs/path"), 
+      :another => File.expand_path("/another/path")}, 
+    r.absolute_paths)
 	end
 	
 	#
-	# set path tests
+	# assignment tests
 	#
 	
-	def test_set_existing_directory_using_index
-		ifs[:dir] = 'another'
+	def test_assignment_documentation
+    r = Tap::Root.new test_root
+    r[:dir] = 'path/to/dir'
+    assert_equal test_root + '/path/to/dir', r[:dir]
+
+    r[:abs, true] = '/abs/path/to/dir'  
+    assert_equal File.expand_path('/abs/path/to/dir'), r[:abs]
+	end
+	
+	def test_set_existing_directory_using_assignment
+		r[:dir] = 'another'
 		
-		assert_equal({:dir => "another"}, ifs.directories)
+		assert_equal({:dir => "another"}, r.directories)
 		assert_equal({
-		  'root' => "./root", 
-		  :root => "./root", 
-		  :dir => "./root/another", 
-		  :abs => "/abs/path"}, 
-		ifs.paths)
+		  'root' => File.expand_path("./root"), 
+		  :root =>  File.expand_path("./root"), 
+		  :dir =>   File.expand_path("./root/another"), 
+		  :abs =>   File.expand_path("/abs/path")}, 
+		r.paths)
 	end
 	
-	def test_set_new_directory_using_index
-		ifs[:new] = 'new'
+	def test_set_new_directory_using_assignment
+		r[:new] = 'new'
 
-		assert_equal({:dir => "dir", :new => "new"}, ifs.directories)
+		assert_equal({:dir => "dir", :new => "new"}, r.directories)
 		assert_equal({
-		  'root' => "./root", 
-		  :root => "./root", 
-		  :dir => "./root/dir",
-		  :abs => "/abs/path", 
-		  :new => "./root/new"}, 
-		ifs.paths)
+		  'root' => File.expand_path("./root"), 
+		  :root =>  File.expand_path("./root"), 
+		  :dir =>   File.expand_path("./root/dir"),
+		  :abs =>   File.expand_path("/abs/path"), 
+		  :new =>   File.expand_path("./root/new")}, 
+		r.paths)
 	end
 
   def test_absolute_paths_can_be_set_by_specifiying_absolute_true
-    ifs[:absolute, true] = '/some/absolute/path'
+    r[:absolute, true] = '/some/absolute/path'
     
-		assert_equal({:dir => "dir"}, ifs.directories)
+		assert_equal({:dir => "dir"}, r.directories)
 		assert_equal({
-		  'root' => "./root", 
-		  :root => "./root", 
-		  :dir => "./root/dir",
-		  :abs => "/abs/path", 
-		  :absolute => '/some/absolute/path'},
-		ifs.paths)
+		  'root' => File.expand_path("./root"), 
+		  :root =>  File.expand_path("./root"), 
+		  :dir =>   File.expand_path("./root/dir"),
+		  :abs =>   File.expand_path("/abs/path"), 
+		  :absolute => File.expand_path('/some/absolute/path')},
+		r.paths)
   end
   
   def test_an_absolute_path_is_not_set_if_absolute_false
-    ifs[:not_absolute, false] = 'not/an/absolute/path'
+    r[:not_absolute, false] = 'not/an/absolute/path'
     
-		assert_equal({:dir => "dir", :not_absolute => "not/an/absolute/path"}, ifs.directories)
+		assert_equal({:dir => "dir", :not_absolute => "not/an/absolute/path"}, r.directories)
 		assert_equal({
-		  'root' => "./root", 
-		  :root => "./root", 
-		  :dir => "./root/dir", 
-		  :abs => "/abs/path", 
-		  :not_absolute => "./root/not/an/absolute/path"}, 
-		ifs.paths)
+		  'root' => File.expand_path("./root"), 
+		  :root =>  File.expand_path("./root"), 
+		  :dir =>   File.expand_path("./root/dir"), 
+		  :abs =>   File.expand_path("/abs/path"), 
+		  :not_absolute => File.expand_path("./root/not/an/absolute/path")}, 
+		r.paths)
   end
   
   def test_paths_can_be_unset_with_nil
     # Non-absolute path
-    ifs[:dir] = '/some/path'
-    assert_equal({:dir => "/some/path"}, ifs.directories)
-		assert_equal({'root' => "./root", :root => "./root", :dir => "./root/some/path", :abs => "/abs/path"}, ifs.paths)
+    r[:dir] = '/some/path'
+    assert_equal({:dir => "/some/path"}, r.directories)
+		assert_equal({
+		  'root' => File.expand_path("./root"), 
+		  :root =>  File.expand_path("./root"), 
+		  :dir =>   File.expand_path("./root/some/path"), 
+		  :abs =>   File.expand_path("/abs/path")}, 
+		r.paths)
 		
-    ifs[:dir] = nil
-    assert_equal({}, ifs.directories)
-		assert_equal({'root' => "./root", :root => "./root", :abs => "/abs/path"}, ifs.paths)
+    r[:dir] = nil
+    assert_equal({}, r.directories)
+		assert_equal({
+		  'root' => File.expand_path("./root"), 
+		  :root =>  File.expand_path("./root"), 
+		  :abs =>   File.expand_path("/abs/path")}, 
+		r.paths)
 
-    # Now with absolute specified
-    ifs[:dir] = '/some/path'
-    assert_equal({:dir => "/some/path"}, ifs.directories)
-		assert_equal({'root' => "./root", :root => "./root", :dir => "./root/some/path", :abs => "/abs/path"}, ifs.paths)
+    # the same with absolute specified
+    r[:dir] = '/some/path'
+    assert_equal({:dir => "/some/path"}, r.directories)
+		assert_equal({
+		  'root' => File.expand_path("./root"), 
+		  :root =>  File.expand_path("./root"), 
+		  :dir =>   File.expand_path("./root/some/path"), 
+		  :abs =>   File.expand_path("/abs/path")}, 
+    r.paths)
     
-    ifs[:dir, false] = nil
-    assert_equal({}, ifs.directories)
-		assert_equal({'root' => "./root", :root => "./root", :abs => "/abs/path"}, ifs.paths)
+    r[:dir, false] = nil
+    assert_equal({}, r.directories)
+		assert_equal({
+		  'root' => File.expand_path("./root"), 
+		  :root =>  File.expand_path("./root"), 
+		  :abs => File.expand_path("/abs/path")}, 
+		r.paths)
 
     # Absolute path
-    ifs[:abs, true] = '/some/absolute/path'
-    assert_equal({}, ifs.directories)
-		assert_equal({'root' => "./root", :root => "./root", :abs => '/some/absolute/path'}, ifs.paths)
+    r[:abs, true] = '/some/absolute/path'
+    assert_equal({}, r.directories)
+		assert_equal({
+		  'root' => File.expand_path("./root"), 
+		  :root =>  File.expand_path("./root"), 
+		  :abs =>   File.expand_path('/some/absolute/path')}, 
+		r.paths)
     
-    ifs[:abs, true] = nil
-    assert_equal({}, ifs.directories)
-		assert_equal({'root' => "./root", :root => "./root"}, ifs.paths)
+    r[:abs, true] = nil
+    assert_equal({}, r.directories)
+		assert_equal({
+		  'root' => File.expand_path("./root"), 
+		  :root =>  File.expand_path("./root")}, 
+		r.paths)
     
-    # Now with absolute unspecfied
-    ifs[:abs, true] = '/some/absolute/path'
-    assert_equal({}, ifs.directories)
-		assert_equal({'root' => "./root", :root => "./root", :abs => '/some/absolute/path'}, ifs.paths)
+    # the same with absolute unspecfied
+    r[:abs, true] = '/some/absolute/path'
+    assert_equal({}, r.directories)
+		assert_equal({
+		  'root' => File.expand_path("./root"), 
+		  :root =>  File.expand_path("./root"), 
+		  :abs =>   File.expand_path('/some/absolute/path')}, 
+    r.paths)
     
-    ifs[:abs] = nil
-    assert_equal({}, ifs.directories)
-		assert_equal({'root' => "./root", :root => "./root"}, ifs.paths)
+    r[:abs] = nil
+    assert_equal({}, r.directories)
+		assert_equal({
+		  'root' => File.expand_path("./root"), 
+		  :root =>  File.expand_path("./root")}, 
+		r.paths)
   end
   
+  def test_set_path_expands_filepaths
+	  r[:dir] = "./sub/../dir"
+		assert_equal File.expand_path("./root/dir"), r.paths[:dir]
+		
+		r[:abs, true] = "/./sub/../dir"
+		assert_equal File.expand_path("/dir"), r.paths[:abs]
+	end
+  
 	#
 	# retrieve path tests
 	#
 	
+	def test_retrieve_documentation
+    r = Tap::Root.new test_root
+    r[:dir] = 'path/to/dir'
+    assert_equal test_root + '/path/to/dir', r[:dir]
+
+    r[:unset] = nil
+    assert_equal test_root + '/unset', r[:unset]
+	end
+	
 	def test_retrieve_paths
-		case_test(
-			:dir => "./root/dir",
-			:root => "./root",
-			'root' => "./root",
-			:abs => "/abs/path"
-		) do |dir, expected|
-			assert_equal expected, ifs[dir]
+		{
+			:dir =>   File.expand_path("./root/dir"),
+			:root =>  File.expand_path("./root"),
+			'root' => File.expand_path("./root"),
+			:abs => File.expand_path("/abs/path")
+		}.each_pair do |dir, expected|
+			assert_equal expected, r[dir]
 		end
 	end
 	
-	def test_retrieve_path_guesses_path_if_path_is_not_set
-		assert_equal({'root' => "./root", :root => "./root", :dir => "./root/dir", :abs => "/abs/path"}, ifs.paths)
-		assert_equal "./root/not_set", ifs[:not_set]
-		assert_equal "./root/nested/dir", ifs['nested/dir']
+	def test_retrieve_path_infers_path_if_path_is_not_set
+		assert_equal({
+		  'root' => File.expand_path("./root"), 
+		  :root =>  File.expand_path("./root"), 
+		  :dir =>   File.expand_path("./root/dir"), 
+		  :abs => File.expand_path("/abs/path")}, 
+		r.paths)
+		assert_equal File.expand_path("./root/not_set"), r[:not_set]
+		assert_equal File.expand_path("./root/nested/dir"), r['nested/dir']
+	end
+	
+	def test_retrieve_path_expands_inferred_filepaths
+		assert_equal File.expand_path("./root/nested/dir"), r['./sub/../nested/dir']
 	end
 
 	#
@@ -305,16 +406,22 @@ class RootTest < Test::Unit::TestCase
 	#
 	
 	def test_filepath
-		assert_equal "./root/dir", ifs[:dir]
-		assert_equal "./root/dir/file.txt", ifs.filepath(:dir, "file.txt")
-		assert_equal "./root/dir/nested/file.txt", ifs.filepath(:dir, "nested/file.txt")
+		assert_equal File.expand_path("./root/dir"), r[:dir]
+		assert_equal File.expand_path("./root/dir/file.txt"), r.filepath(:dir, "file.txt")
+		assert_equal File.expand_path("./root/dir/nested/file.txt"), r.filepath(:dir, "nested/file.txt")
 	end
 	
 	def test_filepath_when_path_is_not_set
-		assert_equal "./root/not_set/file.txt", ifs.filepath(:not_set, "file.txt")
-		assert_equal "./root/folder/subfolder/file.txt", ifs.filepath('folder/subfolder', "file.txt")
-		#assert_equal "./root/folder/subfolder/file.txt", ifs.filepath('/folder/subfolder', "file.txt")
-		assert_equal "./root/folder/subfolder/file.txt", ifs.filepath('folder/subfolder/', "file.txt")
+		assert_equal File.expand_path("./root/not_set/file.txt"), r.filepath(:not_set, "file.txt")
+		assert_equal File.expand_path("./root/folder/subfolder/file.txt"), r.filepath('folder/subfolder', "file.txt")
+		assert_equal File.expand_path("./root/folder/subfolder/file.txt"), r.filepath('/folder/subfolder', "file.txt")
+		assert_equal File.expand_path("./root/folder/subfolder/file.txt"), r.filepath('folder/subfolder/', "file.txt")
+	end
+	
+	def test_filepath_expands_paths
+		assert_equal File.expand_path("./root/dir"), r[:dir]
+		assert_equal File.expand_path("./root/dir/file.txt"), r.filepath(:dir, "./sub/../file.txt")
+		assert_equal File.expand_path("./root/dir/nested/file.txt"), r.filepath(:dir, "nested/./sub/../file.txt")
 	end
 	
 	#
@@ -322,45 +429,57 @@ class RootTest < Test::Unit::TestCase
 	#
 	
 	def test_relative_filepath
-		assert_equal "file.txt", ifs.relative_filepath(:dir, "./root/dir/file.txt")
-		assert_equal "nested/file.txt", ifs.relative_filepath(:dir, "./root/dir/nested/file.txt")
-		assert_equal "file.txt", ifs.relative_filepath('dir/nested', "./root/dir/nested/file.txt")
-		assert_equal "file.txt", ifs.relative_filepath('dir/nested/', "./root/dir/nested/file.txt")
-		assert_equal "file.txt", ifs.relative_filepath('/dir/nested', "./root/dir/nested/file.txt")
+		assert_equal "file.txt", r.relative_filepath(:dir, "./root/dir/file.txt")
+		assert_equal "nested/file.txt", r.relative_filepath(:dir, "./root/dir/nested/file.txt")
+		assert_equal "file.txt", r.relative_filepath('dir/nested', "./root/dir/nested/file.txt")
+		assert_equal "file.txt", r.relative_filepath('dir/nested/', "./root/dir/nested/file.txt")
+		assert_equal "file.txt", r.relative_filepath('/dir/nested', "./root/dir/nested/file.txt")
 	end
 
 	def test_relative_filepath_when_path_equals_input
-		assert_equal "", ifs.relative_filepath(:dir, "./root/dir")
-		assert_equal "", ifs.relative_filepath(:dir, "./root/dir/")
+		assert_equal "", r.relative_filepath(:dir, "./root/dir")
+		assert_equal "", r.relative_filepath(:dir, "./root/dir/")
 	end
 	
 	def test_relative_filepath_expands_paths
-		assert_equal "file.txt", ifs.relative_filepath(:dir, "./root/folder/.././dir/file.txt")
-		assert_equal "file.txt", ifs.relative_filepath(:dir, "root/dir/file.txt")
+		assert_equal "file.txt", r.relative_filepath(:dir, "./root/folder/.././dir/file.txt")
+		assert_equal "file.txt", r.relative_filepath(:dir, "root/dir/file.txt")
 	end
 		
 	def test_relative_filepath_when_path_is_not_set
-		assert_equal "file.txt", ifs.relative_filepath(:not_set, "./root/not_set/file.txt")
-		assert_equal "file.txt", ifs.relative_filepath('folder/subfolder', "./root/folder/subfolder/file.txt")
-		assert_equal "file.txt", ifs.relative_filepath('/folder/subfolder', "./root/folder/subfolder/file.txt")
-		assert_equal "file.txt", ifs.relative_filepath('folder/subfolder/', "./root/folder/subfolder/file.txt")
+		assert_equal "file.txt", r.relative_filepath(:not_set, "./root/not_set/file.txt")
+		assert_equal "file.txt", r.relative_filepath('folder/subfolder', "./root/folder/subfolder/file.txt")
+		assert_equal "file.txt", r.relative_filepath('/folder/subfolder', "./root/folder/subfolder/file.txt")
+		assert_equal "file.txt", r.relative_filepath('folder/subfolder/', "./root/folder/subfolder/file.txt")
 	end
 	
-	def test_relative_filepath_raises_error_if_path_is_not_relative_to_dir
-		assert_raise(RuntimeError) { ifs.relative_filepath(:dir, "./root/file.txt") }
+	def test_relative_filepath_raises_error_if_path_is_not_relative_to_aliased_dir
+		assert_raise(RuntimeError) { r.relative_filepath(:dir, "./root/file.txt") }
 	end
 	
-	def test_relative_filepath_returns_path_if_path_is_not_relative_to_dir_and_not_strict
-		assert_equal "./root/file.txt", ifs.relative_filepath('dir', "./root/file.txt", false)
+	def test_relative_filepath_returns_expanded_path_if_path_is_not_relative_to_aliased_dir_and_not_strict
+		assert_equal test_root + "/root/file.txt", r.relative_filepath('dir', test_root + "/root/folder/.././file.txt", false)
 	end
   
 	#
 	# translate tests
 	#
 	
+	def test_translate_documentation
+	  r = Tap::Root.new '/root_dir'
+	  
+	  fp = r.filepath(:in, 'path/to/file.txt')    
+	  assert_equal File.expand_path('/root_dir/in/path/to/file.txt'), fp
+    assert_equal File.expand_path('/root_dir/out/path/to/file.txt'), r.translate(fp, :in, :out) 
+	end
+	
 	def test_translate
-		assert_equal "./root/another/file.txt", ifs.translate("./root/dir/file.txt", :dir, :another)
-		assert_equal "./root/another/nested/file.txt", ifs.translate("./root/dir/nested/file.txt", :dir, :another)
+		assert_equal File.expand_path("./root/another/file.txt"), r.translate("./root/dir/file.txt", :dir, :another)
+		assert_equal File.expand_path("./root/another/nested/file.txt"), r.translate("./root/dir/nested/file.txt", :dir, :another)
+	end
+	
+	def test_translate_raises_error_if_path_is_not_relative_to_aliased_input_dir
+		assert_raise(RuntimeError) { r.translate("./root/dir/file.txt", :not_dir, :another) }
 	end
 	
 	#
@@ -368,22 +487,22 @@ class RootTest < Test::Unit::TestCase
 	#
 	
 	def test_glob_returns_all_files_matching_pattern
-		assert_equal Dir.glob(File.join(root, '*')),  rfs.glob(:root, "*")	
-		assert_equal Dir.glob(File.join(root, '*.txt')),  rfs.glob(:root, "*.txt")	
-		assert_equal Dir.glob(File.join(root, 'lib/*')),  rfs.glob(:lib, "*")	
+		assert_equal Dir.glob(File.join(test_root, '*')),  tr.glob(:root, "*")	
+		assert_equal Dir.glob(File.join(test_root, '*.txt')),  tr.glob(:root, "*.txt")	
+		assert_equal Dir.glob(File.join(test_root, 'lib/*')),  tr.glob(:lib, "*")	
 	end
 
 	def test_default_glob_pattern_is_all_files_and_folders
-		assert_equal Dir.glob(File.join(root, '**/*')),  rfs.glob(:root)
+		assert_equal Dir.glob(File.join(test_root, '**/*')),  tr.glob(:root)
 	end
 	
 	def test_glob_using_multiple_patterns						
-		yml_files = Dir.glob(File.join(root, '**/*.yml'))
-		txt_files = Dir.glob(File.join(root, '**/*.txt'))
+		yml_files = Dir.glob(File.join(test_root, '**/*.yml'))
+		txt_files = Dir.glob(File.join(test_root, '**/*.txt'))
 		
 		assert_equal(
 			(yml_files + txt_files).sort, 
-			rfs.glob(:root, "**/*.yml", "**/*.txt").sort)
+			tr.glob(:root, "**/*.yml", "**/*.txt").sort)
   end
     
   #
@@ -391,93 +510,42 @@ class RootTest < Test::Unit::TestCase
 	#
 	
 	def test_vglob_returns_all_versions_matching_file_and_version_pattern
-    assert_equal 4, Dir.glob(File.join(root, 'versions/*')).length
+    assert_equal 4, Dir.glob(File.join(test_root, 'versions/*')).length
     
-    assert_equal 3, Dir.glob(File.join(root, 'versions/file*.yml')).length
-    assert_equal Dir.glob(File.join(root, 'versions/file*.yml')), rfs.vglob(:versions, 'file.yml', '*')
+    assert_equal 3, Dir.glob(File.join(test_root, 'versions/file*.yml')).length
+    assert_equal Dir.glob(File.join(test_root, 'versions/file*.yml')).sort, tr.vglob(:versions, 'file.yml', '*').sort
     
-    assert_equal 2, Dir.glob(File.join(root, 'versions/file-0.1*.yml')).length
-    assert_equal Dir.glob(File.join(root, 'versions/file-0.1*.yml')), rfs.vglob(:versions, 'file.yml', "0.1*")
+    assert_equal 2, Dir.glob(File.join(test_root, 'versions/file-0.1*.yml')).length
+    assert_equal Dir.glob(File.join(test_root, 'versions/file-0.1*.yml')).sort, tr.vglob(:versions, 'file.yml', "0.1*").sort
     
-    assert_equal 1, Dir.glob(File.join(root, 'versions/file-0.1.yml')).length
-    assert_equal Dir.glob(File.join(root, 'versions/file-0.1.yml')), rfs.vglob(:versions, 'file.yml', "0.1")
+    assert_equal 1, Dir.glob(File.join(test_root, 'versions/file-0.1.yml')).length
+    assert_equal Dir.glob(File.join(test_root, 'versions/file-0.1.yml')).sort, tr.vglob(:versions, 'file.yml', "0.1").sort
     
-    assert_equal 0, Dir.glob(File.join(root, 'versions/file-2.yml')).length
-    assert_equal [], rfs.vglob(:versions, 'file.yml', "2")
+    assert_equal 0, Dir.glob(File.join(test_root, 'versions/file-2.yml')).length
+    assert_equal [], tr.vglob(:versions, 'file.yml', "2")
 	end
   
 	def test_default_vglob_pattern_is_all_versions
-		assert_equal Dir.glob(File.join(root, 'versions/file-*.yml')) + [File.join(root, 'versions/file.yml')], rfs.vglob(:versions, 'file.yml')
+	  expected = Dir.glob(File.join(test_root, 'versions/file-*.yml')) + [File.join(test_root, 'versions/file.yml')]
+		assert_equal expected.sort, tr.vglob(:versions, 'file.yml').sort
 	end
   
   def test_nil_vglob_pattern_matches_the_no_version_file
-		assert_equal [File.join(root, 'versions/file.yml')], rfs.vglob(:versions, 'file.yml', nil)
-    assert_equal [File.join(root, 'versions/file.yml')], rfs.vglob(:versions, 'file.yml', '')
+		assert_equal [File.join(test_root, 'versions/file.yml')], tr.vglob(:versions, 'file.yml', nil)
+    assert_equal [File.join(test_root, 'versions/file.yml')], tr.vglob(:versions, 'file.yml', '')
 	end
 	
 	def test_vglob_using_multiple_verson_patterns						
 		expected = [
-      File.join(root, 'versions/file-0.1.2.yml'),
-      File.join(root, 'versions/file-0.1.yml')]
+      File.join(test_root, 'versions/file-0.1.2.yml'),
+      File.join(test_root, 'versions/file-0.1.yml')]
 		
-		assert_equal expected, rfs.vglob(:versions, "file.yml", "0.1.2", "0.1")
+		assert_equal expected.sort, tr.vglob(:versions, "file.yml", "0.1.2", "0.1").sort
   end
   
   def test_vglob_filters_for_unique_files			
-		expected = [File.join(root, 'versions/file-0.1.2.yml')]
+		expected = [File.join(test_root, 'versions/file-0.1.2.yml')]
 		
-		assert_equal expected, rfs.vglob(:versions, "file.yml", "0.1.2", "0.1.*")
-  end
-  
-  
-  #
-  # mtime tests
-  #
-  
-  def test_mtime_returns_timestamp_of_most_recently_modifed_file_under_dir
-    not_in_dir = File.join(root, 'one.txt')
-    older_in_dir = File.join(root, 'mtime', 'older.txt')
-    newer_in_dir = File.join(root, 'mtime', 'newer.txt')
-    assert !File.exists?(newer_in_dir)
-
-    begin
-      File.open(newer_in_dir, 'w') {|f| f << "newer"}
-      
-      files = [not_in_dir, older_in_dir, newer_in_dir]
-      assert_equal File.mtime(newer_in_dir), rfs.mtime('mtime', *files)
-      assert_equal File.mtime(newer_in_dir), rfs.mtime('mtime', *files.reverse)
-    ensure
-      File.delete(newer_in_dir) if File.exists?(newer_in_dir)
-    end
-  end
-  
-  def test_mtime_returns_nil_if_no_files_are_under_dir
-    not_in_dir = File.join(root, 'one.txt')
-    assert_equal nil, rfs.mtime('mtime', not_in_dir)
+		assert_equal expected, tr.vglob(:versions, "file.yml", "0.1.2", "0.1.*")
   end
-  
-	#
-	# MISSING! open, write_to, read_from tests
-	#
-
-	#
-	# mkpaths tests
-	#
-	
-	def test_mkpaths
-		root_dir = File.join(root, "mkpath_test")
-		rfs = Tap::Root.new(root_dir, :config => 'config')
-		
-		assert !File.exists?(rfs[:root])
-		assert !File.exists?(rfs[:config])
-		
-		begin
-			rfs.mkpaths
-			
-			assert File.exists?(rfs[:root])
-			assert File.exists?(rfs[:config])
-		ensure
-			FileUtils.rm_r(root_dir)
-		end 
-	end
 end