pairwise 0.1.0 → 0.1.1

data/README.rdoc

@@ -0,0 +1,13 @@
+= Pairwise
+
+Documentation is at http://github.com/josephwilk/pairwise/wikis/home/
+
+== Running tests
+
+  rake
+
+If you get errors about missing gems - just install them.
+
+== Copyright
+
+Copyright (c) 2009,2010 Joseph Wilk. See LICENSE for details.

data/VERSION.yml

@@ -1,4 +1,4 @@
 ---
-:patch: 0
+:patch: 1
 :major: 0
 :minor: 1

data/features/generating_pairwise_data.feature

@@ -66,15 +66,15 @@ Scenario: Not replacing wild cards
   When I run pairwise inputs.yml --keep-wild-cards
   Then I should see the output
   """
-  | A  | B         | C  |
-  | A1 | B1        | C1 |
-  | A1 | B2        | C2 |
-  | A2 | B1        | C3 |
-  | A2 | B2        | C1 |
-  | A3 | B1        | C2 |
-  | A3 | B2        | C3 |
-  | A3 | wild_card | C1 |
-  | A2 | wild_card | C2 |
-  | A1 | wild_card | C3 |
+  | A  | B              | C  |
+  | A1 | B1             | C1 |
+  | A1 | B2             | C2 |
+  | A2 | B1             | C3 |
+  | A2 | B2             | C1 |
+  | A3 | B1             | C2 |
+  | A3 | B2             | C3 |
+  | A3 | any_value_of_B | C1 |
+  | A2 | any_value_of_B | C2 |
+  | A1 | any_value_of_B | C3 |
 
   """

data/lib/pairwise/builder.rb

@@ -6,81 +6,84 @@ module Pairwise
     WILD_CARD = 'wild_card'
 
     def initialize(inputs, options = {})
-      @inputs = inputs
+      @list_of_input_values = inputs
       @options = options
     end
 
     def build
-      input_lists = generate_pairs_between(@inputs[0], [@inputs[1]], 0)
-      @inputs.size > 2 ? in_parameter_order_generation(input_lists) : input_lists.map{|list| list.to_a}
+      input_combinations = generate_pairs_between(@list_of_input_values[0], [@list_of_input_values[1]], 0)
+      @list_of_input_values.size > 2 ? in_parameter_order_generation(input_combinations) : input_combinations.map{|list| list.to_a}
     end
 
     private
 
-    def in_parameter_order_generation(input_lists)
-      @inputs[2..-1].each_with_index do |input_list, i|
+    def in_parameter_order_generation(input_combinations)
+      @list_of_input_values[2..-1].each_with_index do |input_values, i|
         i += 2
-        input_lists, pi = horizontal_growth(input_lists, input_list, @inputs[0..(i-1)])
-        input_lists = vertical_growth(input_lists, pi)
+        input_combinations, uncovered_pairs = horizontal_growth(input_combinations, input_values, @list_of_input_values[0..(i-1)])
+        input_combinations = vertical_growth(input_combinations, uncovered_pairs)
       end
-      input_lists = replace_redundant_wild_cards(input_lists)
-      input_lists = replace_wild_cards(input_lists) unless @options[:keep_wild_cards]
-      input_lists
+      input_combinations = replace_redundant_wild_cards(input_combinations)
+      input_combinations = replace_wild_cards(input_combinations) unless @options[:keep_wild_cards]
+      input_combinations
     end
 
-    def horizontal_growth(input_lists, parameter_i, inputs)
-      pi = generate_pairs_between(parameter_i, inputs, inputs.size)
+    def horizontal_growth(input_combinations, input_values_for_growth, previously_grown_input_values)
+      uncovered_pairs = generate_pairs_between(input_values_for_growth, previously_grown_input_values, previously_grown_input_values.size)
 
-      if input_lists.size <= parameter_i.size
-        input_lists = input_lists.enum_for(:each_with_index).map do |input_list, index_of_input_under_inspection|
-          extended_input_list = input_list + [parameter_i[index_of_input_under_inspection]]
-          pi = remove_pairs_covered_by(extended_input_list, pi)
-          extended_input_list
-        end
+      if input_combinations.size <= input_values_for_growth.size
+        input_combinations, uncovered_pairs = grow_input_combinations_and_remove_covered_pairs(input_combinations, input_values_for_growth, uncovered_pairs)
       else
