cucumber 0.1.10 → 0.2.0

data/lib/cucumber/formatter/pretty.rb

@@ -0,0 +1,179 @@
+require 'cucumber/formatter/console'
+require 'fileutils'
+
+module Cucumber
+  module Formatter
+    # This formatter prints features to plain text - exactly how they were parsed,
+    # just prettier. That means with proper indentation and alignment of table columns.
+    #
+    # If the output is STDOUT (and not a file), there are bright colours to watch too.
+    #
+    class Pretty < Ast::Visitor
+      include FileUtils
+      include Console
+      attr_writer :indent
+
+      def initialize(step_mother, io, options, delim='|')
+        super(step_mother)
+        @io = io
+        @options = options
+        @delim = delim
+        @indent = 0
+      end
+
+      def visit_features(features)
+        super
+        print_summary unless @options[:autoformat]
+      end
+
+      def visit_feature(feature)
+        @indent = 0
+        if @options[:autoformat]
+          file = File.join(@options[:autoformat], feature.file)
+          dir = File.dirname(file)
+          mkdir_p(dir) unless File.directory?(dir)
+          File.open(file, Cucumber.file_mode('w')) do |io|
+            @io = io
+            super
+          end
+        else
+          super
+        end
+      end
+
+      def visit_comment(comment)
+        comment.accept(self)
+      end
+
+      def visit_comment_line(comment_line)
+        unless comment_line.blank?
+          @io.puts(comment_line.indent(@indent)) 
+          @io.flush
+        end
+      end
+
+      def visit_tags(tags)
+        tags.accept(self)
+        if @indent == 1
+          @io.puts 
+          @io.flush
+        end
+      end
+
+      def visit_tag_name(tag_name)
+        tag = format_string("@#{tag_name}", :tag).indent(@indent)
+        @io.print(tag)
+        @io.flush
+        @indent = 1
+      end
+
+      def visit_feature_name(name)
+        @io.puts(name)
+        @io.puts
+        @io.flush
+      end
+
+      def visit_feature_element(feature_element)
+        @indent = 2
+        super
+        @io.puts
+        @io.flush
+      end
+
+      def visit_background(background)
+        @indent = 2
+        @in_background = true
+        super
+        @in_background = nil
+        @io.puts
+        @io.flush
+      end
+
+      def visit_background_name(keyword, name, file_colon_line, source_indent)
+        visit_feature_element_name(keyword, name, file_colon_line, source_indent)
+      end
+
+      def visit_examples_name(keyword, name)
+        @io.puts("\n  #{keyword} #{name}")
+        @io.flush
+        @indent = 4
+      end
+
+      def visit_scenario_name(keyword, name, file_colon_line, source_indent)
+        visit_feature_element_name(keyword, name, file_colon_line, source_indent)
+      end
+
+      def visit_feature_element_name(keyword, name, file_colon_line, source_indent)
+        line = "  #{keyword} #{name}"
+        @io.print(line)
+        if @options[:source]
+          line_comment = " # #{file_colon_line}".indent(source_indent)
+          @io.print(format_string(line_comment, :comment))
+        end
+        @io.puts
+        @io.flush
+      end
+
+      def visit_step(step)
+        @indent = 6
+        super
+      end
+
+      def visit_step_name(keyword, step_match, status, source_indent, background)
+        @step_matches ||= []
+        
+        non_failed_background_step_outside_background = !@in_background && background && (status != :failed)
+        @skip_step = @step_matches.index(step_match) || non_failed_background_step_outside_background
+        
+        unless(@skip_step)
+          source_indent = nil unless @options[:source]
+          formatted_step_name = format_step(keyword, step_match, status, source_indent)
+          @io.puts("    " + formatted_step_name)
+        end
+        @step_matches << step_match
+      end
+
+      def visit_multiline_arg(multiline_arg)
+        return if @options[:no_multiline] || @skip_step
+        super
+      end
+
+      def visit_exception(exception, status)
+        return if @skip_step
+        print_exception(exception, status, @indent)
+        @io.flush
+      end
+
+      def visit_table_row(table_row)
+        @io.print @delim.indent(@indent)
+        super
+        @io.puts
+        print_exception(table_row.exception, :failed, @indent) if table_row.exception
+      end
+
+      def visit_py_string(string, status)
+        s = "\"\"\"\n#{string}\n\"\"\"".indent(@indent)
+        s = s.split("\n").map{|l| l =~ /^\s+$/ ? '' : l}.join("\n")
+        @io.puts(format_string(s, status))
+        @io.flush
+      end
+
+      def visit_table_cell(table_cell)
+        super
+      end
+
+      def visit_table_cell_value(value, width, status)
+        @io.print(' ' + format_string((value.to_s || '').ljust(width), status) + " #{@delim}")
+        @io.flush
+      end
+
+      private
+
+      def print_summary
+        print_counts
+        print_snippets(@options)
+      end
+
+    end
+  end
+end

