pairwise 0.1.3 → 0.1.4

data/VERSION.yml

@@ -1,4 +1,5 @@
----
-:patch: 3
+--- 
+:build: 
 :major: 0
 :minor: 1
+:patch: 4

data/features/customizing_pairwise_output_format.feature

@@ -0,0 +1,27 @@
+Feature: Customizing pairwise output format
+  In order to save time importing pairwise sets
+  As a tester
+  I want the output pairwise data to be in the most convenient format for me
+
+  Scenario: formatting output as csv
+    Given I have the yaml file "inputs.yml" containing:
+      """
+      - event with image: [Football, Basketball, Soccer]
+      - event without image: [Football, Basketball, Soccer]
+      - media: [Image, Video, Music]
+      """
+    When I run pairwise inputs.yml --format csv
+    Then I should see the output
+      """
+      event with image,event without image,media
+      Football,Football,Image
+      Football,Basketball,Video
+      Football,Soccer,Music
+      Basketball,Football,Music
+      Basketball,Basketball,Image
+      Basketball,Soccer,Video
+      Soccer,Football,Video
+      Soccer,Basketball,Music
+      Soccer,Soccer,Image
+
+      """

data/lib/pairwise.rb

@@ -2,6 +2,7 @@ $:.unshift(File.dirname(__FILE__)) unless
   $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
 require 'pairwise/test_pair'
+require 'pairwise/pair_collection'
 require 'pairwise/builder'
 require 'pairwise/formatter'
 require 'pairwise/cli'

data/lib/pairwise/builder.rb

@@ -11,8 +11,8 @@ module Pairwise
     end
 
     def build
-      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}
+      input_combinations = PairCollection.new(@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.to_a
     end
 
     private
@@ -29,7 +29,7 @@ module Pairwise
     end
 
     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)
+      uncovered_pairs = PairCollection.new(input_values_for_growth, previously_grown_input_values, previously_grown_input_values.size)
 
       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)
@@ -39,8 +39,8 @@ module Pairwise
 
         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 = uncovered_pairs.input_combination_that_covers_most_pairs(input_combination, input_values_for_growth)
+          uncovered_pairs.remove_pairs_covered_by!(extended_input_combination)
           extended_input_combination
         end
       end
@@ -51,7 +51,7 @@ module Pairwise
     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)
+        uncovered_pairs.remove_pairs_covered_by!(extended_input_combination)
         extended_input_combination
       end
       [input_combinations, uncovered_pairs]
@@ -104,42 +104,5 @@ module Pairwise
       input_combination[Kernel.rand(input_combination.size)]
     end
 
-    def generate_pairs_between(parameter_i, input_lists, p_index)
-      pairs = []
-      parameter_i.each do |p|
-        input_lists.each_with_index do |input_list, q_index|
-          input_list.each do |q|
-            pairs << TestPair.new(p_index, q_index, p, q)
-          end
-        end
-      end
-      pairs
-    end
-
-    def remove_pairs_covered_by(extended_input_list, pairs)
-      pairs.reject{|pair| pair.covered_by?(extended_input_list)}
-    end
-
-    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_combination = input_combination_candidate
-          covered_count
-        else
-          max_covered_count
-        end
-      end
-      selected_input_combination
-    end
-
-    def pairs_covered_count(input_combination, pairs)
-      pairs.reduce(0) do |covered_count, pair|
-        covered_count += 1 if pair.covered_by?(input_combination)
-        covered_count
-      end
-    end
   end
 end

data/lib/pairwise/cli.rb

@@ -2,6 +2,17 @@ require 'yaml'
 require 'optparse'
 module Pairwise
   class Cli
+    BUILTIN_FORMATS = {
+      'cucumber' => [Pairwise::Formatter::Cucumber,
+                     'Generates pairs as tables for Cucumber'],
+      'csv'      => [Pairwise::Formatter::Csv,
+                     'Generate pairs in a comma seperated format']}
+
+    max = BUILTIN_FORMATS.keys.map{|s| s.length}.max
+    FORMAT_HELP = (BUILTIN_FORMATS.keys.sort.map do |key|
+      "  #{key}#{' ' * (max - key.length)} : #{BUILTIN_FORMATS[key][1]}"
+    end)
+
     class << self
       def execute(args)
         new(args).execute!
@@ -10,7 +21,6 @@ module Pairwise
 
     def initialize(args, out = STDOUT)
       @args, @out = args, out
-      @formatter = Formatter::Cucumber.new(@out)
       @options = defaults
     end
 
@@ -24,6 +34,9 @@ module Pairwise
         opts.on("-k", "--keep-wild-cards") do
           @options[:keep_wild_cards] = true
         end
+        opts.on('-f FORMAT', '--format FORMAT', *FORMAT_HELP) do |format|
+          @options[:format] = format
+        end
         opts.on_tail("--version", "Show version.") do
           @out.puts Pairwise::VERSION
           Kernel.exit(0)
@@ -46,7 +59,7 @@ module Pairwise
 
         builder = Pairwise::Builder.new(input_data, @options)
 