-        input_lists[0...parameter_i.size] = input_lists[0...parameter_i.size].enum_for(:each_with_index).map do |input_list, index_of_input_under_inspection|
-          extended_input_list = input_list + [parameter_i[index_of_input_under_inspection]]
-          pi = remove_pairs_covered_by(extended_input_list, pi)
-          extended_input_list
-        end
-
-        input_lists[parameter_i.size..-1] = input_lists[parameter_i.size..-1].map do |input_list|
-          extended_input_list = input_list_that_covers_most_pairs(input_list, parameter_i, pi)
-          pi = remove_pairs_covered_by(extended_input_list, pi)
-          extended_input_list
+        range_to_grow = 0...input_values_for_growth.size
+        input_combinations[range_to_grow], uncovered_pairs = grow_input_combinations_and_remove_covered_pairs(input_combinations[range_to_grow], input_values_for_growth, uncovered_pairs)
+
+        range_to_grow = input_values_for_growth.size..-1
+        input_combinations[range_to_grow] = input_combinations[range_to_grow].map do |input_combination|
+          extended_input_combination = input_combination_that_covers_most_pairs(input_combination, input_values_for_growth, uncovered_pairs)
+          uncovered_pairs = remove_pairs_covered_by(extended_input_combination, uncovered_pairs)
+          extended_input_combination
         end
       end
 
-      [input_lists, pi]
+      [input_combinations, uncovered_pairs]
     end
 
-    def vertical_growth(input_lists, pi)
-      new_input_lists = []
+    def grow_input_combinations_and_remove_covered_pairs(input_combinations, input_values_for_growth, uncovered_pairs)
+      input_combinations = input_combinations.enum_for(:each_with_index).map do |input_combination, input_index|
+        extended_input_combination = input_combination + [input_values_for_growth[input_index]]
+        uncovered_pairs = remove_pairs_covered_by(extended_input_combination, uncovered_pairs)
+        extended_input_combination
+      end
+      [input_combinations, uncovered_pairs]
+    end
+        
+    def vertical_growth(input_combinations, uncovered_pairs)
+      new_input_combinations = []
 
-      pi.each do |uncovered_pair|
+      uncovered_pairs.each do |uncovered_pair|
         #TODO: Decided if we should replace all matches or single matches?
-        if test_position = uncovered_pair.replaceable_wild_card?(new_input_lists)
-          new_input_lists[test_position] = uncovered_pair.replace_wild_card(new_input_lists[test_position])
+        if test_position = uncovered_pair.replaceable_wild_card?(new_input_combinations)
+          new_input_combinations[test_position] = uncovered_pair.replace_wild_card(new_input_combinations[test_position])
         else
-          new_input_lists << uncovered_pair.create_input_list
+          new_input_combinations << uncovered_pair.create_input_list
         end
       end
 
-      input_lists + new_input_lists
+      input_combinations + new_input_combinations
     end
 
-    def replace_redundant_wild_cards(input_lists)
-      map_each_input_value(input_lists) do |input_value, index|
-        if input_value == WILD_CARD && @inputs[index].length == 1
-          @inputs[index][0]
+    def replace_redundant_wild_cards(input_combinations)
+      map_each_input_value(input_combinations) do |input_value, index|
+        if input_value == WILD_CARD && @list_of_input_values[index].length == 1
+          @list_of_input_values[index][0]
         else
           input_value
         end
       end
     end
 
-    def replace_wild_cards(input_lists)
-      map_each_input_value(input_lists) do |input_value, index|
+    def replace_wild_cards(input_combinations)
+      map_each_input_value(input_combinations) do |input_value, index|
         if input_value == WILD_CARD
           pick_random_value(@inputs[index])
         else
@@ -89,16 +92,16 @@ module Pairwise
       end
     end
 
-    def map_each_input_value(input_lists)
-      input_lists.map do |input_list|
-        input_list.enum_for(:each_with_index).map do |input_value, index|
+    def map_each_input_value(input_combinations)
+      input_combinations.map do |input_combination|
+        input_combination.enum_for(:each_with_index).map do |input_value, index|
           yield input_value, index
         end
       end
     end
 
