cucumber 3.2.0 → 4.0.0.rc.1

data/lib/cucumber/formatter/io.rb

@@ -1,27 +1,21 @@
 # frozen_string_literal: true
 
-require 'cucumber/formatter/http_io'
-
 module Cucumber
   module Formatter
     module Io
       module_function
 
-      def ensure_io(path_or_url_or_io)
-        return nil if path_or_url_or_io.nil?
-        return path_or_url_or_io if path_or_url_or_io.respond_to?(:write)
-        io = if path_or_url_or_io =~ %r{^https?://}
-               HTTPIO.open(path_or_url_or_io)
-             else
-               File.open(path_or_url_or_io, Cucumber.file_mode('w'))
-             end
+      def ensure_io(path_or_io)
+        return nil if path_or_io.nil?
+        return path_or_io if path_or_io.respond_to?(:write)
+        file = File.open(path_or_io, Cucumber.file_mode('w'))
         at_exit do
-          unless io.closed?
-            io.flush
-            io.close
+          unless file.closed?
+            file.flush
+            file.close
           end
         end
-        io
+        file
       end
 
       def ensure_file(path, name)

data/lib/cucumber/formatter/json.rb

@@ -4,7 +4,7 @@ require 'multi_json'
 require 'base64'
 require 'cucumber/formatter/backtrace_filter'
 require 'cucumber/formatter/io'
-require 'cucumber/formatter/hook_query_visitor'
+require 'cucumber/formatter/ast_lookup'
 
 module Cucumber
   module Formatter
@@ -14,6 +14,7 @@ module Cucumber
 
       def initialize(config)
         @io = ensure_io(config.out_stream)
+        @ast_lookup = AstLookup.new(config)
         @feature_hashes = []
         @step_or_hook_hash = {}
         config.on_event :test_case_started, &method(:on_test_case_started)
@@ -25,16 +26,18 @@ module Cucumber
 
       def on_test_case_started(event)
         test_case = event.test_case
-        builder = Builder.new(test_case)
-        unless same_feature_as_previous_test_case?(test_case.feature)
+        builder = Builder.new(test_case, @ast_lookup)
+        unless same_feature_as_previous_test_case?(test_case)
           @feature_hash = builder.feature_hash
           @feature_hashes << @feature_hash
         end
         @test_case_hash = builder.test_case_hash
         if builder.background?
+          @in_background = true
           feature_elements << builder.background_hash
           @element_hash = builder.background_hash
         else
+          @in_background = false
           feature_elements << @test_case_hash
           @element_hash = @test_case_hash
         end
@@ -44,17 +47,17 @@ module Cucumber
       def on_test_step_started(event)
         test_step = event.test_step
         return if internal_hook?(test_step)
-        hook_query = HookQueryVisitor.new(test_step)
-        if hook_query.hook?
+        if test_step.hook?
           @step_or_hook_hash = {}
-          hooks_of_type(hook_query) << @step_or_hook_hash
+          hooks_of_type(test_step) << @step_or_hook_hash
           return
         end
         if first_step_after_background?(test_step)
+          @in_background = false
           feature_elements << @test_case_hash
           @element_hash = @test_case_hash
         end
-        @step_or_hook_hash = create_step_hash(test_step.source.last)
+        @step_or_hook_hash = create_step_hash(test_step)
         steps << @step_or_hook_hash
         @step_hash = @step_or_hook_hash
       end
@@ -82,42 +85,34 @@ module Cucumber
       end
 
       def embed(src, mime_type, _label)
-        begin
-          is_file = File.file?(src)
-        rescue ArgumentError
-          is_file = false
-        end
-
-        if is_file
+        if File.file?(src)
           content = File.open(src, 'rb', &:read)
           data = encode64(content)
+        elsif mime_type =~ /;base64$/
+          mime_type = mime_type[0..-8]
+          data = src
         else
-          if mime_type =~ /;base64$/
-            mime_type = mime_type[0..-8]
-            data = src
-          else
-            data = encode64(src)
-          end
+          data = encode64(src)
         end
         test_step_embeddings << { mime_type: mime_type, data: data }
       end
 
       private
 
-      def same_feature_as_previous_test_case?(feature)
-        current_feature[:uri] == feature.file && current_feature[:line] == feature.location.line
+      def same_feature_as_previous_test_case?(test_case)
+        current_feature[:uri] == test_case.location.file
       end
 
       def first_step_after_background?(test_step)
-        test_step.source[1].to_s != @element_hash[:name]
+        @in_background && test_step.location.lines.max >= @test_case_hash[:line]
       end
 
       def internal_hook?(test_step)
-        test_step.source.last.location.file.include?('lib/cucumber/')
+        test_step.location.file.include?('lib/cucumber/')
       end
 
       def current_feature
-        @feature_hash ||= {}
+        @feature_hash ||= {} # rubocop:disable Naming/MemoizedInstanceVariableName
       end
 
       def feature_elements
@@ -128,16 +123,16 @@ module Cucumber
         @element_hash[:steps] ||= []
       end
 
-      def hooks_of_type(hook_query)
-        case hook_query.type
-        when :before
-          return before_hooks
-        when :after
-          return after_hooks
-        when :after_step
-          return after_step_hooks
+      def hooks_of_type(hook_step)
+        case hook_step.text
+        when 'Before hook'
+          before_hooks
+        when 'After hook'
+          after_hooks
+        when 'AfterStep hook'
+          after_step_hooks
         else
-          fail 'Unknown hook type ' + hook_query.type.to_s
+          raise 'Unknown hook type ' + hook_step.to_s
         end
       end
 
@@ -165,30 +160,30 @@ module Cucumber
         @step_or_hook_hash[:embeddings] ||= []
       end
 
-      def create_step_hash(step_source)
+      def create_step_hash(test_step)
+        step_source = @ast_lookup.step_source(test_step).step
         step_hash = {
-          keyword: step_source.keyword,
-          name: step_source.to_s,
-          line: step_source.original_location.line
+          keyword: step_source[:keyword],
+          name: test_step.text,
+          line: test_step.location.lines.min
         }
-        step_hash[:comments] = Formatter.create_comments_array(step_source.comments) unless step_source.comments.empty?
-        step_hash[:doc_string] = create_doc_string_hash(step_source.multiline_arg) if step_source.multiline_arg.doc_string?
-        step_hash[:rows] = create_data_table_value(step_source.multiline_arg) if step_source.multiline_arg.data_table?
+        step_hash[:doc_string] = create_doc_string_hash(step_source[:doc_string]) unless step_source[:doc_string].nil?
+        step_hash[:rows] = create_data_table_value(step_source[:data_table]) unless step_source[:data_table].nil?
         step_hash
       end
 
       def create_doc_string_hash(doc_string)
-        content_type = doc_string.content_type ? doc_string.content_type : ''
+        content_type = doc_string[:content_type] || ''
         {
-          value: doc_string.content,
+          value: doc_string[:content],
           content_type: content_type,
-          line: doc_string.location.line
+          line: doc_string[:location][:line]
         }
       end
 
       def create_data_table_value(data_table)
-        data_table.raw.map do |row|
-          { cells: row }
+        data_table[:rows].map do |row|
+          { cells: row[:cells].map { |cell| cell[:value] } }
         end
       end
 
@@ -232,113 +227,94 @@ module Cucumber
       class Builder
         attr_reader :feature_hash, :background_hash, :test_case_hash
 
-        def initialize(test_case)
+        def initialize(test_case, ast_lookup)
           @background_hash = nil
-          test_case.describe_source_to(self)
-          test_case.feature.background.describe_to(self)
+          uri = test_case.location.file
+          feature = ast_lookup.gherkin_document(uri)[:feature]
+          feature(feature, uri)
+          background(feature[:children].first[:background]) unless feature[:children].first[:background].nil?
+          scenario(ast_lookup.scenario_source(test_case), test_case)
         end
 
         def background?
           @background_hash != nil
         end
 
-        def feature(feature)
+        def feature(feature, uri)
           @feature_hash = {
-            uri: feature.file,
-            id: create_id(feature),
-            keyword: feature.keyword,
-            name: feature.to_s,
-            description: feature.description,
-            line: feature.location.line
+            id: create_id(feature[:name]),
+            uri: uri,
+            keyword: feature[:keyword],
+            name: feature[:name],
+            description: value_or_empty_string(feature[:description]),
+            line: feature[:location][:line]
           }
-          unless feature.tags.empty?
-            @feature_hash[:tags] = create_tags_array(feature.tags)
-            @test_case_hash[:tags] = if @test_case_hash[:tags]
-                                       @feature_hash[:tags] + @test_case_hash[:tags]
-                                     else
-                                       @feature_hash[:tags]
-                                     end
-          end
-          @feature_hash[:comments] = Formatter.create_comments_array(feature.comments) unless feature.comments.empty?
-          @test_case_hash[:id].insert(0, @feature_hash[:id] + ';')
+          return if feature[:tags].empty?
+          @feature_hash[:tags] = create_tags_array_from_hash_array(feature[:tags])
         end
 
         def background(background)
           @background_hash = {
-            keyword: background.keyword,
-            name: background.to_s,
-            description: background.description,
-            line: background.location.line,
+            keyword: background[:keyword],
+            name: background[:name],
+            description: value_or_empty_string(background[:description]),
+            line: background[:location][:line],
             type: 'background'
           }
-          @background_hash[:comments] = Formatter.create_comments_array(background.comments) unless background.comments.empty?
         end
 
-        def scenario(scenario)
+        def scenario(scenario_source, test_case)
+          scenario = scenario_source.type == :Scenario ? scenario_source.scenario : scenario_source.scenario_outline
           @test_case_hash = {
-            id: create_id(scenario),
-            keyword: scenario.keyword,
-            name: scenario.to_s,
-            description: scenario.description,
-            line: scenario.location.line,
+            id: "#{@feature_hash[:id]};#{create_id_from_scenario_source(scenario_source)}",
+            keyword: scenario[:keyword],
+            name: scenario[:name],
+            description: value_or_empty_string(scenario[:description]),
+            line: test_case.location.lines.max,
             type: 'scenario'
           }
-          @test_case_hash[:tags] = create_tags_array(scenario.tags) unless scenario.tags.empty?
-          @test_case_hash[:comments] = Formatter.create_comments_array(scenario.comments) unless scenario.comments.empty?
+          @test_case_hash[:tags] = create_tags_array_from_tags_array(test_case.tags) unless test_case.tags.empty?
         end
 
-        def scenario_outline(scenario)
-          @test_case_hash = {
-            id: create_id(scenario) + ';' + @example_id,
-            keyword: scenario.keyword,
-            name: scenario.to_s,
-            description: scenario.description,
-            line: @row.location.line,
-            type: 'scenario'
-          }
-          tags = []
-          tags += create_tags_array(scenario.tags) unless scenario.tags.empty?
-          tags += @examples_table_tags if @examples_table_tags
-          @test_case_hash[:tags] = tags unless tags.empty?
-          comments = []
-          comments += Formatter.create_comments_array(scenario.comments) unless scenario.comments.empty?
-          comments += @examples_table_comments if @examples_table_comments
-          comments += @row_comments if @row_comments
-          @test_case_hash[:comments] = comments unless comments.empty?
-        end
+        private
 
-        def examples_table(examples_table)
-          # the json file have traditionally used the header row as row 1,
-          # wheras cucumber-ruby-core used the first example row as row 1.
-          @example_id = create_id(examples_table) + ";#{@row.number + 1}"
+        def value_or_empty_string(value)
+          value.nil? ? '' : value
+        end
 
-          @examples_table_tags = create_tags_array(examples_table.tags) unless examples_table.tags.empty?
-          @examples_table_comments = Formatter.create_comments_array(examples_table.comments) unless examples_table.comments.empty?
+        def create_id(name)
+          name.downcase.tr(' ', '-')
         end
 
-        def examples_table_row(row)
-          @row = row
-          @row_comments = Formatter.create_comments_array(row.comments) unless row.comments.empty?
+        def create_id_from_scenario_source(scenario_source)
+          if scenario_source.type == :Scenario
+            create_id(scenario_source.scenario[:name])
+          else
+            scenario_outline_name = scenario_source.scenario_outline[:name]
+            examples_name = scenario_source.examples[:name]
+            row_number = calculate_row_number(scenario_source)
+            "#{create_id(scenario_outline_name)};#{create_id(examples_name)};#{row_number}"
+          end
         end
 
-        private
+        def calculate_row_number(scenario_source)
+          scenario_source.examples[:table_body].each_with_index do |row, index|
+            return index + 2 if row == scenario_source.row
+          end
+        end
 
-        def create_id(element)
-          element.to_s.downcase.tr(' ', '-')
+        def create_tags_array_from_hash_array(tags)
+          tags_array = []
+          tags.each { |tag| tags_array << { name: tag[:name], line: tag[:location][:line] } }
+          tags_array
         end
 
-        def create_tags_array(tags)
+        def create_tags_array_from_tags_array(tags)
           tags_array = []
           tags.each { |tag| tags_array << { name: tag.name, line: tag.location.line } }
           tags_array
         end
       end
     end
-
-    def self.create_comments_array(comments)
-      comments_array = []
-      comments.each { |comment| comments_array << { value: comment.to_s.strip, line: comment.location.line } }
-      comments_array
-    end
   end
 end

data/lib/cucumber/formatter/junit.rb

@@ -5,6 +5,7 @@ require 'cucumber/formatter/backtrace_filter'
 require 'cucumber/formatter/io'
 require 'cucumber/formatter/interceptor'
 require 'fileutils'
+require 'cucumber/formatter/ast_lookup'
 
 module Cucumber
   module Formatter
@@ -19,6 +20,7 @@ module Cucumber
       end
 
       def initialize(config)
+        @ast_lookup = AstLookup.new(config)
         config.on_event :test_case_started, &method(:on_test_case_started)
         config.on_event :test_case_finished, &method(:on_test_case_finished)
         config.on_event :test_step_finished, &method(:on_test_step_finished)
@@ -33,17 +35,15 @@ module Cucumber
             tests: 0,
             skipped: 0,
             time: 0,
-            builder: Builder::XmlMarkup.new(:indent => 2)
+            builder: Builder::XmlMarkup.new(indent: 2)
           }
         end
       end
 
       def on_test_case_started(event)
         test_case = event.test_case
