kbaum-cucumber 0.4.5.pre

data/lib/cucumber/formatter/progress.rb

@@ -0,0 +1,75 @@
+require 'cucumber/formatter/console'
+require 'cucumber/formatter/io'
+
+module Cucumber
+  module Formatter
+    # The formatter used for <tt>--format progress</tt>
+    class Progress
+      include Console
+      include Io
+      attr_reader :step_mother
+
+      def initialize(step_mother, path_or_io, options)
+        @step_mother, @io, @options = step_mother, ensure_io(path_or_io, "progress"), options
+      end
+
+      def after_features(features)
+        @io.puts
+        @io.puts
+        print_summary(features)
+      end
+
+      def before_feature_element(feature_element)
+        record_tag_occurrences(feature_element, @options)
+      end
+
+      def after_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background)
+        progress(status)
+        @status = status
+      end
+      
+      def before_outline_table(outline_table)
+        @outline_table = outline_table
+      end
+      
+      def after_outline_table(outline_table)
+        @outline_table = nil
+      end
+
+      def table_cell_value(value, status)
+        return unless @outline_table
+        status ||= @status
+        progress(status) unless table_header_cell?(status)
+      end
+
+      private
+
+      def print_summary(features)
+        print_steps(:pending)
+        print_steps(:failed)
+        print_stats(features)
+        print_snippets(@options)
+        print_passing_wip(@options)
+        print_tag_limit_warnings(@options)
+      end
+
+      CHARS = {
+        :passed    => '.',
+        :failed    => 'F',
+        :undefined => 'U',
+        :pending   => 'P',
+        :skipped   => '-'
+      }
+
+      def progress(status)
+        char = CHARS[status]
+        @io.print(format_string(char, status))
+        @io.flush
+      end
+
+      def table_header_cell?(status)
+        status == :skipped_param
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/rerun.rb

@@ -0,0 +1,50 @@
+module Cucumber
+  module Formatter
+    # The formatter used for <tt>--format rerun</tt>
+    #
+    # This formatter keeps track of all failing features and print out their location.
+    # Example:
+    #
+    #   features/foo.feature:34 features/bar.feature:11:76:81
+    #
+    # This formatter is used by AutoTest - it will use the output to decide what
+    # to run the next time, simply passing the output string on the command line.
+    #
+    class Rerun
+      include Io
+
+      def initialize(step_mother, path_or_io, options)
+        @io = ensure_io(path_or_io, "rerun")
+        @options = options
+        @file_names = []
+        @file_colon_lines = Hash.new{|h,k| h[k] = []}
+      end
+
+      # features() is never executed at all... ?
+      def after_features(features)
+        files = @file_names.uniq.map do |file|
+          lines = @file_colon_lines[file]
+          "#{file}:#{lines.join(':')}"
+        end
+        @io.puts files.join(' ')
+        
+        # Flusing output to rerun tempfile here...
+        @io.flush
+        @io.close
+      end
+
+      # feature_element() is never executed at all, either... ?
+      def after_feature_element(feature_element)
+        if feature_element.failed?
+          file, line = *feature_element.file_colon_line.split(':')
+          @file_colon_lines[file] << line
+          @file_names << file
+        end
+      end
+
+      def step_name(keyword, step_match, status, source_indent, background)
+        @rerun = true if [:failed].index(status)
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/stepdefs.rb

@@ -0,0 +1,14 @@
+require 'cucumber/formatter/usage'
+
+module Cucumber
+  module Formatter
+    class Stepdefs < Usage
+      def print_steps(stepdef_key)
+      end
+
+      def max_step_length
+        0
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/steps.rb

@@ -0,0 +1,49 @@
+module Cucumber
+  module Formatter
+    # The formatter used for <tt>--format steps</tt>
+    class Steps
+
+      def initialize(step_mother, path_or_io, options)
+        @io = ensure_io(path_or_io, "steps")
+        @options = options
+        @step_definition_files = collect_steps(step_mother)
+      end
+
+      def after_features(features)
+        print_summary
+      end
+
+      private
+
+      def print_summary
+        count = 0
+        @step_definition_files.keys.sort.each do |step_definition_file|
+          @io.puts step_definition_file
+          
+          sources = @step_definition_files[step_definition_file]
+          source_indent = source_indent(sources)
+          sources.sort.each do |file_colon_line, regexp_source|
+            @io.print regexp_source.indent(2)
+            @io.print " # #{file_colon_line}".indent(source_indent - regexp_source.jlength)
+            @io.puts
+          end
+          @io.puts
+          count += sources.size
+        end
+        @io.puts "#{count} step definition(s) in #{@step_definition_files.size} source file(s)."
+      end
+
+      def collect_steps(step_mother)
+        step_mother.step_definitions.inject({}) do |step_definitions, step_definition|
+          step_definitions[step_definition.file] ||= []
+          step_definitions[step_definition.file] << [ step_definition.file_colon_line, step_definition.regexp_source ]
+          step_definitions
+        end
+      end
+
+      def source_indent(sources)
+        sources.map { |file_colon_line, regexp| regexp.size }.max + 1
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/summary.rb

