tap 0.8.0 → 0.9.0

data/lib/tap/version.rb

@@ -1,4 +0,0 @@
-module Tap
-  VERSION="0.8.0" 
-  HOMEPAGE="http://tap.rubyforge.org"
-end

data/test/app/config/addition_template.yml

@@ -1,6 +0,0 @@
-factor0: 0
-
-variations!:
-   - factor1: 10
-   - factor0: 1
-     factor1: 20

data/test/app_class_test.rb

@@ -1,33 +0,0 @@
-require  File.join(File.dirname(__FILE__), 'tap_test_helper')
-require 'tap/app'
-
-class AppClassTest < Test::Unit::TestCase
-	include Tap
-
-  #
-  # instance tests
-  #
-  
-  def test_instance_returns_current_instance_or_a_default_app
-    a = App.new
-    App.instance = a
-    assert_equal a, App.instance
-    
-    App.instance = nil
-    assert_equal App, App.instance.class
-  end
-  
-  #
-  # parse_yaml tests
-  #
-  
-  def test_parse_yaml_loads_arg_if_arg_matches_yaml_document_string
-    string = "---\nkey: value"
-    assert_equal({"key" => "value"}, App.parse_yaml(string))
-  end
-  
-  def test_parse_yaml_returns_arg_unless_matches_yaml_document_string
-    string = "key: value"
-    assert_equal("key: value", App.parse_yaml(string))
-  end
-end

data/test/check/binding_eval.rb

@@ -1,23 +0,0 @@
-# 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

@@ -1,22 +0,0 @@
-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

@@ -1,175 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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/support/batch_queue_test.rb