-        unless same_feature_as_previous_test_case?(test_case.feature)
-          start_feature(test_case.feature)
-        end
-        @failing_step_source = nil
+        start_feature(test_case) unless same_feature_as_previous_test_case?(test_case)
+        @failing_test_step = nil
         # In order to fill out <system-err/> and <system-out/>, we need to
         # intercept the $stderr and $stdout
         @interceptedout = Interceptor::Pipe.wrap(:stdout)
@@ -52,15 +52,15 @@ module Cucumber
 
       def on_test_step_finished(event)
         test_step, result = *event.attributes
-        return if @failing_step_source
+        return if @failing_test_step
 
-        @failing_step_source = test_step.source.last unless result.ok?(@config.strict)
+        @failing_test_step = test_step unless result.ok?(@config.strict)
       end
 
       def on_test_case_finished(event)
         test_case, result = *event.attributes
         result = result.with_filtered_backtrace(Cucumber::Formatter::BacktraceFilter)
-        test_case_name = NameBuilder.new(test_case)
+        test_case_name = NameBuilder.new(test_case, @ast_lookup)
         scenario = test_case_name.scenario_name
         scenario_designation = "#{scenario}#{test_case_name.name_suffix}"
         output = create_output_string(test_case, scenario, result, test_case_name.row_name)