@@ -0,0 +1,35 @@
+module Cucumber
+  module Formatter
+    module Summary
+
+      def scenario_summary(step_mother, &block)
+        scenarios_proc = lambda{|status| step_mother.scenarios(status)}
+        dump_count(step_mother.scenarios.length, "scenario") + dump_status_counts(scenarios_proc, &block)
+      end
+
+      def step_summary(step_mother, &block)
+        steps_proc = lambda{|status| step_mother.steps(status)}
+        dump_count(step_mother.steps.length, "step") + dump_status_counts(steps_proc, &block)
+      end
+
+      private
+
+      def dump_status_counts(find_elements_proc)
+        counts = [:failed, :skipped, :undefined, :pending, :passed].map do |status|
+          elements = find_elements_proc.call(status)
+          elements.any? ? yield("#{elements.length} #{status.to_s}", status) : nil
+        end.compact
+        if counts.any?
+          " (#{counts.join(', ')})"
+        else
+          ""
+        end
+      end
+
+      def dump_count(count, what, state=nil)
+        [count, state, "#{what}#{count == 1 ? '' : 's'}"].compact.join(" ")
+      end
+
+    end
+  end
+end

data/lib/cucumber/formatter/tag_cloud.rb

@@ -0,0 +1,34 @@
+require 'cucumber/formatter/io'
+
+module Cucumber
+  module Formatter
+    # The formatter used for <tt>--format tag_cloud</tt>
+    # Custom formatter that prints a tag cloud as a table.
+    class TagCloud
+      include Io
+
+      def initialize(step_mother, path_or_io, options)
+        @io = ensure_io(path_or_io, "tag_cloud")
+        @options = options
+        @counts = Hash.new{|h,k| h[k] = 0}
+      end
+
+      def after_features(features)
+        print_summary(features)
+      end
+
+      def tag_name(tag_name)
+        @counts[tag_name] += 1
+      end
+      
+      private
+  
+      def print_summary(features)
+        matrix = @counts.to_a.sort{|paira, pairb| paira[0] <=> pairb[0]}.transpose
+        table = Cucumber::Ast::Table.new(matrix)
+        formatter = Cucumber::Formatter::Pretty.new(@step_mother, @io, {})
+        Cucumber::Ast::TreeWalker.new(@step_mother, [formatter], {}).visit_multiline_arg(table)
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/unicode.rb

@@ -0,0 +1,35 @@
+# Require this file if you need Unicode support.
+require 'cucumber/platform'
+require 'cucumber/formatter/ansicolor'
+
+$KCODE='u' unless Cucumber::RUBY_1_9
+
+if Cucumber::WINDOWS_MRI && `chcp` =~ /(\d+)/
+  codepage = $1.to_i
+  codepages = (1251..1252)
+
+  if codepages.include?(codepage)
+    Cucumber::CODEPAGE = "cp#{codepage}"
+  
+    require 'iconv'
+    module Kernel #:nodoc:
+      alias cucumber_print print
+      def print(*a)
+        begin
+          cucumber_print(*Iconv.iconv(Cucumber::CODEPAGE, "UTF-8", *a))
+        rescue Iconv::IllegalSequence
+          cucumber_print(*a)
+        end
+      end
+
+      alias cucumber_puts puts
+      def puts(*a)
+        begin
+          cucumber_puts(*Iconv.iconv(Cucumber::CODEPAGE, "UTF-8", *a))
+        rescue Iconv::IllegalSequence
+          cucumber_puts(*a)
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/usage.rb