data/lib/cucumber/formatter/profile.rb

@@ -0,0 +1,77 @@
+require 'cucumber/formatter/progress'
+
+module Cucumber
+  module Formatter
+    class Profile < Progress
+      NUMBER_OF_STEP_DEFINITONS_TO_SHOW = 10
+      NUMBER_OF_STEP_INVOCATIONS_TO_SHOW = 5
+
+      def initialize(step_mother, io, options)
+        super
+        @step_definition_durations = Hash.new { |h,step_definition| h[step_definition] = [] }
+      end
+
+      def visit_step(step)
+        @step_duration = Time.now
+        @step = step
+        super
+      end
+
+      def visit_step_name(keyword, step_match, status, source_indent, background)
+        duration = Time.now - @step_duration
+        super
+
+        if step_match.step_definition
+          description = format_step(keyword, step_match, status, nil)
+          @step_definition_durations[step_match.step_definition] << [duration, description, @step.file_colon_line]
+        end
+      end
+
+      def print_summary
+        super
+        @io.puts "\n\nTop #{NUMBER_OF_STEP_DEFINITONS_TO_SHOW} average slowest steps with #{NUMBER_OF_STEP_INVOCATIONS_TO_SHOW} slowest matches:\n"
+
+        mean_durations = map_to_mean_durations(@step_definition_durations)
+        mean_durations = mean_durations.sort_by do |duration_description_location, step_definition, mean_duration| 
+          mean_duration
+        end.reverse
+
+        mean_durations[0...NUMBER_OF_STEP_DEFINITONS_TO_SHOW].each do |duration_description_location, step_definition, mean_duration|
+          print_step_definition(step_definition, mean_duration)
+          duration_description_location = duration_description_location.sort_by do |duration, description, location| 
+            duration 
+          end.reverse
+          print_step_definitions(duration_description_location, step_definition)
+        end
+      end
+
+      private
+
+      def map_to_mean_durations(step_definition_durations)
+        mean_durations = []
+        step_definition_durations.each do |step_definition, duration_description_location|
+          total_duration = duration_description_location.inject(0) { |sum, step_details| step_details[0] + sum }
+          mean_duration = total_duration / duration_description_location.length
+
+          mean_durations << [duration_description_location, step_definition, mean_duration]
+        end
+        mean_durations
+      end
+
+      def print_step_definition(step_definition, mean_duration)
+        duration = sprintf("%.7f",  mean_duration)
+        @io.puts format_string("#{duration} #{step_definition.backtrace_line}", :failed)
+      end
+
+      def print_step_definitions(duration_description_location, step_definition)
+        max_length = duration_description_location[0...NUMBER_OF_STEP_INVOCATIONS_TO_SHOW].map{|_, d, _| d.jlength}.max
+        duration_description_location[0...NUMBER_OF_STEP_INVOCATIONS_TO_SHOW].each do |duration, description, location|
+          @io.print format_string("  #{sprintf("%.7f", duration)}", :pending)
+          @io.print "  #{description}"
+          @io.print format_string("  # #{location}".indent(max_length - description.jlength), :comment)
+          @io.puts
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/progress.rb

