tap 0.7.9

data/test/root/alt_lib/alt_module.rb

@@ -0,0 +1,4 @@
+# =:Key:Value
+#
+module AltModule
+end

data/test/root/lib/absolute_alt_filepath.rb

@@ -0,0 +1,2 @@
+module AbsoluteAlternativeFilepathModule
+end

data/test/root/lib/alternative_filepath.rb

@@ -0,0 +1,2 @@
+module AlternativeFilepathModule
+end

data/test/root/lib/another_module.rb

@@ -0,0 +1,2 @@
+module AnotherModule
+end

data/test/root/lib/nested/some_module.rb

@@ -0,0 +1,4 @@
+module Nested
+module SomeModule
+end
+end

data/test/root/lib/some/module.rb

@@ -0,0 +1,4 @@
+module Some
+  module Module
+  end
+end

data/test/root/lib/some_class.rb

@@ -0,0 +1,2 @@
+class SomeClass
+end

data/test/root/lib/some_module.rb

@@ -0,0 +1,3 @@
+module SomeModule
+end
+puts "in some module"

data/test/root/load_path/load_path_module.rb

@@ -0,0 +1,2 @@
+module LoadPathModule
+end

data/test/root/load_path/skip_module.rb

@@ -0,0 +1,2 @@
+module SkipModule
+end

data/test/root/unload/full_path.rb

@@ -0,0 +1,2 @@
+module FullPath
+end

data/test/root/unload/loaded_by_nested.rb

@@ -0,0 +1,2 @@
+module LoadedByNested
+end

data/test/root/unload/nested/nested_load.rb

@@ -0,0 +1,6 @@
+require File.dirname(__FILE__) + "/../loaded_by_nested.rb"
+
+module Nested
+  module NestedLoad
+  end
+end

data/test/root/unload/nested/nested_with_ext.rb

@@ -0,0 +1,4 @@
+module Nested
+  module NestedWithExt
+  end
+end

data/test/root/unload/nested/relative_path.rb

@@ -0,0 +1,4 @@
+module Nested
+  module RelativePath
+  end
+end

data/test/root/unload/older.rb

@@ -0,0 +1,2 @@
+module Older
+end

data/test/root/unload/unload_base.rb

@@ -0,0 +1,9 @@
+require File.expand_path(File.dirname(__FILE__) + "/full_path.rb")
+require File.dirname(__FILE__) + "/../unload/nested/relative_path.rb"
+
+# these will be loaded when the nested directory is on the load path
+require "nested_load"
+require "nested_with_ext.rb"
+
+module UnloadBase
+end

data/test/root_test.rb