@@ -0,0 +1,127 @@
+require 'cucumber/formatter/progress'
+require 'cucumber/step_definition_light'
+
+module Cucumber
+  module Formatter
+    class Usage < Progress
+      include Console
+
+      class StepDefKey < StepDefinitionLight
+        attr_accessor :mean_duration, :status
+      end
+
+      def initialize(step_mother, path_or_io, options)
+        @step_mother = step_mother
+        @io = ensure_io(path_or_io, "usage")
+        @options = options
+        @stepdef_to_match = Hash.new{|h,stepdef_key| h[stepdef_key] = []}
+      end
+
+      def before_step(step)
+        @step = step
+        @start_time = Time.now
+      end
+
+      def before_step_result(*args)
+        @duration = Time.now - @start_time
+      end
+
+      def after_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background)
+        if step_match.name.nil? # nil if it's from a scenario outline
+          stepdef_key = StepDefKey.new(step_match.step_definition.regexp_source, step_match.step_definition.file_colon_line)
+
+          @stepdef_to_match[stepdef_key] << {
+            :keyword => keyword, 
+            :step_match => step_match, 
+            :status => status, 
+            :file_colon_line => @step.file_colon_line,
+            :duration => @duration
+          }
+        end
+        super
+      end
+
+      def print_summary(features)
+        add_unused_stepdefs
+        aggregate_info
+
+        if @options[:dry_run]
+          keys = @stepdef_to_match.keys.sort {|a,b| a.regexp_source <=> b.regexp_source}
+        else
+          keys = @stepdef_to_match.keys.sort {|a,b| a.mean_duration <=> b.mean_duration}.reverse
+        end
+
+        keys.each do |stepdef_key|
+          print_step_definition(stepdef_key)
+
+          if @stepdef_to_match[stepdef_key].any?
+            print_steps(stepdef_key)
+          else
+            @io.puts("  " + format_string("NOT MATCHED BY ANY STEPS", :failed))
+          end
+        end
+        @io.puts
+        super
+      end
+
+      def print_step_definition(stepdef_key)
+        @io.print format_string(sprintf("%.7f", stepdef_key.mean_duration), :skipped) + " " unless @options[:dry_run]
+        @io.print format_string(stepdef_key.regexp_source, stepdef_key.status)
+        if @options[:source]
+          indent = max_length - stepdef_key.regexp_source.jlength
+          line_comment = "    # #{stepdef_key.file_colon_line}".indent(indent)
+          @io.print(format_string(line_comment, :comment))
+        end
+        @io.puts
+      end
+
+      def print_steps(stepdef_key)
+        @stepdef_to_match[stepdef_key].each do |step|
+          @io.print "  "
+          @io.print format_string(sprintf("%.7f", step[:duration]), :skipped) + " " unless @options[:dry_run]
+          @io.print format_step(step[:keyword], step[:step_match], step[:status], nil)
+          if @options[:source]
+            indent = max_length - (step[:keyword].jlength + step[:step_match].format_args.jlength)
+            line_comment = " # #{step[:file_colon_line]}".indent(indent)
+            @io.print(format_string(line_comment, :comment))
+          end
+          @io.puts
+        end
+      end
+
+      def max_length
+        [max_stepdef_length, max_step_length].compact.max
+      end
+
+      def max_stepdef_length
+        @stepdef_to_match.keys.flatten.map{|key| key.regexp_source.jlength}.max
+      end
+
+      def max_step_length
+        @stepdef_to_match.values.flatten.map do |step|
+          step[:keyword].jlength + step[:step_match].format_args.jlength
+        end.max
+      end
+
+      def aggregate_info
+        @stepdef_to_match.each do |key, steps|
+          if steps.empty?
+            key.status = :skipped
+            key.mean_duration = 0
+          else
+            key.status = Ast::StepInvocation.worst_status(steps.map{|step| step[:status]})
+            total_duration = steps.inject(0) {|sum, step| step[:duration] + sum}
+            key.mean_duration = total_duration / steps.length
+          end
+        end
+      end
+
+      def add_unused_stepdefs
+        @step_mother.unmatched_step_definitions.each do |step_definition|
+          stepdef_key = StepDefKey.new(step_definition.regexp_source, step_definition.file_colon_line)
+          @stepdef_to_match[stepdef_key] = []
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/language_support.rb

@@ -0,0 +1,30 @@
+module Cucumber
+  # This module defines the API for programming panguage support in Cucumber.
+  # While Cucumber itself is written in Ruby, any programming language can
+  # be supported by implementing this API.
+  #
+  # For the sake of illustration we'll consider an imaginary language called
+  # _why. _why files have the .why extension, so we need to put support for
+  # this language in the <tt>Cucumber::WhySupport::WhyLanguage</tt>. This
+  # class must be defined in a file called <tt>cucumber/why_support/why_language.rb</tt>
+  # and be available on Ruby's <tt>$LOAD_PATH</tt>:
+  #
+  #   module Cucumber
+  #     module WhySupport
+  #       class WhyLanguage
+  #
+  #         # Uses whatever available language bridge to load
+  #         # +why_file+ and returns an Array of StepDefinition.
+  #         def load_code_file(why_file)
+  #         end
+  #       end
+  #     end
+  #   end
+  #
+  # Each language implementation manages its own hooks, and must execute them
+  # at appropriate times.
+  #   
+  #
+  module LanguageSupport
+  end
+end