-    def pick_random_value(input_list)
-      input_list[rand(input_list.size)]
+    def pick_random_value(input_combination)
+      input_combination[rand(input_combination.size)]
     end
 
     def generate_pairs_between(parameter_i, input_lists, p_index)
@@ -113,28 +116,28 @@ module Pairwise
       pairs
     end
 
-    def remove_pairs_covered_by(extended_input_list, pi)
-      pi.reject{|pair| pair.covered_by?(extended_input_list)}
+    def remove_pairs_covered_by(extended_input_list, pairs)
+      pairs.reject{|pair| pair.covered_by?(extended_input_list)}
     end
 
-    def input_list_that_covers_most_pairs(input_list, parameter_i, pi)
-      selected_input_list = nil
-      parameter_i.reduce(0) do |max_covered_count, value|
-        input_list_candidate = input_list + [value]
-        covered_count = pairs_covered_count(input_list_candidate, pi)
+    def input_combination_that_covers_most_pairs(input_combination, input_values_for_growth, pairs)
+      selected_input_combination = nil
+      input_values_for_growth.reduce(0) do |max_covered_count, value|
+        input_combination_candidate = input_combination + [value]
+        covered_count = pairs_covered_count(input_combination_candidate, pairs)
         if covered_count >= max_covered_count
-          selected_input_list = input_list_candidate
+          selected_input_combination = input_combination_candidate
           covered_count
         else
           max_covered_count
         end
       end
-      selected_input_list
+      selected_input_combination
     end
 
-    def pairs_covered_count(input_list, pairs)
+    def pairs_covered_count(input_combination, pairs)
       pairs.reduce(0) do |covered_count, pair|
-        covered_count += 1 if pair.covered_by?(input_list)
+        covered_count += 1 if pair.covered_by?(input_combination)
         covered_count
       end
     end

data/lib/pairwise/formatter/cucumber.rb

@@ -7,16 +7,17 @@ module Pairwise
         @max = {}
       end
 
-      def display(test_data, inputs)
-        @test_data, @inputs = test_data, inputs
-
+      def display(test_data, input_labels)
+        @test_data = label_wild_cards(test_data, input_labels)    
+        @input_labels = input_labels
+                        
         @out.print "|"
-        inputs.each_with_index do |key, column|
-          @out.print padded_string(key, column) + "|"
+        @input_labels.each_with_index do |label, column|
+          @out.print padded_string(label, column) + "|"
         end
         @out.puts
 
-        test_data.each do |data|
+        @test_data.each do |data|
           @out.print "|"
           data.each_with_index do |datum, column|
             @out.print padded_string(datum, column) + "|"
@@ -26,13 +27,21 @@ module Pairwise
       end
 
       private
+      def label_wild_cards(test_data, labels)
+        test_data.map do |data|
+          data.enum_for(:each_with_index).map do |datum, column|
+            datum == Builder::WILD_CARD ? "any_value_of_#{labels[column]}" : datum
+          end
+        end
+      end
+      
       def padded_string(string, column)
         padding_length = max_line_length(column) - string.length
         " #{string} " + (" " * padding_length)
       end
 
       def max_line_length(column)
-        @max[column] ||= ([@inputs[column].length] + @test_data.map{|data| data[column].length}).max
+        @max[column] ||= ([@input_labels[column].length] + @test_data.map{|data| data[column].length}).max
       end
 
     end

data/lib/pairwise/test_pair.rb

@@ -30,9 +30,9 @@ module Pairwise
       input_list
     end
 
-    def replaceable_wild_card?(input_lists)
-      wild_card_list = input_lists.map do |input_list|
-        input_list[@p2_position] == Builder::WILD_CARD && input_list[@p1_position] == @p1
+    def replaceable_wild_card?(input_combinations)
+      wild_card_list = input_combinations.map do |input_combination|
+        input_combination[@p2_position] == Builder::WILD_CARD && input_combination[@p1_position] == @p1
       end
       wild_card_list.rindex(true)
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: pairwise
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors: 
 - Joseph Wilk
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-05 00:00:00 +00:00
+date: 2010-01-07 00:00:00 +00:00
 default_executable: pairwise
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -40,9 +40,11 @@ extensions: []
 
 extra_rdoc_files: 
 - LICENSE
+- README.rdoc
 files: 
 - .gitignore
 - LICENSE
+- README.rdoc
 - Rakefile
 - VERSION.yml
 - bin/pairwise