cucumber 3.0.0.pre.1 → 4.0.0.rc.4

data/lib/cucumber/formatter/console_counts.rb

@@ -6,51 +6,33 @@ module Cucumber
       include Console
 
       def initialize(config)
-        @test_case_summary = Core::Test::Result::Summary.new
-        @test_step_summary = Core::Test::Result::Summary.new
-
-        config.on_event :test_case_finished do |event|
-          event.result.describe_to @test_case_summary
-        end
-
-        config.on_event :test_step_finished do |event|
-          event.result.describe_to @test_step_summary if from_gherkin?(event.test_step)
-        end
+        @summary = Core::Report::Summary.new(config.event_bus)
       end
 
       def to_s
         [
-          [scenario_count, status_counts(@test_case_summary)].compact.join(" "),
-          [step_count, status_counts(@test_step_summary)].compact.join(" ")
+          [scenario_count, status_counts(@summary.test_cases)].compact.join(' '),
+          [step_count, status_counts(@summary.test_steps)].compact.join(' ')
         ].join("\n")
       end
 
       private
 
-      def from_gherkin?(test_step)
-        test_step.source.last.location.file.match(/\.feature$/)
-      end
-
       def scenario_count
-        count = @test_case_summary.total
-        "#{count} scenario" + (count == 1 ? "" : "s")
+        count = @summary.test_cases.total
+        "#{count} scenario" + (count == 1 ? '' : 's')
       end
 
       def step_count
-        count = @test_step_summary.total
-        "#{count} step" + (count == 1 ? "" : "s")
+        count = @summary.test_steps.total
+        "#{count} step" + (count == 1 ? '' : 's')
       end
 
       def status_counts(summary)
-        counts = [:failed, :skipped, :undefined, :pending, :passed].map { |status|
-          count = summary.total(status)
-          [status, count]
-        }.select { |status, count|
-          count > 0
-        }.map { |status, count|
-          format_string("#{count} #{status}", status)
-        }
-        "(#{counts.join(", ")})" if counts.any?
+        counts = Core::Test::Result::TYPES.map { |status| [status, summary.total(status)] }
+        counts = counts.select { |_status, count| count > 0 }
+        counts = counts.map { |status, count| format_string("#{count} #{status}", status) }
+        "(#{counts.join(', ')})" if counts.any?
       end
     end
   end

data/lib/cucumber/formatter/console_issues.rb

@@ -5,29 +5,53 @@ module Cucumber
     class ConsoleIssues
       include Console
 
-      def initialize(config)
-        @failures = []
+      def initialize(config, ast_lookup = AstLookup.new(config))
+        @previous_test_case = nil
+        @issues = Hash.new { |h, k| h[k] = [] }
         @config = config
         @config.on_event(:test_case_finished) do |event|
-          @failures << event.test_case if event.result.failed?
+          if event.test_case != @previous_test_case
+            @previous_test_case = event.test_case
+            @issues[event.result.to_sym] << event.test_case unless event.result.ok?(@config.strict)
+          elsif event.result.passed?
+            @issues[:flaky] << event.test_case unless Core::Test::Result::Flaky.ok?(@config.strict.strict?(:flaky))
+            @issues[:failed].delete(event.test_case)
+          end
         end
+        @ast_lookup = ast_lookup
       end
 
       def to_s
-        return if @failures.empty?
-        result = [ format_string("Failing Scenarios:", :failed) ] + @failures.map { |failure|
-          source = @config.source? ? format_string(" # #{failure.keyword}: #{failure.name}", :comment) : ''
-          format_string("cucumber #{profiles_string}" + failure.location, :failed) + source
-        }
-        result.join("\n")
+        return if @issues.empty?
+        result = Core::Test::Result::TYPES.map { |type| scenario_listing(type, @issues[type]) }
+        result.flatten.join("\n")
       end
 
       def any?
-        @failures.any?
+        @issues.any?
       end
 
       private
 