@@ -1,320 +0,0 @@
-require  File.join(File.dirname(__FILE__), '../tap_test_helper')
-require 'tap/support/batch_queue'
-
-class BatchQueueTest < Test::Unit::TestCase
-  
-  # creates readers to facilitate testing
-  module BatchQueueAccessors
-    attr_reader :tasks, :inputs
-  end
-
-  attr_accessor :t, :not_executable, :queue
- 
-  def setup
-    @t = Tap::Task.new
-    @not_executable = Tap::Task.new
-    @not_executable.condition {|task, inputs| false}
-    
-    @queue = Tap::Support::BatchQueue.new
-    @queue.extend BatchQueueAccessors
-  end
-  
-  def test_not_executable_is_not_executable_with_and_without_inputs
-    assert !not_executable.executable?([])
-    assert !not_executable.executable?([:a,:b,:c])
-  end
-  
-  def test_documentation
-    t1 = Tap::Task.new
-    t2 = Tap::Task.new
-    
-    q = Tap::Support::BatchQueue.new
-    q.enq t1, 1
-    q.enq t2, :a,:b,:c
-    q.enq t1, 2,3
-      
-    assert_equal [t1, [1,2,3]], q.deq
-    assert_equal [t2, [:a,:b,:c]], q.deq   
-    assert_nil q.deq    
-  end
-  
-  #
-  # initialization tests
-  #
-  
-  def test_queue_is_empty_and_inputs_and_tasks_cannot_be_accessed
-    q = Tap::Support::BatchQueue.new
-    assert q.empty?
-    assert_raise(NoMethodError) { q.inputs }
-    assert_raise(NoMethodError) { q.tasks }
-  end
-  
-  #
-  # size, length, clear, empty? tests
-  #
-  
-  def test_size_and_length_return_number_of_tasks
-    assert_equal 0, queue.size
-    assert_equal 0, queue.length
-    
-    queue.inputs[t] = [1,2,3]
-    
-    assert_equal 0, queue.size
-    assert_equal 0, queue.length
-    
-    queue.tasks << t
-    
-    assert_equal 1, queue.size
-    assert_equal 1, queue.length
-  end
-  
-  def test_empty_is_true_if_tasks_is_empty
-    assert queue.empty?
-    queue.inputs[t] = [1,2,3]
-    assert queue.empty?
-    queue.tasks << t
-    assert !queue.empty?
-  end
-  
-  def test_clear_resets_tasks_and_inputs
-    assert_equal({}, queue.inputs)
-    assert_equal [], queue.tasks
-    
-    queue.inputs[t] = [1,2,3]
-    queue.tasks << t
-    queue.clear
-    
-    assert_equal({}, queue.inputs)
-    assert_equal [], queue.tasks
-  end
-  
-  #
-  # queue test
-  #
-  
-  def test_enq_pushes_task_onto_tasks
-    t1 = Tap::Task.new
-    t2 = Tap::Task.new
-    assert_equal [], queue.tasks
-    
-    queue.enq(t1)
-    assert_equal [t1], queue.tasks
-    
-    queue.enq(t2)
-    assert_equal [t1, t2], queue.tasks
-  end
-  
-  def test_enq_concats_inputs_to_inputs
-    assert_equal nil, queue.inputs[t]
-    
-    queue.enq(t,1)
-    assert_equal [1], queue.inputs[t]
-    
-    queue.enq(t,2,3)
-    assert_equal [1,2,3], queue.inputs[t]
-  end
-  
-	def test_enq_does_not_push_task_onto_tasks_if_it_is_already_in_the_queue
-    t1 = Tap::Task.new
-    t2 = Tap::Task.new
-    queue.tasks << t1
-    queue.tasks << t2
-    assert_equal [t1,t2], queue.tasks
-    
-    queue.enq(t1)
-    assert_equal [t1,t2], queue.tasks
-  end
-  
-  def test_enq_queues_batch_if_task_is_batched
-    t.batch << t.dup
-    assert_equal [], queue.tasks
-    
-    queue.enq(t)
-    assert_equal t.batch, queue.tasks
-  end
-  
-  def test_enq_forks_inputs_if_necessary_for_batch
-    t.batch << t.dup
-    
-    a = Tap::Support::Audit.new(2)
-    queue.enq(t, 1, a)
-    
-    audits = []
-    t.batch.each do |task|
-      assert_equal [1, a], queue.inputs[task]
-      audits << queue.inputs[task].last
-    end
-    
-    # if the object ids of these audits are not equal, but they
-    # evaluate to equal, we can safely assume they're forked.
-    assert_equal 2, audits.length
-    assert_equal audits.first, audits.last
-    assert_not_equal audits.first.object_id, audits.last.object_id
-  end
-  
-  #
-  # priority_enq test
-  #
-  
-  def test_priority_enq_shifts_task_onto_tasks
-    t1 = Tap::Task.new
-    t2 = Tap::Task.new
-    assert_equal [], queue.tasks
-    
-    queue.priority_enq(t1)
-    assert_equal [t1], queue.tasks
-    
-    queue.priority_enq(t2)
-    assert_equal [t2, t1], queue.tasks
-  end
-  
-  #
-  # prioritize test
-  #
-  
-  def test_prioritize_moves_task_to_the_front_of_the_queue
-    t1 = Tap::Task.new
-    t2 = Tap::Task.new
-    queue.tasks << t1
-    queue.tasks << t2
-    assert_equal [t1,t2], queue.tasks
-    
-    queue.prioritize(t2)
-    assert_equal [t2,t1], queue.tasks
-  end
-  
-  def test_prioritize_does_not_insert_the_task_if_the_task_is_not_in_the_queue
-    assert_equal [], queue.tasks
-    
-    queue.prioritize(t)
-    assert_equal [], queue.tasks
-  end
-  
-  def test_prioritize_prioritizes_each_task_in_a_batch_in_order
-    t1 = Tap::Task.new
-    t2 = Tap::Task.new
-    t2.batch << t2.dup
-    
-    queue.tasks << t1
-    queue.tasks.concat t2.batch
-    
-    assert_equal [t1] + t2.batch, queue.tasks
-    
-    queue.prioritize(t2)
-    assert_equal t2.batch + [t1], queue.tasks
-  end
-  
-  #
-  # marginalize test
-  #
-  
-  def test_marginalize_moves_task_to_the_front_of_the_queue
-    t1 = Tap::Task.new
-    t2 = Tap::Task.new
-    queue.tasks << t1
-    queue.tasks << t2
-    assert_equal [t1,t2], queue.tasks
-    
-    queue.marginalize(t1)
-    assert_equal [t2,t1], queue.tasks
-  end
-  
-  def test_marginalizeoes_not_insert_the_task_if_the_task_is_not_in_the_queue
-    assert_equal [], queue.tasks
-    
-    queue.marginalize(t)
-    assert_equal [], queue.tasks
-  end
-  
-  def test_marginalize_marginalizes_each_task_in_a_batch_in_order
-    t1 = Tap::Task.new
-    t2 = Tap::Task.new
-    t2.batch << t2.dup
-    
-    queue.tasks.concat t2.batch
-    queue.tasks << t1
-    
-    assert_equal t2.batch + [t1], queue.tasks
-    queue.marginalize(t2)
-    assert_equal [t1] + t2.batch, queue.tasks
-  end
-  
-  #
-  # executable? tests
-  #
-  
-  def test_executable_true_if_task_is_executable_with_current_inputs
-    t.condition {|task, inputs| inputs && inputs.length > 1 }
-    
-    assert !queue.executable?(t)
-    queue.enq t,1
-    assert !queue.executable?(t)
-    queue.enq t,2
-    assert queue.executable?(t)
-  end
-  
-  #
-  # deq test
-  #
-  
-  def test_deq_returns_the_next_executable_task_and_inputs
-    queue.enq not_executable, :a,:b,:c
-    queue.enq t,1,2,3
-    
-    assert_equal [t, [1,2,3]], queue.deq
-    assert !queue.empty?
-  end
-  
-  def test_deq_returns_the_specified_task_even_if_not_executable
-    queue.enq t,1,2,3
-    queue.enq not_executable, :a,:b,:c
-    
-    assert_equal [not_executable, [:a,:b,:c]], queue.deq(not_executable)
-    assert !queue.empty?
-  end
-  
-  def test_deq_with_no_inputs_returns_empty_array_as_inputs
-    queue.enq t
-    assert_equal [t, []], queue.deq
-  end
-
-  #
-  # peek test
-  #
-  
-  def test_peek_returns_the_next_executable_task_and_does_not_dequeue_the_task 
-    queue.enq not_executable
-    queue.enq t
-    
-    assert_equal t, queue.peek
-    assert_equal 2, queue.size
-  end
-  
-  def test_peek_returns_nil_if_no_tasks_are_executable
-    assert_equal nil, queue.peek
-    
-    queue.enq not_executable
-
-    assert_equal nil, queue.peek
-  end
-  
-  #
-  # num_executable test
-  #
-  
-  def test_num_executable_returns_number_of_queued_executable_tasks
-    assert_equal 0, queue.num_executable
-    queue.enq not_executable
-    assert_equal 0, queue.num_executable
-    queue.enq t
-    assert_equal 1, queue.num_executable
-  end
-  
-  def test_num_not_executable_returns_number_of_queued_non_executable_tasks
-    assert_equal 0, queue.num_not_executable
-    queue.enq t
-    assert_equal 0, queue.num_not_executable
-    queue.enq not_executable
-    assert_equal 1, queue.num_not_executable
-  end
-end