@@ -71,45 +71,54 @@ module Cucumber
       end
 
       def on_test_run_finished(_event)
-        @features_data.each { |file, data| end_feature(data) }
+        @features_data.each { |_file, data| end_feature(data) }
       end
 
       private
 
-      def same_feature_as_previous_test_case?(feature)
-        @current_feature_data && @current_feature_data[:feature].file == feature.file && @current_feature_data[:feature].location == feature.location
+      def same_feature_as_previous_test_case?(test_case)
+        @current_feature_data && @current_feature_data[:uri] == test_case.location.file
       end
 
-      def start_feature(feature)
-        raise UnNamedFeatureError.new(feature.file) if feature.name.empty?
-        @current_feature_data = @features_data[feature.file]
+      def start_feature(test_case)
+        uri = test_case.location.file
+        feature = @ast_lookup.gherkin_document(uri)[:feature]
+        raise UnNamedFeatureError, uri if feature[:name].empty?
+        @current_feature_data = @features_data[uri]
+        @current_feature_data[:uri] = uri unless @current_feature_data[:uri]
         @current_feature_data[:feature] = feature unless @current_feature_data[:feature]
       end
 
       def end_feature(feature_data)
-        @testsuite = Builder::XmlMarkup.new(:indent => 2)
+        @testsuite = Builder::XmlMarkup.new(indent: 2)
         @testsuite.instruct!
         @testsuite.testsuite(
-          :failures => feature_data[:failures],
-          :errors => feature_data[:errors],
-          :skipped => feature_data[:skipped],
-          :tests => feature_data[:tests],
-          :time => format('%.6f', feature_data[:time]),
-          :name => feature_data[:feature].name
+          failures: feature_data[:failures],
+          errors: feature_data[:errors],
+          skipped: feature_data[:skipped],
+          tests: feature_data[:tests],
+          time: format('%.6f', feature_data[:time]),
+          name: feature_data[:feature][:name]
         ) do
           @testsuite << feature_data[:builder].target!
         end
 