@@ -0,0 +1,483 @@
+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
+	
+	def setup
+		@ifs = Tap::Root.new "./root", {:dir => "dir"}, {:abs => '/abs/path'}
+		@rfs = Tap::Root.new root, {:lib => "lib"}
+	end
+	
+	def root 
+		File.join(File.dirname(__FILE__), 'root')
+	end
+	
+	def test_documentation
+	  root = Tap::Root.new self.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]   
+  
+    #  # 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)                 
+     
+    #  # 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')                 
+    
+    #  # 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')     
+	end
+	
+	#
+	# Tap::Root relative filepath test
+	#
+	
+	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")
+	end
+
+	def test_class_relative_filepath_expands_paths
+		assert_equal "file.txt", Tap::Root.relative_filepath('./root/dir', "./root/folder/.././dir/file.txt")
+		assert_equal "file.txt", Tap::Root.relative_filepath('./root/dir', "root/dir/file.txt")
+		assert_equal "file.txt", Tap::Root.relative_filepath('root/dir', "./root/dir/file.txt")
+	end
+		
+	def test_class_relative_filepath_raises_error_if_path_is_not_relative_to_dir
+		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)
+	end
+  
+	#
+	# initialize tests
+	#
+	
+	def test_defualt_root_is_dir_pwd
+		ifs = Tap::Root.new
+		
+		assert_equal Dir.pwd, ifs.root
+		assert_equal({}, ifs.directories)
+	end
+	
+	def test_initialize_root
+		ifs = 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({
+		  'root' => "./root", 
+		  :root => "./root", 
+		  :dir => "./root/dir", 
+		  :temp => "./root/tmp", 
+		  :abs => "/abs/path"}, 
+		ifs.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')
+		
+		assert_equal({
+		  'root' => "./root", 
+		  :root => "./root", 
+			'dir' => "./root/str_dir", 
+			:dir => "./root/sym_dir", 
+			1 => "./root/n_dir"}, 
+		ifs.paths)
+	end
+	
+	#
+	# set root tests
+	#
+	
+	def test_set_root_resets_paths
+		ifs.root = './another'
+		
+		assert_equal "./another", ifs.root
+		assert_equal({:dir => "dir"}, ifs.directories)
+		assert_equal({
+		  'root' => "./another", 
+		  :root => "./another", 
+		  :dir => "./another/dir", 
+		  :abs => "/abs/path"}, 
+		ifs.paths)
+	end
+	
+	def test_root_cannot_be_set_through_index
+		assert_raise(ArgumentError) { ifs['root'] = './another' }
+	end
+	
+	#
+	# set directories tests
+	#
+		
+	def test_set_directories
+		ifs.directories = {:alt => "dir"}
+
+		assert_equal({:alt => "dir"}, ifs.directories)
+		assert_equal({'root' => "./root", :root => "./root", :alt => "./root/dir", :abs => "/abs/path"}, ifs.paths)
+	end
+	
+	def test_raise_error_when_trying_to_set_root_through_directories
+		assert_raise(ArgumentError) { ifs.directories = {'root' => "another"} }
+	end
+	
+	#
+	# set absolute paths test
+	#
+	
+	def test_set_absolute_paths
+		ifs.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)
+	end
+	
+	def test_raise_error_when_trying_to_set_root_through_absolute_paths
+		assert_raise(ArgumentError) { ifs.absolute_paths = {'root' => "another"} }
+	end
+	
+	#
+	# get absolute paths test
+	#
+	
+	def test_absolute_paths_returns_all_non_root_paths_with_no_directory
+	  assert_equal({:abs => "/abs/path"}, ifs.absolute_paths)
+	  
+	  ifs.paths[:another] = "/another/path"
+	  assert_equal({:abs => "/abs/path", :another => "/another/path"}, ifs.absolute_paths)
+	end
+	
+	#
+	# set path tests
+	#
+	
+	def test_set_existing_directory_using_index
+		ifs[:dir] = 'another'
+		
+		assert_equal({:dir => "another"}, ifs.directories)
+		assert_equal({
+		  'root' => "./root", 
+		  :root => "./root", 
+		  :dir => "./root/another", 
+		  :abs => "/abs/path"}, 
+		ifs.paths)
+	end
+	
+	def test_set_new_directory_using_index
+		ifs[:new] = 'new'
+
+		assert_equal({:dir => "dir", :new => "new"}, ifs.directories)
+		assert_equal({
+		  'root' => "./root", 
+		  :root => "./root", 
+		  :dir => "./root/dir",
+		  :abs => "/abs/path", 
+		  :new => "./root/new"}, 
+		ifs.paths)
+	end
+
+  def test_absolute_paths_can_be_set_by_specifiying_absolute_true
+    ifs[:absolute, true] = '/some/absolute/path'
+    
+		assert_equal({:dir => "dir"}, ifs.directories)
+		assert_equal({
+		  'root' => "./root", 
+		  :root => "./root", 
+		  :dir => "./root/dir",
+		  :abs => "/abs/path", 
+		  :absolute => '/some/absolute/path'},
+		ifs.paths)
+  end
+  
+  def test_an_absolute_path_is_not_set_if_absolute_false
+    ifs[:not_absolute, false] = 'not/an/absolute/path'
+    
+		assert_equal({:dir => "dir", :not_absolute => "not/an/absolute/path"}, ifs.directories)
+		assert_equal({
+		  'root' => "./root", 
+		  :root => "./root", 
+		  :dir => "./root/dir", 
+		  :abs => "/abs/path", 
+		  :not_absolute => "./root/not/an/absolute/path"}, 
+		ifs.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)
+		
+    ifs[:dir] = nil
+    assert_equal({}, ifs.directories)
+		assert_equal({'root' => "./root", :root => "./root", :abs => "/abs/path"}, ifs.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)
+    
+    ifs[:dir, false] = nil
+    assert_equal({}, ifs.directories)
+		assert_equal({'root' => "./root", :root => "./root", :abs => "/abs/path"}, ifs.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)
+    
+    ifs[:abs, true] = nil
+    assert_equal({}, ifs.directories)
+		assert_equal({'root' => "./root", :root => "./root"}, ifs.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)
+    
+    ifs[:abs] = nil
+    assert_equal({}, ifs.directories)
+		assert_equal({'root' => "./root", :root => "./root"}, ifs.paths)
+  end
+  
+	#
+	# retrieve path tests
+	#
+	
+	def test_retrieve_paths
+		case_test(
+			:dir => "./root/dir",
+			:root => "./root",
+			'root' => "./root",
+			:abs => "/abs/path"
+		) do |dir, expected|
+			assert_equal expected, ifs[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']
+	end
+
+	#
+	# filepath tests
+	#
+	
+	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")
+	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")
+	end
+	
+	#
+	# relative filepath tests
+	#
+	
+	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")
+	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/")
+	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")
+	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")
+	end
+	
+	def test_relative_filepath_raises_error_if_path_is_not_relative_to_dir
+		assert_raise(RuntimeError) { ifs.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)
+	end
+  
+	#
+	# translate tests
+	#
+	
+	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)
+	end
+	
+	#
+	# glob tests
+	#
+	
+	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, "*")	
+	end
+
+	def test_default_glob_pattern_is_all_files_and_folders
+		assert_equal Dir.glob(File.join(root, '**/*')),  rfs.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'))
+		
+		assert_equal(
+			(yml_files + txt_files).sort, 
+			rfs.glob(:root, "**/*.yml", "**/*.txt").sort)
+  end
+    
+  #
+	# vglob tests
+	#
+	
+	def test_vglob_returns_all_versions_matching_file_and_version_pattern
+    assert_equal 4, Dir.glob(File.join(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 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 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 0, Dir.glob(File.join(root, 'versions/file-2.yml')).length
+    assert_equal [], rfs.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')
+	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', '')
+	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')]
+		
+		assert_equal expected, rfs.vglob(:versions, "file.yml", "0.1.2", "0.1")
+  end
+  
+  def test_vglob_filters_for_unique_files			
+		expected = [File.join(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)
+  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