cucumber 1.3.20 → 2.0.0.beta.1

data/lib/cucumber/formatter/junit.rb

@@ -1,4 +1,4 @@
-require 'cucumber/formatter/ordered_xml_markup'
+require 'builder'
 require 'cucumber/formatter/io'
 require 'cucumber/formatter/interceptor'
 require 'fileutils'
@@ -7,6 +7,11 @@ module Cucumber
   module Formatter
     # The formatter used for <tt>--format junit</tt>
     class Junit
+
+      # TODO: remove coupling to types
+      AST_SCENARIO_OUTLINE = Cucumber::Core::Ast::ScenarioOutline
+      AST_EXAMPLE_ROW = Reports::LegacyExampleTableRow
+
       include Io
 
       class UnNamedFeatureError < StandardError
@@ -23,7 +28,7 @@ module Cucumber
       def before_feature(feature)
         @current_feature = feature
         @failures = @errors = @tests = @skipped = 0
-        @builder = OrderedXmlMarkup.new( :indent => 2 )
+        @builder = Builder::XmlMarkup.new( :indent => 2 )
         @time = 0
         # In order to fill out <system-err/> and <system-out/>, we need to
         # intercept the $stderr and $stdout
@@ -32,12 +37,12 @@ module Cucumber
       end
 
       def before_feature_element(feature_element)
-        @in_examples = Ast::ScenarioOutline === feature_element
+        @in_examples = AST_SCENARIO_OUTLINE === feature_element
         @steps_start = Time.now
       end
 
       def after_feature(feature)