-        write_file(feature_result_filename(feature_data[:feature].file), @testsuite.target!)
+        write_file(feature_result_filename(feature_data[:uri]), @testsuite.target!)
       end
 
-      def create_output_string(test_case, scenario, result, row_name)
-        output = "#{test_case.keyword}: #{scenario}\n\n"
+      def create_output_string(test_case, scenario, result, row_name) # rubocop:disable Metrics/PerceivedComplexity
+        scenario_source = @ast_lookup.scenario_source(test_case)
+        keyword = scenario_source.type == :Scenario ? scenario_source.scenario[:keyword] : scenario_source.scenario_outline[:keyword]
+        output = "#{keyword}: #{scenario}\n\n"
         return output if result.ok?(@config.strict)
-        if test_case.keyword == 'Scenario'
-          if @failing_step_source
-            output += @failing_step_source.keyword.to_s unless hook?(@failing_step_source)
-            output += "#{@failing_step_source}\n"
+        if scenario_source.type == :Scenario
+          if @failing_test_step
+            if @failing_test_step.hook?
+              output += "#{@failing_test_step.text} at #{@failing_test_step.location}\n"
+            else
+              step_source = @ast_lookup.step_source(@failing_test_step).step
+              output += "#{step_source[:keyword]}#{@failing_test_step.text}\n"
+            end
           else # An Around hook has failed
             output += "Around hook\n"
           end
