tap 0.8.0 → 0.9.0

data/test/support/combinator_test.rb

@@ -1,249 +0,0 @@
-require  File.join(File.dirname(__FILE__), '../tap_test_helper')
-require 'tap/support/combinator'
-
-class CombinatorTest < Test::Unit::TestCase
-	include Tap::Support
-	include Tap::Test::SubsetMethods
-	include Benchmark
-	
-	def test_documentation
-	  c = Combinator.new [1,2], [3,4]
-    assert_equal [[1,3], [1,4], [2,3], [2,4]], c.collect        
-    
-    c = Combinator.new [1,2], [3,4], [5,6]
-    assert_equal [[1],[2]], c.a             
-    assert_equal Combinator, c.b.class      
-    assert_equal [[3],[4]], c.b.a    
-    assert_equal [[5],[6]], c.b.b    
-	end
-	
-	#
-	# initialize tests
-	#
-	
-	def test_initialize
-		c = Combinator.new
-		assert_equal [], c.a
-		assert_equal [], c.b
-		
-	  {
-			[[1], [2,3], [3, [4]]] =>[[[1]], [[2], [3]], [[3],[[4]]]], 	# arrays have each element arrayified 
-			[nil, nil, nil] => [[], [], []],		                        # nil returns an empty array
-			[[], [{:one => 1},nil], nil] => [[], [[{:one => 1}],[nil]], []]	    # mixture
-		}.each_pair do |sets, expected|
-			c = Combinator.new(*sets)
-			assert_equal expected[0], c.a
-			assert_equal Combinator, c.b.class
-			assert_equal expected[1], c.b.a
-			assert_equal expected[2], c.b.b	
-		end
-	end
-	
-	def test_initialize_raises_error_unless_sets_are_all_arrays_combinators_or_nil
-	  [
-	    [1], 
-	    [[], 1], 
-	    [1,[]]
-	  ].each do |sets|
-	    assert_raise(ArgumentError) { Combinator.new(*sets) }
-	  end
-	end
-
-	#
-	# sets test
-	#
-	 
-	def test_sets_returns_input_sets_minus_nil_or_empty_arrays
-	  [
-	    [],
-	    [[1]],
-	    [[1], [2]],
-	    [[1], [2,3], [4,5,6]],
-	    [[1], [2,[3]], [4,5,6]],
-	    [[1], nil, [], [4,5,6], nil]
-	  ].each do |sets|
-	    expected = sets.reject {|s| s.nil? || s.empty? }
-	    assert_equal expected, Combinator.new(*sets).sets, PP.singleline_pp(sets, "")
-	  end
-	end
-	
-	#
-	# length test
-	#
-	
-	def test_length
-	  {
-	    [] => 0,
-	    [[1]] => 1,
-	    [[1], [2]] => 1,
-	    [[1],[2],[3]] => 1,
-	    [[1],[], nil,[3]] => 1,
-	    
-	    [[1,2]] => 2,
-	    [[1], [2,3]] => 2,
-	    [[1,2], [3,4]] => 4,
-	    [[1,2], [3,4], [5,6]] => 8,
-	    [[1,2], nil, [3,4], [], [5,6]] => 8
-	  }.each_pair do |sets, expected|
-	    assert_equal expected, Combinator.new(*sets).length, PP.singleline_pp(sets, "")
-	  end
-	end
-	
-	#
-	# each tests
-	#
-	
-	def test_each
-	  {
-  	  [[1]] => [[1]],
-      [[1], [2]] => [[1,2]],
-      [[1],[2],[3]] => [[1,2,3]],
-      [[1],[], nil,[3]] => [[1,3]],
-    
-      [[1,2]] => [[1],[2]],
-      [[1], [2,3]] => [[1,2], [1,3]],
-      [[1,2], [3,4]] => [[1,3],[1,4],[2,3],[2,4]],
-      [[1,2], [3,4], [5,6]] => [[1,3,5],[1,3,6],[1,4,5],[1,4,6],[2,3,5],[2,3,6],[2,4,5],[2,4,6]],
-      [[1,2], nil, [3,4], [], [5,6]] => [[1,3,5],[1,3,6],[1,4,5],[1,4,6],[2,3,5],[2,3,6],[2,4,5],[2,4,6]]
-	  }.each_pair do |set, expected|
-	    comb = Combinator.new(*set)
-	    
-  		combinations = []
-  		comb.each { |c| combinations << c }
-  		assert_equal expected, combinations, PP.singleline_pp(set, "")
-	  end
-	end
-	
-	def test_each_with_deferencing
-		comb = Combinator.new([1], [2,3])
-		combinations = []
-		comb.each { |a,b| combinations << [a,b] }
-		
-		assert_equal [[1,2], [1,3]], combinations
-	end
-
-  #
-  # collect test
-  #
-
-	def test_collect
-		comb = Combinator.new([0,1], [0,1])
-		expected = [[0,0],[0,1],[1,0],[1,1]].collect { |c| c << 2 }
-		assert_equal expected, comb.collect { |c| c << 2 }
-	end
-
-	def test_collect_returns_all_if_no_block_given
-		comb = Combinator.new([0,1], [0,1])
-		assert_equal [[0,0],[0,1],[1,0],[1,1]], comb.collect
-	end
-	
-	#
-	# additional tests
-	#
-	
-	def test_combinator_3_by_3_by_3
-		comb = Combinator.new([0,1,2], [0,1,2], [0,1,2])
-		expected = [
-		[0, 0, 0],
-		[0, 0, 1],
-		[0, 0, 2],
-		[0, 1, 0],
-		[0, 1, 1],
-		[0, 1, 2],
-		[0, 2, 0],
-		[0, 2, 1],
-		[0, 2, 2],
-		[1, 0, 0],
-		[1, 0, 1],
-		[1, 0, 2],
-		[1, 1, 0],
-		[1, 1, 1],
-		[1, 1, 2],
-		[1, 2, 0],
-		[1, 2, 1],
-		[1, 2, 2],
-		[2, 0, 0],
-		[2, 0, 1],
-		[2, 0, 2],
-		[2, 1, 0],
-		[2, 1, 1],
-		[2, 1, 2],
-		[2, 2, 0],
-		[2, 2, 1],
-		[2, 2, 2],
-		]
-		
-		assert_equal 3*3*3, comb.length
-		assert_equal expected, comb.collect
-	end
-	
-	def test_combinator_3_by_2_by_3
-		comb = Combinator.new([0,1,2], [0,1], [0,1,2])
-		expected = [
-		[0, 0, 0],
-		[0, 0, 1],
-		[0, 0, 2],
-		[0, 1, 0],
-		[0, 1, 1],
-		[0, 1, 2],
-		[1, 0, 0],
-		[1, 0, 1],
-		[1, 0, 2],
-		[1, 1, 0],
-		[1, 1, 1],
-		[1, 1, 2],
-		[2, 0, 0],
-		[2, 0, 1],
-		[2, 0, 2],
-		[2, 1, 0],
-		[2, 1, 1],
-		[2, 1, 2],
-		]
-		
-		assert_equal 3*2*3, comb.length
-		assert_equal expected, comb.collect
-	end
-	
-	def test_combinator_3_by_2_by_1
-		comb = Combinator.new([0,1,2], [0,1], [0])
-		expected = [
-		[0, 0, 0],
-		[0, 1, 0],
-		[1, 0, 0],
-		[1, 1, 0],
-		[2, 0, 0],
-		[2, 1, 0],
-		]
-		
-		assert_equal 3*2*1, comb.length
-		assert_equal expected, comb.collect
-	end
-	
-	# From these tests, it looks like (sensibly) the Combinator is more sensitive to the
-	# number of sets than to the number of items in each set. ie for ten items:
-	#   Combinator.new([1,2],[1,2],[1,2],[1,2],[1,2])
-	# runs slower than
-	#  Combinator.new([1,2,3,4,5], [1,2,3,4,5])
-	#
-	# Of course they generate different output too... like [1,1,1,1,1] vs [1,1]... so you
-	# really do not have a choice in how you structure the combination.
-	def test_combination_speed
-		benchmark_test(15) do |x| 
-			[[3,10],[10,3],[10,4],[10,5]].each do |trial|
-				items, fold = *trial
-				set = []
-				sets = []
-				length = items ** fold
-					
-				1.upto(items) {|i| set << i}
-				fold.times { sets << set }
-			
-				c = Combinator.new(*sets)
-				assert_equal length, c.length
-					
-				x.report("#{items}x#{fold} - #{length}") { assert_equal length, c.collect.length }
-			end
-		end
-	end
-
-end