+      def scenario_listing(type, test_cases)
+        return [] if test_cases.empty?
+        [format_string("#{type_heading(type)} Scenarios:", type)] + test_cases.map do |test_case|
+          scenario_source = @ast_lookup.scenario_source(test_case)
+          keyword = scenario_source.type == :Scenario ? scenario_source.scenario.keyword : scenario_source.scenario_outline.keyword
+          source = @config.source? ? format_string(" # #{keyword}: #{test_case.name}", :comment) : ''
+          format_string("cucumber #{profiles_string}#{test_case.location.file}:#{test_case.location.lines.max}", type) + source
+        end
+      end
+
+      def type_heading(type)
+        case type
+        when :failed
+          'Failing'
+        else
+          type.to_s.slice(0, 1).capitalize + type.to_s.slice(1..-1)
+        end
+      end
+
       def profiles_string
         return if @config.custom_profiles.empty?
         @config.custom_profiles.map { |profile| "-p #{profile}" }.join(' ') + ' '

data/lib/cucumber/formatter/duration.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Cucumber
   module Formatter
     module Duration
@@ -7,7 +8,7 @@ module Cucumber
       # <tt>time</tt> format.
       def format_duration(seconds)
         m, s = seconds.divmod(60)
-        "#{m}m#{'%.3f' % s}s"
+        "#{m}m#{format('%<seconds>.3f', seconds: s)}s"
       end
     end
   end

data/lib/cucumber/formatter/duration_extractor.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
+
 module Cucumber
   module Formatter
-
     class DurationExtractor
       attr_reader :result_duration
       def initialize(result)
@@ -22,8 +22,10 @@ module Cucumber
       def exception(*) end
 
       def duration(duration, *)
-        duration.tap { |duration| @result_duration = duration.nanoseconds / 10**9.0 }
+        duration.tap { |dur| @result_duration = dur.nanoseconds / 10**9.0 }
       end
+
+      def attach(*) end
     end
   end
 end

data/lib/cucumber/formatter/errors.rb

@@ -0,0 +1,6 @@
+module Cucumber
+  module Formatter
+    class TestCaseUnknownError < StandardError; end
+    class TestStepUnknownError < StandardError; end
+  end
+end

data/lib/cucumber/formatter/fail_fast.rb

@@ -1,20 +1,23 @@
 # frozen_string_literal: true
+
 require 'cucumber/formatter/io'
 require 'cucumber/formatter/console'
 
 module Cucumber
   module Formatter
-
     class FailFast
-
       def initialize(configuration)
+        @previous_test_case = nil
         configuration.on_event :test_case_finished do |event|
           test_case, result = *event.attributes
-          Cucumber.wants_to_quit = true unless result.ok?(configuration.strict?)
+          if test_case != @previous_test_case
+            @previous_test_case = event.test_case
+            Cucumber.wants_to_quit = true unless result.ok?(configuration.strict)
+          elsif result.passed?
+            Cucumber.wants_to_quit = false
+          end
         end
       end
-
     end
-
   end
 end

data/lib/cucumber/formatter/fanout.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
+
 module Cucumber
   module Formatter
-
     # Forwards any messages sent to this object to all recipients
     # that respond to that message.
     class Fanout < BasicObject
@@ -13,6 +13,8 @@ module Cucumber
       end
 
       def method_missing(message, *args)
+        super unless recipients
+
         recipients.each do |recipient|
           recipient.send(message, *args) if recipient.respond_to?(message)
         end
@@ -21,8 +23,6 @@ module Cucumber
       def respond_to_missing?(name, include_private = false)
         recipients.any? { |recipient| recipient.respond_to?(name, include_private) }
       end
-
     end
-
   end
 end

data/lib/cucumber/formatter/ignore_missing_messages.rb

@@ -1,21 +1,19 @@
 # frozen_string_literal: true
+
 module Cucumber
   module Formatter
-
     class IgnoreMissingMessages < BasicObject
       def initialize(receiver)
         @receiver = receiver
       end
 
       def method_missing(message, *args)