-        @formatter.display(builder.build, input_labels)
+        formatter.display(builder.build, input_labels)
       else
         puts "Error: '#{@input_file}' does not contain the right yaml structure for me to generate the pairwise set!"
       end
@@ -54,7 +67,8 @@ module Pairwise
 
     private
     def defaults
-      {:keep_wild_cards => false}
+      { :keep_wild_cards => false,
+        :format => 'cucumber' }
     end
 
     def valid_inputs?(inputs)
@@ -66,6 +80,11 @@ module Pairwise
       Kernel.exit(0)
     end
 
+    def formatter
+      format = BUILTIN_FORMATS[@options[:format]][0]
+      format.new(@out)
+    end
+
     def parse_input_data!(inputs)
       inputs = hash_inputs_to_list(inputs) if inputs.is_a?(Hash)
 

data/lib/pairwise/formatter.rb

@@ -1 +1 @@
-%q[cucumber].each {|file| require "pairwise/formatter/#{file}"}
+%w[cucumber csv].each {|file| require "pairwise/formatter/#{file}"}

data/lib/pairwise/formatter/csv.rb

@@ -0,0 +1,17 @@
+module Pairwise
+  module Formatter
+    class Csv
+
+      def initialize(out)
+        @out = out
+      end
+
+      def display(test_data, input_labels)
+        @out.puts input_labels.join(',')
+        test_data.each do |data|
+          @out.puts data.join(',')
+        end
+      end
+    end
+  end
+end

data/lib/pairwise/pair_collection.rb

@@ -0,0 +1,52 @@
+module Pairwise
+  class PairCollection < Array
+
+    def initialize(input_parameter_values, input_value_lists, input_parameter_index)
+      pairs = generate_pairs_between(input_parameter_values, input_value_lists, input_parameter_index)
+      super(pairs)
+    end
+
+    def remove_pairs_covered_by!(extended_input_list)
+      self.reject!{|pair| pair.covered_by?(extended_input_list)}
+    end
+
+    def input_combination_that_covers_most_pairs(input_combination, input_values_for_growth)
+      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)
+        if covered_count >= max_covered_count
+          selected_input_combination = input_combination_candidate
+          covered_count
+        else
+          max_covered_count
+        end
+      end
+      selected_input_combination
+    end
+
+    def to_a
+      self.map{|list| list.to_a}
+    end
+
+    private
+    def generate_pairs_between(input_parameter_values, input_value_lists, input_parameter_index)
+      pairs = []
+      input_parameter_values.each do |input_value_a|
+        input_value_lists.each_with_index do |input_list, input_value_b_index|
+          input_list.each do |input_value_b|
+            pairs << TestPair.new(input_parameter_index, input_value_b_index, input_value_a, input_value_b)
+          end
+        end
+      end
+      pairs
+    end
+
+    def pairs_covered_count(input_combination)
+      self.reduce(0) do |covered_count, pair|
+        covered_count += 1 if pair.covered_by?(input_combination)
+        covered_count
+      end
+    end
+  end
+end

data/spec/pairwise/builder_spec.rb

@@ -26,7 +26,7 @@ module Pairwise
         # We are getting the uncovered pairs in reverse
         #pi.should == [[:A2, :C2],[:A1, :C3],[:B1, :C2],[:B2, :C3]]
         # Cheat and check we get the list in reverse
-        pi.should == [[:C2, :A2], [:C2, :B1], [:C3, :A1], [:C3, :B2]]
+        pi.to_a.should == [[:C2, :A2], [:C2, :B1], [:C3, :A1], [:C3, :B2]]
       end
     end
   end

data/spec/pairwise/cli_spec.rb

@@ -34,6 +34,20 @@ module Pairwise
       end
     end
 
+    context '-f FORMAT or --format FORMAT' do
+      it "defaults to the cucumber format for output" do
+        after_parsing('') do
+          options[:format].should == 'cucumber'
+        end
+      end
+
+      it "overides the cucumber format when passed a specific format" do
+        after_parsing('--format csv') do
+          options[:format].should == 'csv'
+        end
+      end
+    end
+
     context "--help" do
       it "displays usage" do
         after_parsing('--help') do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: pairwise
 version: !ruby/object:Gem::Version 
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors: 
 - Joseph Wilk
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-09 00:00:00 +00:00
+date: 2010-02-21 00:00:00 +00:00
 default_executable: pairwise
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -49,6 +49,7 @@ files:
 - VERSION.yml
 - bin/pairwise
 - features/bugs/bad_yml.feature
+- features/customizing_pairwise_output_format.feature
 - features/generating_pairwise_data.feature
 - features/step_definitions/pairwise_data_steps.rb
 - features/support/env.rb
@@ -59,7 +60,9 @@ files:
 - lib/pairwise/builder.rb
 - lib/pairwise/cli.rb
 - lib/pairwise/formatter.rb
+- lib/pairwise/formatter/csv.rb
 - lib/pairwise/formatter/cucumber.rb
+- lib/pairwise/pair_collection.rb
 - lib/pairwise/test_pair.rb
 - spec/pairwise/builder_spec.rb
 - spec/pairwise/cli_spec.rb