-        @testsuite = OrderedXmlMarkup.new( :indent => 2 )
+        @testsuite = Builder::XmlMarkup.new( :indent => 2 )
         @testsuite.instruct!
         @testsuite.testsuite(
           :failures => @failures,
@@ -110,7 +115,7 @@ module Cucumber
       end
 
       def after_table_row(table_row)
-        return unless @in_examples and Cucumber::Ast::OutlineTable::ExampleRow === table_row
+        return unless @in_examples and AST_EXAMPLE_ROW === table_row
         duration = Time.now - @table_start
         unless @header_row
           name_suffix = " (outline example : #{table_row.name})"
@@ -162,8 +167,6 @@ module Cucumber
       end
 
       def write_file(feature_filename, data)
-        return unless @tests > 0
-
         File.open(feature_filename, 'w') { |file| file.write(data) }
       end
 

data/lib/cucumber/formatter/pretty.rb

@@ -33,18 +33,12 @@ module Cucumber
       end
 
       def after_features(features)
-        print_summary(features) unless @options[:autoformat]
+        print_summary(features)
       end
 
       def before_feature(feature)
         @exceptions = []
         @indent = 0
-        if @options[:autoformat]
-          file = File.join(@options[:autoformat], feature.file)
-          dir = File.dirname(file)
-          mkdir_p(dir) unless File.directory?(dir)
-          @io = ensure_file(file, "pretty")
-        end
       end
 
       def comment_line(comment_line)
@@ -219,7 +213,7 @@ module Cucumber
         line = "#{keyword}: #{names[0]}".indent(@scenario_indent)
         @io.print(line)
         if @options[:source]
-          line_comment = " # #{file_colon_line}".indent(source_indent)
+          line_comment = "# #{file_colon_line}".indent(source_indent)
           @io.print(format_string(line_comment, :comment))
         end
         @io.puts

data/lib/cucumber/formatter/rerun.rb

@@ -46,14 +46,13 @@ module Cucumber
       end
 
       def after_feature_element(feature_element)
-        return if Cucumber::Ast::ScenarioOutline === feature_element
-        if  @rerun || feature_element.failed? || feature_element.status == :skipped
+        if (@rerun || feature_element.failed? || feature_element.status == :skipped) && !(Cucumber::Reports::Legacy::Ast::ScenarioOutline === feature_element)
           @lines << feature_element.line
         end
       end
 
       def after_table_row(table_row)
-        return unless @in_examples and Cucumber::Ast::OutlineTable::ExampleRow === table_row
+        return unless @in_examples and Cucumber::Reports::LegacyExampleTableRow === table_row
         unless @header_row
           if table_row.failed? || table_row.status == :skipped
             @rerun = true

data/lib/cucumber/formatter/unicode.rb

@@ -2,11 +2,8 @@
 # Tips for improvement - esp. ruby 1.9: http://www.ruby-forum.com/topic/184730
 require 'cucumber/platform'
 require 'cucumber/formatter/ansicolor'
-$KCODE='u' if Cucumber::RUBY_1_8_7
 
 if Cucumber::WINDOWS
-  require 'iconv' if Cucumber::RUBY_1_8_7
-
   if ENV['CUCUMBER_OUTPUT_ENCODING']
     Cucumber::CODEPAGE = ENV['CUCUMBER_OUTPUT_ENCODING']
   elsif `cmd /c chcp` =~ /(\d+)/
@@ -22,27 +19,17 @@ if Cucumber::WINDOWS
   end
 
   module Cucumber
-    module WindowsOutput #:nodoc:
+    # @private
+    module WindowsOutput
       def self.extended(o)
         o.instance_eval do
+
           def cucumber_preprocess_output(*a)
-            if Cucumber::RUBY_1_8_7
-              begin
-                Iconv.iconv(Cucumber::CODEPAGE, "UTF-8", *a.map{|a|a.to_s})
-              rescue Iconv::InvalidEncoding => e
-                STDERR.cucumber_puts("WARNING: #{e.message}")
-                a
-              rescue Iconv::IllegalSequence => e
-                STDERR.cucumber_puts("WARNING: #{e.message}")
-                a
-              end
-            else
-              begin
-                a.map{|arg| arg.to_s.encode(Encoding.default_external)}
-              rescue Encoding::UndefinedConversionError => e
-                STDERR.cucumber_puts("WARNING: #{e.message}")
-                a
-              end
+            begin
+              a.map{|arg| arg.to_s.encode(Encoding.default_external)}
+            rescue Encoding::UndefinedConversionError => e
+              STDERR.cucumber_puts("WARNING: #{e.message}")
+              a
             end
           end
 

data/lib/cucumber/formatter/usage.rb

@@ -21,6 +21,36 @@ module Cucumber
         print_profile_information
       end
 
+      def before_background(background)
+        @outline = false
+      end
+
+      def before_feature_element(feature_element)
+        case(feature_element)
+        when Core::Ast::Scenario
+          @outline = false
+        when Core::Ast::ScenarioOutline
+          @outline = true
+          if @options[:expand]
+            @in_instantiated_scenario = false
+          end
+        else
+          raise "Bad type: #{feature_element.class}"
+        end
+      end
+
+      def scenario_name(keyword, name, file_colon_line, source_indent)
+        if @outline and @in_instantiated_scenario
+          if @new_example_table
+            @example_row = 1
+            @new_example_table = false
+          else
+            @example_row += 1
+          end
+          @example_line = @current_example_rows[@example_row].to_hash['line']
+        end
+      end
+
       def before_step(step)
         @step = step
         @start_time = Time.now
@@ -35,17 +65,30 @@ module Cucumber
         unless step_definition.nil? # nil if it's from a scenario outline
           stepdef_key = StepDefKey.new(step_definition.regexp_source, step_definition.file_colon_line)
 
+          file_colon_line = @step.file_colon_line
+          if @outline and @in_instantiated_scenario
+            file_colon_line = replace_line_number(@step.file_colon_line, @example_line)
+          end
+
           @stepdef_to_match[stepdef_key] << {
             :keyword => keyword,
             :step_match => step_match,
             :status => status,
-            :file_colon_line => @step.file_colon_line,
+            :file_colon_line => file_colon_line,
             :duration => @duration
           }
         end
         super
       end
 
+      def before_examples(examples)
+        if @options[:expand]
+          @in_instantiated_scenario = true
+          @new_example_table = true
+          @current_example_rows = to_hash(examples.gherkin_statement)['rows']
+        end
+      end
+
       def print_summary(features)
         add_unused_stepdefs
         aggregate_info
@@ -114,19 +157,39 @@ module Cucumber
             key.status = :skipped
             key.mean_duration = 0
           else
-            key.status = Ast::StepInvocation.worst_status(steps.map{|step| step[:status]})
+            key.status = 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 worst_status(statuses)
+        [:passed, :undefined, :pending, :skipped, :failed].find do |status|
+          statuses.include?(status)
+        end
+      end
+
       def add_unused_stepdefs
         @runtime.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
+
+      private
+
+      def replace_line_number(file_colon_line, line)
+        file_colon_line.split(':')[0] + ':' + line.to_s
+      end
+
+      def to_hash(gherkin_statement)
+        if defined?(JRUBY_VERSION)
+          gherkin_statement.toMap()
+        else
+          gherkin_statement.to_hash
+        end
+      end
     end
   end
 end

data/lib/cucumber/language_support/language_methods.rb

@@ -28,7 +28,7 @@ module Cucumber
 
       def execute_after_step(scenario)
         hooks_for(:after_step, scenario).each do |hook|
-          invoke(hook, 'AfterStep', scenario, false)
+          invoke(hook, 'AfterStep', scenario)
         end
       end
 

data/lib/cucumber/mappings.rb

@@ -0,0 +1,212 @@
+require 'cucumber/runtime'
+require 'cucumber'
+require 'cucumber/multiline_argument'
+
+module Cucumber
+  class Mappings
+
+    def self.for(runtime)
+      if runtime.dry_run?
+        Mappings::DryRun.new(runtime)
+      else
+        Mappings.new(runtime)
+      end
+    end
+
+    def initialize(runtime = nil)
+      @runtime = runtime
+    end
+
+    def test_step(step, mapper)
+      map_step(step, mapper)
+      map_after_step_hooks(mapper)
+    end
+
+    def test_case(test_case, mapper)
+      map_test_case(test_case, mapper)
+      map_test_case_hooks(mapper)
+    end
+
+    def runtime
+      return @runtime if @runtime
+      result = Cucumber::Runtime.new
+      result.support_code.load_files!(support_files)
+      @runtime = result
+    end
+
+    private
+
+    attr_reader :scenario
+    private :scenario
+
+    def ruby
+      @ruby ||= runtime.load_programming_language('rb')
+    end
+
+    def support_files
+      Dir['features/**/*.rb']
+    end
+
+    def map_step(step, mapper)
+      step.describe_source_to MapStep.new(runtime, mapper)
+    end
+
+    def map_after_step_hooks(mapper)
+      ruby.hooks_for(:after_step, scenario).each do |hook|
+        mapper.after do
+          hook.invoke 'AfterStep', scenario
+        end
+      end
+    end
+
+    def map_test_case(test_case, mapper)
+      @scenario = Source.new(test_case).build_scenario
+      mapper.before do
+        runtime.begin_scenario(scenario)
+      end
+    end
+
+    def map_test_case_hooks(mapper)
+      ruby.hooks_for(:before, scenario).each do |hook|
+        mapper.before do
+          hook.invoke('Before', scenario)
+        end
+      end
+      ruby.hooks_for(:after, scenario).each do |hook|
+        mapper.after do
+          hook.invoke('After', scenario)
+        end
+      end
+      ruby.hooks_for(:around, scenario).each do |hook|
+        mapper.around do |run_scenario|
+          hook.invoke('Around', scenario, &run_scenario)
+        end
+      end
+    end
+
+    # adapts our test_case to look like the Cucumber Runtime's Scenario
+    class TestCase
+      def initialize(test_case, feature)
+        @test_case = test_case
+        @feature = feature
+      end
+
+      def accept_hook?(hook)
+        hook.tag_expressions.all? { |expression| @test_case.match_tags?(expression) }
+      end
+
+      def language
+        @test_case.language
+      end
+
+      def feature
+        @feature
+      end
+
+      def name
+        @test_case.name
+      end
+
+      def source_tags
+        warn('deprecated: call #tags instead')
+        tags
+      end
+
+      def tags
+        @test_case.tags
+      end
+    end
+
+    class Scenario < TestCase
+    end
+
+    class ScenarioOutlineExample < TestCase
+      def scenario_outline
+        self
+      end
+    end
+
+    class Source
+      def initialize(test_case)
+        @test_case = test_case
+        test_case.describe_source_to(self)
+      end
+
+      def feature(feature)
+        @feature = feature
+      end
+
+      def scenario(scenario)
+        @factory = Scenario
+      end
+
+      def scenario_outline(scenario)
+        @factory = ScenarioOutlineExample
+      end
+
+      def examples_table(examples_table)
+      end
+
+      def examples_table_row(row)
+      end
+
+      def build_scenario
+        @factory.new(@test_case, Feature.new(@feature.legacy_conflated_name_and_description))
+      end
+    end
+
+    class DryRun < Mappings
+
+      private
+
+      def map_test_case(*)
+        # NOOP - we don't want to create World etc for dry run
+      end
+
+      def map_step(step, mapper)
+        step.describe_source_to MapStep::DryRun.new(runtime, mapper)
+      end
+
+      def map_after_step_hooks(mapper)
+        # NOOP - we don't need after step hooks for dry run
+      end
+
+      def map_test_case_hooks(mapper)
+        # NOOP - we don't need hooks for dry run
+      end
+    end
+
+    Feature = Struct.new(:name)
+
+    class MapStep
+      include Cucumber.initializer(:runtime, :mapper)
+
+      def step(node)
+        step_match = runtime.step_match(node.name)
+        map_step(node, step_match)
+      rescue Cucumber::Undefined
+      end
+
+      def feature(*);end
+      def scenario(*);end
+      def background(*);end
+      def scenario_outline(*);end
+      def examples_table(*);end
+      def examples_table_row(*);end
+
+      private
+      def map_step(node, step_match)
+        multiline_arg = MultilineArgument.from(node.multiline_arg)
+        mapper.map { step_match.invoke(multiline_arg) }
+      end
+
+      class DryRun < MapStep
+        private
+        def map_step(node, step_match)
+          mapper.map { raise Core::Test::Result::Skipped, "dry run" }
+        end
+      end
+    end
+
+  end
+end