-        @receiver.send(message, *args) if @receiver.respond_to?(message)
+        @receiver.respond_to?(message) ? @receiver.send(message, *args) : super
       end
 
       def respond_to_missing?(name, include_private = false)
         @receiver.respond_to?(name, include_private)
       end
     end
-
   end
 end
-

data/lib/cucumber/formatter/interceptor.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-require 'thread'
 
 module Cucumber
   module Formatter
@@ -8,20 +7,20 @@ module Cucumber
         attr_reader :pipe
         def initialize(pipe)
           @pipe = pipe
-          @buffer = []
+          @buffer = StringIO.new
           @wrapped = true
         end
 
         def write(str)
-          lock.synchronize do 
+          lock.synchronize do
             @buffer << str if @wrapped
             return @pipe.write(str)
           end
         end
 
-        def buffer
+        def buffer_string
           lock.synchronize do
-            return @buffer.dup
+            return @buffer.string.dup
           end
         end
 
@@ -31,17 +30,15 @@ module Cucumber
         end
 
         def method_missing(method, *args, &blk)
-          @pipe.send(method, *args, &blk)
+          @pipe.send(method, *args, &blk) || super
         end
 
-        def respond_to?(method, include_private=false)
+        def respond_to_missing?(method, include_private = false)
           super || @pipe.respond_to?(method, include_private)
         end
 
         def self.validate_pipe(pipe)
-          unless [:stdout, :stderr].include? pipe
-            raise ArgumentError, '#wrap only accepts :stderr or :stdout'
-          end
+          raise ArgumentError, '#wrap only accepts :stderr or :stdout' unless %i[stdout stderr].include? pipe
         end
 
         def self.unwrap!(pipe)
@@ -63,17 +60,18 @@ module Cucumber
 
           case pipe
           when :stderr
-            $stderr = self.new($stderr)
+            $stderr = new($stderr)
             return $stderr
           when :stdout
-            $stdout = self.new($stdout)
+            $stdout = new($stdout)
             return $stdout
           end
         end
 
-      private
+        private
+
         def lock
-          @lock||=Mutex.new
+          @lock ||= Mutex.new
         end
       end
     end

data/lib/cucumber/formatter/io.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Cucumber
   module Formatter
     module Io
@@ -18,17 +19,17 @@ module Cucumber
       end
 
       def ensure_file(path, name)
-        raise "You *must* specify --out FILE for the #{name} formatter" unless String === path
+        raise "You *must* specify --out FILE for the #{name} formatter" unless String == path.class
         raise "I can't write #{name} to a directory - it has to be a file" if File.directory?(path)
-        raise "I can't write #{name} to a file in the non-existing directory #{File.dirname(path)}" if !File.directory?(File.dirname(path))
+        raise "I can't write #{name} to a file in the non-existing directory #{File.dirname(path)}" unless File.directory?(File.dirname(path))
         ensure_io(path)
       end
 
       def ensure_dir(path, name)
-        raise "You *must* specify --out DIR for the #{name} formatter" unless String === path
+        raise "You *must* specify --out DIR for the #{name} formatter" unless String == path.class
         raise "I can't write #{name} reports to a file - it has to be a directory" if File.file?(path)
         FileUtils.mkdir_p(path) unless File.directory?(path)
-        path
+        File.absolute_path path
       end
     end
   end

data/lib/cucumber/formatter/json.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
+
 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'
+require 'cucumber/deprecate'
 
 module Cucumber
   module Formatter
@@ -12,47 +14,59 @@ module Cucumber
       include Io
 
       def initialize(config)
+        Cucumber::Deprecate::CliOption.deprecate(
+          config.error_stream,
+          '--format=json',
+          "Please use --format=message and stand-alone json-formatter.\n" \
+          'json-formatter homepage: https://github.com/cucumber/cucumber/tree/master/json-formatter#cucumber-json-formatter',
+          '5.0.0'
+        )
+
         @io = ensure_io(config.out_stream)
