tap 0.8.0 → 0.9.0

data/test/env/test_configure/recurse_a.yml

@@ -0,0 +1,2 @@
+load_paths: a
+config_paths: recurse_b.yml

data/test/env/test_configure/recurse_b.yml

@@ -0,0 +1,2 @@
+load_paths: b
+config_paths: recurse_a.yml

data/test/env/test_configure/tap.yml

@@ -0,0 +1,23 @@
+######################################################
+# App Configurations:
+######################################################
+
+directories:                  
+  rel: dir
+
+options:                      
+  quiet: true
+  
+######################################################
+# Env Configurations:
+######################################################
+
+load_paths: [lib, rel]
+
+command_paths:
+  - cmd
+
+config_paths: recurse_a.yml
+
+before: |
+  before

data/test/env/test_load_env_config/dir/tap.yml

@@ -0,0 +1,3 @@
+load_paths: [lib, nested/lib]
+command_paths: [cmd, nested/cmd]
+load_once_paths: [lop.rb, nested/lop.rb]

data/test/env/test_load_env_config/recurse_a.yml

@@ -0,0 +1,2 @@
+config_paths: recurse_b.yml
+load_paths: lib

data/test/env/test_load_env_config/recurse_b.yml

@@ -0,0 +1,2 @@
+config_paths: recurse_a.yml
+load_paths: nested/lib

data/test/env/test_load_env_config/tap.yml

@@ -0,0 +1,3 @@
+load_paths: [lib, nested/lib]
+command_paths: [cmd, nested/cmd]
+load_once_paths: [lop.rb, nested/lop.rb]

data/test/env_test.rb