data/test/support/template_test.rb

@@ -1,122 +0,0 @@
-require  File.dirname(__FILE__) + '/../tap_test_helper'
-require 'tap/support/template'
-
-class TemplateTest < Test::Unit::TestCase
-	include Tap::Support
-  include Tap::Test::SubsetMethods
-  
-  class MockTemplater
-    attr_reader :templates
-    
-    def initialize
-      @templates = []
-    end
-    
-    def <<(template)
-      self.templates << template
-    end
-  end
-  
-  def new_template(hash)
-    hash.extend Template
-    hash.templater = MockTemplater.new
-    hash
-  end
-
-	def test_new_template
-	  t = new_template({})
-	  assert_equal({}, t)
-	  assert_equal MockTemplater, t.templater.class
-	  assert_equal [], t.templater.templates
-	end
-	
-	def test_documentation
-	  # variations
-  	t = {"default" => "default value"}.extend Template
-  	t.templater = []
-  	t.variations([
-  	    {"default" => "non-default value"},
-  	    {"another" => "value"}])
-  	    
-    expected = [{"default" => "non-default value"}, 
-  	           {"default" => "default value", "another" => "value"}]
-  	assert_equal expected, t.templater      
-  	
-	  
-	  # combinations
-	  t = {"default" => "default value"}.extend Template
-  	t.templater = []
-  	t.combinations(
-  	    "letter" => ["a", "b"],
-  	    "number" => [1, 2])
-  	
-    expected = [{"default" => "default value", "letter" => "a", "number" => 1}, 
-  	            {"default" => "default value", "letter" => "a", "number" => 2},
-  	            {"default" => "default value", "letter" => "b", "number" => 1},
-  	            {"default" => "default value", "letter" => "b", "number" => 2}]
-  	assert_equal expected.length, t.templater.length
-  	expected.each do |expectation|
-  	  assert t.templater.include?(expectation)
-  	end   
-	end
-	
-	#
-	# variations test
-	#
-	
-	def test_variations_bang_pushes_merged_template_for_each_input_variation_to_templater_and_does_not_clear_self
-	  t = new_template(:key => 'default')
-		t.variations!([{:key => 'non-default'}, {:another => 'value'}])
-
-    assert_equal({:key => 'default'}, t)
-		assert_equal([
-		  {:key => 'non-default'}, 
-		  {:key => 'default', :another => 'value'}], 
-		t.templater.templates)
-	end
-	
-	def test_variations_is_variations_bang_but_clears_self
-		t1 = new_template(:key => 'default')
-		t1.variations([{:key => 'non-default'}, {:another => 'value'}])
-		
-		t2 = new_template(:key => 'default')
-		t2.variations!([{:key => 'non-default'}, {:another => 'value'}])
-      	
-    assert_equal({}, t1)  
-    assert_equal t1.templater.templates, t2.templater.templates
-	end
-	
-	#
-	# combinations tests
-	#
-	
-	def test_combinations_bang_pushes_all_combinations_of_variables_to_templater_and_does_not_clear_self
-		t = new_template(:default => 'value', :key => 'default')
-    t.combinations!({:key => [0,1], :another => [2,3]})
-      	
-    assert_equal({:default => 'value', :key => 'default'}, t)  
-    		
-    # a two-step check for the templates is necessary because the order of the 
-    # origninal sets is hash-order dependent
-		expected = [
-			{:default => 'value', :key => 0, :another => 2},
-			{:default => 'value', :key => 0, :another => 3},
-			{:default => 'value', :key => 1, :another => 2},
-			{:default => 'value', :key => 1, :another => 3}]
-
-		assert_equal expected.length, t.templater.templates.length
-		expected.each { |expectation| assert t.templater.templates.include?(expectation) }
-	end
-	
-	def test_combinations_is_combinations_bang_but_clears_self
-		t1 = new_template(:default => 'value', :key => 'default')
-    t1.combinations({:key => [0,1], :another => [2,3]})
-    
-    t2 = new_template(:default => 'value', :key => 'default')
-    t2.combinations!({:key => [0,1], :another => [2,3]})
-      	
-    assert_equal({}, t1)  
-    assert_equal t1.templater.templates, t2.templater.templates
-	end
-
-end