@@ -0,0 +1,60 @@
+require 'cucumber/formatter/console'
+
+module Cucumber
+  module Formatter
+    class Progress < Ast::Visitor
+      include Console
+
+      def initialize(step_mother, io, options)
+        super(step_mother)
+        @io = io
+        @options = options
+      end
+
+      def visit_features(features)
+        super
+        @io.puts
+        @io.puts
+        print_summary
+      end
+
+      def visit_multiline_arg(multiline_arg)
+        @multiline_arg = true
+        super
+        @multiline_arg = false
+      end
+
+      def visit_step_name(keyword, step_match, status, source_indent, background)
+        progress(status) unless status == :outline
+      end
+
+      def visit_table_cell_value(value, width, status)
+        progress(status) if (status != :thead) && !@multiline_arg
+      end
+
+      private
+
+      def print_summary
+        print_steps(:pending)
+        print_steps(:failed)
+        print_counts
+        print_snippets(@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
+      
+    end
+  end
+end

data/lib/cucumber/formatter/rerun.rb

@@ -0,0 +1,35 @@
+module Cucumber
+  module Formatter
+    class Rerun < Ast::Visitor
+      def initialize(step_mother, io, options)
+        super(step_mother)
+        @io = io
+        @file_names = []
+        @file_colon_lines = Hash.new{|h,k| h[k] = []}
+      end
+
+      def visit_features(features)
+        super
+        files = @file_names.uniq.map do |file|
+          lines = @file_colon_lines[file]
+          "#{file}:#{lines.join(':')}"
+        end
+        @io.puts files.join(' ')
+      end
+
+      def visit_feature_element(feature_element)
+        @rerun = false
+        super
+        if @rerun
+          file, line = *feature_element.file_colon_line.split(':')
+          @file_colon_lines[file] << line
+          @file_names << file
+        end
+      end
+
+      def visit_step_name(keyword, step_match, status, source_indent, background)
+        @rerun = true if [:failed].index(status)
+      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
+      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.rb

@@ -0,0 +1 @@
+%w{color_io pretty progress profile rerun html}.each{|n| require "cucumber/formatter/#{n}"}

data/lib/cucumber/formatters/unicode.rb

@@ -0,0 +1,2 @@
+# This is for backwards compatibility
+require 'cucumber/formatter/unicode'

data/lib/cucumber/jbehave.rb

@@ -0,0 +1,97 @@
+if defined?(JRUBY_VERSION)
+  require 'java'
+
+  Exception::CUCUMBER_FILTER_PATTERNS.unshift(/^org\/jruby|^org\/jbehave|^org\/junit|^java\/|^sun\/|^\$_dot_dot_/)
+
+  module Cucumber
+    module JBehave
+      # Register an instance of org.jbehave.scenario.steps.Steps
+      def JBehave(jbehave_steps)
+        jbehave_steps.getSteps.each do |jbehave_candidate_step|
+          step_definitions << JBehaveStepDefinition.new(jbehave_steps, jbehave_candidate_step)
+        end
+      end
+    
+      # Open up so we can get the pattern....
+      JBehaveCandidateStep = org.jbehave.scenario.steps.CandidateStep
+      class JBehaveCandidateStep
+        field_reader :pattern
+      end
+    
+      # Adapter for JBehave org.jbehave.scenario.steps.CandidateStep
+      class JBehaveStepDefinition
+        def initialize(jbehave_steps, jbehave_candidate_step)
+          @jbehave_steps = jbehave_steps
+          @jbehave_candidate_step = jbehave_candidate_step
+          @regexp = Regexp.new(jbehave_candidate_step.pattern.pattern)
+        end
+
+        def step_match(name_to_match, name_to_report)
+          if(match = name_to_match.match(@regexp))
+            StepMatch.new(self, name_to_match, name_to_report, match.captures)
+          else
+            nil
+          end
+        end
+
+        def file_colon_line
+          @jbehave_steps.java_class.name
+        end
+
+        def format_args(step_name, format)
+          step_name.gzub(@regexp, format)
+        end
+
+        def invoke(world, args, step_name)
+          step = @jbehave_candidate_step.createFrom("Given #{step_name}") # JBehave doesn't care about the adverb.
+          step = @jbehave_candidate_step.__send__(:createStep, "Given #{step_name}", args) # JBehave doesn't care about the adverb.
+
+          result = step.perform
+          result.describeTo(Reporter)
+        end
+      end
+
+      # Implements the org.jbehave.scenario.reporters.ScenarioReporter methods
+      class Reporter
+        def self.successful(step_text)
+          # noop
+        end
+
+        def self.failed(step, java_exception)
+          raise java_exception_to_ruby_exception(java_exception)
+        end
+
+        private
+      
+        def self.java_exception_to_ruby_exception(java_exception)
+          # OK, this is a little funky - JRuby weirdness
+          ruby_exception = org.jruby.NativeException.new(JRuby.runtime, JBehaveException, java_exception)
+          ruby_exception.set_backtrace([]) # work around backtrace bug in jruby
+          exception = JBehaveException.new("#{java_exception.getClass.getName}: #{java_exception.getMessage}")
+          bt = ruby_exception.backtrace
+          Exception.cucumber_strip_backtrace!(bt, nil, nil)
+          exception.set_backtrace(bt)
+          exception
+        end
+      end
+
+      class JBehaveException < Exception
+      end
+
+      def self.snippet_text(step_keyword, step_name)
+        camel = step_name.gsub(/(\s.)/) {$1.upcase.strip}
+        method = camel[0..0].downcase + camel[1..-1]
+        snippet = %{    @#{step_keyword}("#{step_name}")
+    public void #{method}() {
+        throw new RuntimeException("pending");
+    }}
+      end
+    end
+  end
+
+  self.extend(Cucumber::JBehave)
+  self.snippet_generator = Cucumber::JBehave
+else
+  STDERR.puts "ERROR: cucumber/jbehave only works with JRuby"
+  Kernel.exit(1)
+end