+        @ast_lookup = AstLookup.new(config)
         @feature_hashes = []
-        config.on_event :test_case_starting, &method(:on_test_case_starting)
+        @step_or_hook_hash = {}
+        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_starting, &method(:on_test_step_starting)
+        config.on_event :test_step_started, &method(:on_test_step_started)
         config.on_event :test_step_finished, &method(:on_test_step_finished)
         config.on_event :test_run_finished, &method(:on_test_run_finished)
       end
 
-      def on_test_case_starting(event)
+      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
         @any_step_failed = false
       end
 
-      def on_test_step_starting(event)
+      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
@@ -66,50 +80,48 @@ module Cucumber
       end
 
       def on_test_case_finished(event)
-        test_case, result = *event.attributes
+        _test_case, result = *event.attributes
         result = result.with_filtered_backtrace(Cucumber::Formatter::BacktraceFilter)
         add_failed_around_hook(result) if result.failed? && !@any_step_failed
       end
 
-      def on_test_run_finished(event)
+      def on_test_run_finished(_event)
         @io.write(MultiJson.dump(@feature_hashes, pretty: true))
       end
 
-      def puts(message)
-        test_step_output << message
-      end
-
-      def embed(src, mime_type, _label)
+      def attach(src, mime_type)
+        if mime_type == 'text/x.cucumber.log+plain'
+          test_step_output << src
+          return
+        end
         if File.file?(src)
-          content = File.open(src, 'rb') { |f| f.read }
+          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].name != @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
@@ -120,16 +132,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 'Unkown hook type ' + hook_query.type.to_s
+          raise 'Unknown hook type ' + hook_step.to_s
         end
       end
 
@@ -157,20 +169,20 @@ 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.name,
-          line: step_source.location.line
+          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.media_type || ''
         {
           value: doc_string.content,
           content_type: content_type,
@@ -179,25 +191,26 @@ module Cucumber
       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(&:value) }
         end
       end
 
       def add_match_and_result(test_step, result)
         @step_or_hook_hash[:match] = create_match_hash(test_step, result)
         @step_or_hook_hash[:result] = create_result_hash(result)
+        result.embeddings.each { |e| embed(e['src'], e['mime_type'], e['label']) } if result.respond_to?(:embeddings)
       end
 
       def add_failed_around_hook(result)
         @step_or_hook_hash = {}
         around_hooks << @step_or_hook_hash
-        @step_or_hook_hash[:match] = { location: "unknown_hook_location:1" }
+        @step_or_hook_hash[:match] = { location: 'unknown_hook_location:1' }
 
         @step_or_hook_hash[:result] = create_result_hash(result)
       end
 
-      def create_match_hash(test_step, result)
+      def create_match_hash(test_step, _result)
         { location: test_step.action_location.to_s }
       end
 
@@ -218,119 +231,100 @@ module Cucumber
 
       def encode64(data)
         # strip newlines from the encoded data
-        Base64.encode64(data).gsub(/\n/, '')
+        Base64.encode64(data).delete("\n")
       end
 
       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),
+            id: create_id(feature.name),
+            uri: uri,
             keyword: feature.keyword,
             name: feature.name,
-            description: feature.description,
+            description: value_or_empty_string(feature.description),
             line: feature.location.line
           }
-          unless feature.tags.empty?
-            @feature_hash[:tags] = create_tags_array(feature.tags)
-            if @test_case_hash[:tags]
-              @test_case_hash[:tags] = @feature_hash[:tags] + @test_case_hash[:tags]
-            else
-              @test_case_hash[:tags] = @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.name,
-            description: background.description,
+            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),
+            id: "#{@feature_hash[:id]};#{create_id_from_scenario_source(scenario_source)}",
             keyword: scenario.keyword,
-            name: scenario.name,
-            description: scenario.description,
-            line: scenario.location.line,
+            name: test_case.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.name,
-            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.name.downcase.gsub(/ /, '-')
+        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