@@ -0,0 +1,198 @@
+require File.join(File.dirname(__FILE__), 'tap_test_helper')
+require 'tap/env'
+
+class ConfigurationTest < Test::Unit::TestCase
+  include Tap::Env::Configuration
+  
+  acts_as_file_test
+  
+  #
+  # read_config test 
+  #
+  
+  def test_read_config_templates_then_loads_config
+    config_file = output_tempfile
+    
+    File.open(config_file, "wb") {|f| f << "sum: <%= 1 + 2 %>" }
+    assert_equal({'sum' => 3}, read_config(config_file))
+  end
+  
+  def test_read_config_returns_empty_hash_for_non_existant_nil_and_false_files
+    config_file = output_tempfile
+    
+    assert !File.exists?(config_file)
+    assert_equal({}, read_config(config_file))
+    
+    FileUtils.touch(config_file)
+    assert_equal({}, read_config(config_file))
+    
+    File.open(config_file, "wb") {|f| f << nil.to_yaml }
+    assert_equal(nil, YAML.load_file(config_file))
+    assert_equal({}, read_config(config_file))
+    
+    File.open(config_file, "wb") {|f| f << false.to_yaml }
+    assert_equal(false, YAML.load_file(config_file))
+    assert_equal({}, read_config(config_file))
+  end
+  
+  def test_read_config_raises_error_for_non_hash_result
+    config_file = output_tempfile
+    File.open(config_file, "wb") {|f| f << [].to_yaml }
+    
+    assert_raise(RuntimeError) { read_config(config_file) }
+  end
+  
+  #
+  # partition_configs test
+  #
+  
+  def test_partition_configs
+    config = {'before' => :b, 'gems' => :g, 'root' => :r, 'another' => :a}
+    
+    env, app, other = partition_configs(config, ['gems'], ['root', 'another'])
+    assert_equal({'gems' => :g}, env)
+    assert_equal({'root' => :r, 'another' => :a}, app)
+    assert_equal({'before' => :b}, other)
+  end
+  
+  #
+  # join_configs test
+  #
+  
+  def test_join_configs
+    a = {:a => 1, :b => [1]}
+    b = {:a => [2], :b => [1]}
+    c = {:c => 1}
+    
+    assert_equal({:a => [1, 2], :b => [1], :c => [1]}, join_configs(a,b,c))
+    assert_equal({:a => [2, 1], :b => [1], :c => [1]}, join_configs(c,b,a))
+  end
+end
+
+class EnvTest < Test::Unit::TestCase
+  
+  acts_as_file_test
+  attr_accessor :e
+  
+  def setup
+    super
+    @e = Tap::Env.instance
+    e.reset
+  end
+  
+  def teardown
+    super
+    e.reset
+  end
+  
+  #
+  # load_env_config test
+  #
+  
+  def test_load_env_config
+    empty_config = {
+      "load_paths" => [],
+      "load_once_paths" => [],
+      "config_paths" => [],
+      "command_paths" => [],
+      "gems" => [],
+      "generator_paths" => []
+    }
+    starting_load_paths = $:.uniq
+    
+    assert_equal(empty_config, e.config)
+    assert Dependencies.load_paths.empty?
+    assert Dependencies.load_once_paths.empty?
+  
+    # test specifying a file
+    assert File.exists?(method_filepath('tap.yml'))
+    e.load_config(method_filepath('tap.yml'))
+    
+    assert_equal({
+      "load_paths" => [method_filepath('lib'), method_filepath('nested/lib')],
+      "load_once_paths" => [method_filepath('lop.rb'), method_filepath('nested/lop.rb')],
+      "config_paths" => [method_filepath('tap.yml')],
+      "command_paths" => [method_filepath('cmd'), method_filepath('nested/cmd')],
+      "gems" => [],
+      "generator_paths" => [method_filepath('lib/generators')]
+    }, e.config)
+    
+    assert_equal [], e.config['load_paths'] - $:
+    assert_equal e.config['load_paths'], Dependencies.load_paths
+    assert_equal e.config['load_once_paths'], Dependencies.load_once_paths
+
+    # test specifying a dir
+    assert File.exists?(method_filepath('dir', 'tap.yml'))
+    e.load_config(method_filepath('dir'))
+    
+    assert_equal({
+      "load_paths" => [method_filepath('dir/lib'), method_filepath('dir/nested/lib'), method_filepath('lib'), method_filepath('nested/lib')],
+      "load_once_paths" => [ method_filepath('dir/lop.rb'), method_filepath('dir/nested/lop.rb'), method_filepath('lop.rb'), method_filepath('nested/lop.rb')],
+      "config_paths" => [method_filepath('tap.yml'), method_filepath('dir', 'tap.yml')],
+      "command_paths" => [method_filepath('dir/cmd'), method_filepath('dir/nested/cmd'), method_filepath('cmd'), method_filepath('nested/cmd')],
+      "gems" => [],
+      "generator_paths" => [method_filepath('dir/lib/generators'), method_filepath('lib/generators')]
+    }, e.config)
+    
+    assert_equal [], e.config['load_paths'] - $:
+    assert_equal e.config['load_paths'], Dependencies.load_paths
+    assert_equal e.config['load_once_paths'], Dependencies.load_once_paths
+
+    # add extra Dependencies load paths to be sure ONLY the ENV load paths are cleared
+    Dependencies.load_paths << 'extra'
+    Dependencies.load_once_paths << 'extra'
+    
+    # test reset
+    e.reset
+    assert_equal(empty_config, e.config)
+    assert_equal ['extra'], Dependencies.load_paths
+    assert_equal ['extra'], Dependencies.load_once_paths
+    assert_equal starting_load_paths, $:
+    
+    # test recursion/config_path loading
+    pwd = Dir.pwd
+    begin
+      Dir.chdir(method_root)
+      e.load_config('recurse_a.yml')
+    ensure
+      Dir.chdir(pwd)
+    end
+    
+    assert_equal [method_filepath('lib'), method_filepath('nested/lib')], e.config['load_paths']
+    assert_equal [method_filepath('recurse_a.yml'), method_filepath('recurse_b.yml')], e.config['config_paths']
+  end
+  
+  #
+  # configure test
+  #
+  
+  # def test_configure
+  #   assert e.load_paths.empty?
+  #   assert e.command_paths.empty?
+  #   assert e.load_once_paths.empty?
+  #   assert e.config_paths.empty?
+  #   assert_nil e.before
+  #   assert_nil e.after
+  #   assert_equal Tap::App.instance, e.app
+  #   
+  #   pwd = Dir.pwd
+  #   begin
+  #     Dir.chdir(method_root)
+  #     e.configure
+  #   ensure
+  #     Dir.chdir(pwd)
+  #   end
+  #   
+  #   app = e.app
+  # 
+  #   assert_equal [method_filepath('lib'), method_filepath('dir'), method_filepath('a'), method_filepath('b')], e.load_paths
+  #   assert_equal [method_filepath('cmd')], e.command_paths
+  #   assert_equal [], e.load_once_paths
+  #   assert_equal [method_filepath('tap.yml'), method_filepath('recurse_a.yml'), method_filepath('recurse_b.yml')], e.config_paths
+  #   assert_equal "before\n", e.before
+  #   assert_equal nil, e.after
+  #   
+  #   assert_equal({'rel' => 'dir'}, app.directories)
+  #   assert app.options.quiet
+  # end
+end

data/test/file_task_test.rb

@@ -9,6 +9,7 @@ class FileTaskTest < Test::Unit::TestCase
 	def setup
 	  super
 	  @t = Tap::FileTask.new
+	  app.root = trs.root
 	end
 	
 	def touch_file(path, content=nil)
@@ -47,7 +48,7 @@ class FileTaskTest < Test::Unit::TestCase
     FileUtils.mkdir_p( method_filepath(:output) )
     
     File.open(file_one, "w") {|f| f << "original content"}
-    t = Tap::FileTask.new do |task, inputs|
+    t = Tap::FileTask.new do |task|
       task.mkdir(dir)                      
       task.prepare([file_one, file_two]) 
       
@@ -60,7 +61,7 @@ class FileTaskTest < Test::Unit::TestCase
     begin
       assert !File.exists?(dir)        
       assert !File.exists?(file_two)        