data/test/support/templater/erb.txt

@@ -1,2 +0,0 @@
-Line <%= 0 + 1 %>
-Line <%= 1 + 1 %>

data/test/support/templater/erb.yml

@@ -1,2 +0,0 @@
-one: entry <%= 0 + 1 %>
-two: entry <%= 1 + 1 %>

data/test/support/templater/somefile.txt

@@ -1,2 +0,0 @@
-Line one
-Line two

data/test/support/templater_test.rb

@@ -1,192 +0,0 @@
-require  File.dirname(__FILE__) + '/../tap_test_helper'
-require 'tap/support/templater'
-
-class TemplaterTest < Test::Unit::TestCase
-	include Tap::Support
-  include Tap::Test::SubsetMethods
-
-  module ProcessModule
-  	def process(input)
-  		self.store(:processed, "#{input} was processed")
-  	end
-
-  	def bang_process!(input)
-  	  self.store(:processed, "#{input} was bang processed")
-  	end
-
-  	def add_new_method_call(input)
-  	  self.store(:add_new_method_call, "#{input} was processed")
-  	  self.store("process!", "entry from new method call")
-  	end
-  end
-
-  module MethodModule
-    def do_something(input)
-      self["processed"] = "#{input} was processed"
-    end
-  end
-  
-  module DocMethods
-    def method_call(input)
-     self["result"] = "#{input} was processed"
-    end
-  end
-  
-  def test_documentation
-    t = Templater.new(
-            "key"=> "value", 
-            "method_call!" => "method input",
-            "replacement=" => "replacement input")
-    t.run_methods(DocMethods)
-    t.run_replace do |input|
-      "#{input} was replaced"
-    end
-    
-    expected = [{"key" => "value", 
-                "result" => "method input was processed",
-                "replacement" => "replacement input was replaced"}]
-    assert_equal expected, t.templates  
-    
-    # run methods
-    t = Templater.new('method_call!' => 'input')
-  	t.run_methods(DocMethods)   
-  	assert_equal [{"result" => "input was processed"}], t.templates              
-  	
-    # run_replace
-    t = Templater.new('replacement=' => 'some value')
-  	t.run_replace {|value| "#{value} was replaced"}                    
-  	assert_equal [{"replacement" => "some value was replaced"}], t.templates
-  end
-  
-  #
-	# initialization test
-	#
-	
-	def test_initialize
-		t = Templater.new({'key' => 'value'})
-		assert_equal([{'key' => 'value'}], t.templates)
-	end
-	
-	#
-	# push tests
-	#
-	
-	def test_push_skips_empty_templates
-	  t = Templater.new({})
-	  t << {}
-	  assert_equal [], t.templates
-	end
-  
-  #
-  # run templater test
-  #
-  
-  def test_run_templater_does_not_select_non_string_values
-	  t = Templater.new(:key => "value", 1 => "value")
-  	t.run_templater(/.*/) do |template, key, value|
-		  flunk "should not have run"
-		end
-
-  	assert_equal([{:key => "value", 1 => "value"}], t.templates)
-	end
-  
-  def test_run_templater_works_on_each_template
-	  t = Templater.new('key' => "value")
-	  t << {"another" => "another value"}
-		t.run_templater(/.*/) do |template, key, value|
-		  template[key.to_sym] = "#{value} was templated"
-		end
-
-		assert_equal([
-		  {:key => "value was templated"}, 
-		  {:another => "another value was templated"}], 
-		t.templates)
-	end
-	
-	def test_run_templater_extends_templates_with_Template_and_sets_input_templater
-	  t = Templater.new({'key' => 'value'})
-	  t << {'another' => 'value'}
-	  assert_equal [{'key' => 'value'}, {'another' => 'value'}], t.templates
-	  
-	  t.templates.each do |template|
-	    assert !template.respond_to?(:templater)
-	  end
-	  
-	  t.run_templater(/.*/) do |template, key, value|
-	    assert template.respond_to?(:templater)
-	    assert_equal t, template.templater
-	  end
-	end
-	
-	def test_run_templater_removes_empty_templates
-	  t = Templater.new('key' => 'value')
-		t.run_templater(/.*/) do |template, key, value|
-		  t << {}
-		  template.templater << {}
-		end
-
-		assert_equal([], t.templates)
-	end
-	
-	
-  #
-	# run methods test
-	#
-	
-	def test_run_methods_extends_templates_with_input_modules
-	  t = Templater.new('process!' => "entry")
-  	t.run_methods(ProcessModule)
-
-  	assert_equal([{:processed => 'entry was processed'}], t.templates)
-	end
-	
-	def test_run_methods_runs_methods_added_during_processing
-	  t = Templater.new('add_new_method_call!' => "entry")
-  	t.run_methods(ProcessModule)
-
-  	assert_equal([{
-      :add_new_method_call => 'entry was processed',
-      :processed => 'entry from new method call was processed'}], t.templates)
-	end
-	
-	def test_run_methods_raises_no_method_error_when_method_does_not_exist
-		[
-			'non_existant!', 
-			'non existant!'
-		].each do |key|
-			t = Templater.new(key => 'entry')
-			assert !t.templates.first.respond_to?(key)
-			assert_raise(NoMethodError) { t.run_methods }
-		end
-	end
-	
-	def test_run_methods_works_recursively
-	  t = Templater.new(
-	    'key' => 'default',
-	    "variations!!" => [
-	      {'key' => 'non-default'},
-	      {'key' => 'with variations',
-	      "variations!!" => [
-	        {'another' => 'value'}]}]
-	  )
-		t.run_methods
-
-		assert_equal([
-		  {'key' => 'default'}, 
-		  {'key' => 'non-default'}, 
-		  {'key' => 'with variations'},
-		  {'key' => 'with variations', 'another' => 'value'}], 
-		t.templates)
-	end
-  
-  #
-	# run_replace test
-	#
-	
-	def test_run_replace_replaces_value_with_return_from_block
-		t = Templater.new('replaced=' => "value")
-		t.run_replace {|value| "#{value} was replaced" }
-				
-		assert_equal([{'replaced' => 'value was replaced'}], t.templates)
-	end
-end