@@ -119,24 +128,20 @@ module Cucumber
         output + "\nMessage:\n"
       end
 
-      def hook?(step)
-        ['Before hook', 'After hook', 'AfterStep hook'].include? step.text
-      end
-
       def build_testcase(result, scenario_designation, output)
         duration = ResultBuilder.new(result).test_case_duration
         @current_feature_data[:time] += duration
-        classname = @current_feature_data[:feature].name
+        classname = @current_feature_data[:feature][:name]
         name = scenario_designation
 
-        @current_feature_data[:builder].testcase(:classname => classname, :name => name, :time => format('%.6f', duration)) do
+        @current_feature_data[:builder].testcase(classname: classname, name: name, time: format('%.6f', duration)) do
           if !result.passed? && result.ok?(@config.strict)
             @current_feature_data[:builder].skipped
             @current_feature_data[:skipped] += 1
           elsif !result.passed?
             status = result.to_sym
             exception = get_backtrace_object(result)
-            @current_feature_data[:builder].failure(:message => "#{status} #{name}", :type => status) do
+            @current_feature_data[:builder].failure(message: "#{status} #{name}", type: status) do
               @current_feature_data[:builder].cdata! output
               @current_feature_data[:builder].cdata!(format_exception(exception)) if exception
             end
@@ -154,11 +159,9 @@ module Cucumber
 
       def get_backtrace_object(result)
         if result.failed?
-          return result.exception
+          result.exception
         elsif result.backtrace
-          return result
-        else
-          return nil
+          result
         end
       end
 
@@ -171,7 +174,7 @@ module Cucumber
       end
 
       def basename(feature_file)
-        File.basename(feature_file.gsub(/[\\\/]/, '-'), '.feature')
+        File.basename(feature_file.gsub(/[\\\/]/, '-'), '.feature') # rubocop:disable Style/RegexpLiteral
       end
 
       def write_file(feature_filename, data)
@@ -187,34 +190,29 @@ module Cucumber
     class NameBuilder
       attr_reader :scenario_name, :name_suffix, :row_name
 
-      def initialize(test_case)
+      def initialize(test_case, ast_lookup)
         @name_suffix = ''
         @row_name = ''
-        test_case.describe_source_to self
-      end
-
-      def feature(*)
-        self
+        scenario_source = ast_lookup.scenario_source(test_case)
+        if scenario_source.type == :Scenario
+          scenario(scenario_source.scenario)
+        else
+          scenario_outline(scenario_source.scenario_outline)
+          examples_table_row(scenario_source.row)
+        end
       end
 
       def scenario(scenario)
-        @scenario_name = (scenario.name.nil? || scenario.name == '') ? 'Unnamed scenario' : scenario.name
-        self
+        @scenario_name = scenario[:name].empty? ? 'Unnamed scenario' : scenario[:name]
       end
 
       def scenario_outline(outline)
-        @scenario_name = (outline.name.nil? || outline.name == '') ? 'Unnamed scenario outline' : outline.name
-        self
-      end
-
-      def examples_table(*)
-        self
+        @scenario_name = outline[:name].empty? ? 'Unnamed scenario outline' : outline[:name]
       end
 
       def examples_table_row(row)
-        @row_name = '| ' + row.values.join(' | ') + ' |'
+        @row_name = '| ' + row[:cells].map { |cell| cell[:value] }.join(' | ') + ' |'
         @name_suffix = " (outline example : #{@row_name})"
-        self
       end
     end
 
@@ -238,7 +236,7 @@ module Cucumber
       def exception(*) end
 
       def duration(duration, *)
-        duration.tap { |duration| @test_case_duration = duration.nanoseconds / 10**9.0 }
+        duration.tap { |dur| @test_case_duration = dur.nanoseconds / 10**9.0 }
       end
     end
   end