-      t.execute(nil)
+      t.execute
       flunk "no error raised"
     rescue
       assert_equal "error!", $!.message
@@ -69,105 +70,113 @@ class FileTaskTest < Test::Unit::TestCase
       assert_equal "original content", File.read(file_one)  
     end
   end
-
-  #
+	
+	#
+	# dirname tests
+	#
+	
+	def test_dirname_returns_default_dirname_by_default
+	  assert_equal "tap/file_task", t.dirname
+	
+	  t = Tap::FileTask.new "batch"
+	  assert_equal 2, t.batch.size
+	  t1, t2 = t.batch
+	  assert_equal "batch_0", t1.dirname
+	  assert_equal "batch_1", t2.dirname
+	end
+	
+	def test_dirname_returns_dirname_if_set
+	  t.dirname = "name"
+	  assert_equal "name", t.dirname
+	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|
+
+    t.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|
+    t.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|
+  
+    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(method_filepath(:output))
-    
+  
     list = [0, 1].collect do |n| 
       path = method_filepath(:output, "#{n}.txt")
       path
     end
-    
-    Tap::FileTask.open(list, "w") do |files|
+  
+    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(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|
+
+    t.open(list).each_with_index do |file, n|
       assert_equal File, file.class
       assert_equal n.to_s, file.read
       file.close
     end
   end
-	
-	#
-	# dirname tests
-	#
-	
-	def test_dirname_returns_default_dirname_by_default
-	  assert_equal "tap/file_task", t.dirname
-	
-	  t = Tap::FileTask.new "batch"
-	  assert_equal 2, t.batch.size
-	  t1, t2 = t.batch
-	  assert_equal "batch_0", t1.dirname
-	  assert_equal "batch_1", t2.dirname
-	end
-	
-	def test_dirname_returns_dirname_if_set
-	  t.dirname = "name"
-	  assert_equal "name", t.dirname
-	end
+
+  #
+  # basename test
+  #
+
+  def test_basename_doc
+    assert_equal 'file.txt', t.basename('path/to/file.txt')
+    assert_equal 'file.html', t.basename('path/to/file.txt', '.html')
+  end
 	
 	#
 	# inference tests
@@ -235,9 +244,8 @@ class FileTaskTest < Test::Unit::TestCase
   # backup_filepath test
   #
   
-  def btest_backup_filepath_documentation
-  
-    t = FileTask.new("dir/name", :backup_dir => :backup, :backup_timestamp => "%Y%m%d")
+  def test_backup_filepath_documentation
+    t = Tap::FileTask.new("dir/name", :backup_dir => :backup, :backup_timestamp => "%Y%m%d")
     t.app[:backup]                                 # => "/backup"
     Date.today.to_s                                # => "2007-08-08"
   
@@ -262,7 +270,16 @@ class FileTaskTest < Test::Unit::TestCase
       app.filepath(:output, t.name, "file_#{timestamp}.txt"), 
       t.backup_filepath("file.txt"))
   end
+  
+  def test_backup_dir_can_be_full_path
+    timestamp = prepare_backup_filepath_with_output_and_timestamp
+    
+    t.backup_dir = File.expand_path('path/to/backup', Dir.pwd)
     
+    expected_path = File.join('path/to/backup', t.name,"file_#{timestamp}.txt")
+    assert_equal(File.expand_path(expected_path, Dir.pwd), t.backup_filepath("file.txt"))
+  end
+  
   def test_backup_filepath_uses_inference_block
     timestamp = prepare_backup_filepath_with_output_and_timestamp
     
@@ -321,10 +338,10 @@ class FileTaskTest < Test::Unit::TestCase
 		of1 = trs.filepath(:root, 'old_file_one.txt')
 		of2 = trs.filepath(:root, 'old_file_two.txt')
 		
-		nf1 = tempfile('new_file_one.txt')
+		nf1 = output_tempfile('new_file_one.txt')
 		File.open(nf1, "w") {|file| file << output_str}
 		
-		nf2 = tempfile('new_file_two.txt')
+		nf2 = output_tempfile('new_file_two.txt')
 		File.open(nf2, "w") {|file| file << output_str}
 		
 		[of1, of2, nf1, nf2]
@@ -335,10 +352,10 @@ class FileTaskTest < Test::Unit::TestCase
 		files.each { |file| assert File.exists?(file), file }
 
 		of1, of2, nf1, nf2 = files
-		assert FileUtils.uptodate?(nf1, of1)
-		assert FileUtils.uptodate?(nf2, of1)
-		assert FileUtils.uptodate?(nf1, of2)
-		assert FileUtils.uptodate?(nf2, of2)
+		assert FileUtils.uptodate?(nf1, [of1])
+		assert FileUtils.uptodate?(nf2, [of1])
+		assert FileUtils.uptodate?(nf1, [of2])
+		assert FileUtils.uptodate?(nf2, [of2])
 	end
 
 	def test_uptodate