cucumber-gherkin 18.1.1 → 19.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 06d4222c01a13b4e9f4917d1aa7e1ffdd368c3c03e93642d58e54585d0b25b2b
-  data.tar.gz: 3accb0a9e0a99a9d55793e4469e898900a4382cc072c488214097d4068ec77a7
+  metadata.gz: ae75939385e17d02883ed75667a2d1034016602864c9a315367298774e972fe2
+  data.tar.gz: ebf7593f646b841f9bafa394973640a1930785ee75c5818f6bfd3996829a07d8
 SHA512:
-  metadata.gz: 6f1b8aa5798b485203d30076dd919026f48a1a783769caa3cd048408cfa16ed3a5d79e671be98a3997a59f93bf5e6d997da83a29efa43d2042d83c13f5348b20
-  data.tar.gz: 209bb87a85e7de4f976feb8c9ae1bbaeb5c10a40da0ae09b01c6d627633321cba8336cae9dae02e05e4a96b06e8825765e2784314f72e5d9e226b7e0f4ccd8bc
+  metadata.gz: 42e4469320d69329ac01bebd5ef69e08ad67d87cefaff6d0c14264e6752817c927808675a9b158ccd0e7fd1a56c525ef9dd23ea8fc6de7839b7708dba588f118
+  data.tar.gz: 527c28e2cc74360692db23cc8824fd2124c2ada9eed56d40d7734f543887025fd2cfb532ec2ab2176680027b46c0fbb9532f0dc4c7a0ab296c6037c2376037c5

data/bin/gherkin

@@ -6,13 +6,11 @@ require 'optparse'
 require 'json'
 require 'cucumber/messages'
 require 'gherkin'
-require 'gherkin/stream/subprocess_message_stream'
 
 options = {
   include_source: true,
   include_gherkin_document: true,
   include_pickles: true,
-  format: 'protobuf',
   predictable_ids: false
 }
 
@@ -26,9 +24,6 @@ OptionParser.new do |opts|
   opts.on("--[no-]pickles", "Don't print pickle messages") do |v|
     options[:include_pickles] = v
   end
-  opts.on("--format ndjson|protobuf", "Output format") do |v|
-    options[:format] = v
-  end
   opts.on("--predictable-ids", "Generate incrementing ids rather than UUIDs") do |v|
     options[:id_generator] = Cucumber::Messages::IdGenerator::Incrementing.new if v
   end
@@ -36,33 +31,16 @@ end.parse!
 
 def process_messages(messages, options)
   messages.each do |message|
-    if options[:format] == 'ndjson'
-      message.write_ndjson_to(STDOUT)
-    elsif options[:format] == 'protobuf'
-      message.write_delimited_to(STDOUT)
-    else
-      raise "Unsupported format: #{options[:format]}"
-    end
+    STDOUT.write(JSON.fast_generate(message))
+    STDOUT.write("\n")
   end
 end
 
-gherkin_executable = ENV['GHERKIN_EXECUTABLE']
 if ARGV.empty?
-  # Read protobuf from STDIN
-  messages = Cucumber::Messages::BinaryToMessageEnumerator.new(STDIN)
-elsif gherkin_executable
-  # Read protobuf from STDIN
-  messages = Gherkin::Stream::SubprocessMessageStream.new(
-    gherkin_executable,
-    ARGV,
-    options[:include_source],
-    options[:include_gherkin_document],
-    options[:include_pickles]
-  ).messages
+  # Read from STDIN
+  messages = Cucumber::Messages::NdjsonToMessageEnumerator.new(STDIN)
 else
-  messages = Gherkin.from_paths(
-    ARGV,
-    options
-  )
+  messages = Gherkin.from_paths(ARGV, options)
 end
+
 process_messages(messages, options)

data/lib/gherkin.rb

@@ -30,10 +30,10 @@ module Gherkin
   private
 
   def self.encode_source_message(uri, data)
-    Cucumber::Messages::Source.new({
+    {
       uri: uri,
       data: data,
-      media_type: 'text/x.cucumber.gherkin+plain'
-    })
+      mediaType: 'text/x.cucumber.gherkin+plain'
+    }
   end
 end

data/lib/gherkin/ast_builder.rb

@@ -24,10 +24,10 @@ module Gherkin
 
     def build(token)
       if token.matched_type == :Comment
-        @comments.push(Cucumber::Messages::GherkinDocument::Comment.new(
+        @comments.push({
           location: get_location(token, 0),
           text: token.matched_text
-        ))
+        })
       else
         current_node.add(token.matched_type, token)
       end
@@ -43,10 +43,10 @@ module Gherkin
 
     def get_location(token, column)
       column = column == 0 ? token.location[:column] : column
-      Cucumber::Messages::Location.new(
+      {
         line: token.location[:line],
         column: column
-      )
+      }.delete_if {|k,v| v.nil?}
     end
 
     def get_tags(node)
@@ -56,11 +56,11 @@ module Gherkin
 
       tags_node.get_tokens(:TagLine).each do |token|
         token.matched_items.each do |tag_item|
-          tags.push(Cucumber::Messages::GherkinDocument::Feature::Tag.new(
+          tags.push({
             location: get_location(token, tag_item.column),
             name: tag_item.text,
             id: @id_generator.new_id
-          ))
+          })
         end
       end
 
@@ -69,11 +69,11 @@ module Gherkin
 
     def get_table_rows(node)
       rows = node.get_tokens(:TableRow).map do |token|
-        Cucumber::Messages::GherkinDocument::Feature::TableRow.new(
+        {
           id: @id_generator.new_id,
           location: get_location(token, 0),
           cells: get_cells(token)
-        )
+        }
       end
       ensure_cell_count(rows)
       rows
@@ -81,26 +81,25 @@ module Gherkin
 
     def ensure_cell_count(rows)
       return if rows.empty?
-      cell_count = rows[0].cells.length
+      cell_count = rows[0][:cells].length
       rows.each do |row|
-        if row.cells.length != cell_count
-          location = {line: row.location.line, column: row.location.column}
-          raise AstBuilderException.new("inconsistent cell count within the table", location)
+        if row[:cells].length != cell_count
+          raise AstBuilderException.new("inconsistent cell count within the table", row[:location])
         end
       end
     end
 
     def get_cells(table_row_token)
       table_row_token.matched_items.map do |cell_item|
-        Cucumber::Messages::GherkinDocument::Feature::TableRow::TableCell.new(
+        {
           location: get_location(table_row_token, cell_item.column),
           value: cell_item.text
-        )
+        }
       end
     end
 
     def get_description(node)
-      node.get_single(:Description)
+      node.get_single(:Description) || ''
     end
 
     def get_steps(node)
@@ -114,45 +113,45 @@ module Gherkin
         data_table = node.get_single(:DataTable)
         doc_string = node.get_single(:DocString)
 
-        Cucumber::Messages::GherkinDocument::Feature::Step.new(
+        step = {
           location: get_location(step_line, 0),
           keyword: step_line.matched_keyword,
           text: step_line.matched_text,
-          data_table: data_table,
-          doc_string: doc_string,
+          dataTable: data_table,
+          docString: doc_string,
           id: @id_generator.new_id
-        )
+        }.delete_if {|k,v| v.nil?}
       when :DocString
         separator_token = node.get_tokens(:DocStringSeparator)[0]
         media_type = separator_token.matched_text == '' ? nil : separator_token.matched_text
         line_tokens = node.get_tokens(:Other)
         content = line_tokens.map { |t| t.matched_text }.join("\n")
 
-        Cucumber::Messages::GherkinDocument::Feature::Step::DocString.new(
+        {
           location: get_location(separator_token, 0),
           content: content,
           delimiter: separator_token.matched_keyword,
-          media_type: media_type,
-        )
+          mediaType: media_type,
+        }.delete_if {|k,v| v.nil?}
       when :DataTable
         rows = get_table_rows(node)
-        Cucumber::Messages::GherkinDocument::Feature::Step::DataTable.new(
-          location: rows[0].location,
+        {
+          location: rows[0][:location],
           rows: rows,
-        )
+        }.delete_if {|k,v| v.nil?}
       when :Background
         background_line = node.get_token(:BackgroundLine)
         description = get_description(node)
         steps = get_steps(node)
 
-        Cucumber::Messages::GherkinDocument::Feature::Background.new(
+        {
           id: @id_generator.new_id,
           location: get_location(background_line, 0),
           keyword: background_line.matched_keyword,
           name: background_line.matched_text,
           description: description,
           steps: steps
-        )
+        }.delete_if {|k,v| v.nil?}
       when :ScenarioDefinition
         tags = get_tags(node)
         scenario_node = node.get_single(:Scenario)
@@ -160,7 +159,7 @@ module Gherkin
         description = get_description(scenario_node)
         steps = get_steps(scenario_node)
         examples = scenario_node.get_items(:ExamplesDefinition)
-        Cucumber::Messages::GherkinDocument::Feature::Scenario.new(
+        {
           id: @id_generator.new_id,
           tags: tags,
           location: get_location(scenario_line, 0),
@@ -169,7 +168,7 @@ module Gherkin
           description: description,
           steps: steps,
           examples: examples
-        )
+        }.delete_if {|k,v| v.nil?}
       when :ExamplesDefinition
         tags = get_tags(node)
         examples_node = node.get_single(:Examples)
@@ -178,18 +177,18 @@ module Gherkin
         rows = examples_node.get_single(:ExamplesTable)
 
         table_header = rows.nil? ? nil : rows.first
-        table_body = rows.nil? ? nil : rows[1..-1]
+        table_body = rows.nil? ? [] : rows[1..-1]
 
-        Cucumber::Messages::GherkinDocument::Feature::Scenario::Examples.new(
+        {
           id: @id_generator.new_id,
           tags: tags,
           location: get_location(examples_line, 0),
           keyword: examples_line.matched_keyword,
           name: examples_line.matched_text,
           description: description,
-          table_header: table_header,
-          table_body: table_body,
-        )
+          tableHeader: table_header,
+          tableBody: table_body,
+        }.delete_if {|k,v| v.nil?}
       when :ExamplesTable
         get_table_rows(node)
       when :Description
@@ -206,17 +205,17 @@ module Gherkin
         return unless feature_line
         children = []
         background = node.get_single(:Background)
-        children.push(Cucumber::Messages::GherkinDocument::Feature::FeatureChild.new(background: background)) if background
+        children.push({background: background}) if background
         node.get_items(:ScenarioDefinition).each do |scenario|
-          children.push(Cucumber::Messages::GherkinDocument::Feature::FeatureChild.new(scenario: scenario))
+          children.push({scenario: scenario})
         end
         node.get_items(:Rule).each do |rule|
-          children.push(Cucumber::Messages::GherkinDocument::Feature::FeatureChild.new(rule: rule))
+          children.push({rule: rule})
         end
         description = get_description(header)
         language = feature_line.matched_gherkin_dialect
 
-        Cucumber::Messages::GherkinDocument::Feature.new(
+        {
           tags: tags,
           location: get_location(feature_line, 0),
           language: language,
@@ -224,7 +223,7 @@ module Gherkin
           name: feature_line.matched_text,
           description: description,
           children: children,
-        )
+        }.delete_if {|k,v| v.nil?}
       when :Rule
         header = node.get_single(:RuleHeader)
         return unless header
@@ -233,13 +232,13 @@ module Gherkin
         tags = get_tags(header)
         children = []
         background = node.get_single(:Background)
-        children.push(Cucumber::Messages::GherkinDocument::Feature::FeatureChild::RuleChild.new(background: background)) if background
+        children.push({background: background}) if background
         node.get_items(:ScenarioDefinition).each do |scenario|
-          children.push(Cucumber::Messages::GherkinDocument::Feature::FeatureChild::RuleChild.new(scenario: scenario))
+          children.push({scenario: scenario})
         end
         description = get_description(header)
 
-        Cucumber::Messages::GherkinDocument::Feature::FeatureChild::Rule.new(
+        {
           id: @id_generator.new_id,
           tags: tags,
           location: get_location(rule_line, 0),
@@ -247,13 +246,13 @@ module Gherkin
           name: rule_line.matched_text,
           description: description,
           children: children,
-        )
+        }.delete_if {|k,v| v.nil?}
       when :GherkinDocument
         feature = node.get_single(:Feature)
         {
-          feature: feature,
-          comments: @comments
-        }
+          comments: @comments,
+          feature: feature
+        }.delete_if {|k,v| v.nil?}
       else
         return node
       end

data/lib/gherkin/gherkin-languages.json

@@ -26,7 +26,7 @@
     "name": "Afrikaans",
     "native": "Afrikaans",
     "rule": [
-      "Rule"
+      "Regel"
     ],
     "scenario": [
       "Voorbeeld",
@@ -1675,7 +1675,7 @@
     "name": "Hungarian",
     "native": "magyar",
     "rule": [
-      "Rule"
+      "Szabály"
     ],
     "scenario": [
       "Példa",
@@ -2741,7 +2741,8 @@
       "Сценарий"
     ],
     "scenarioOutline": [
-      "Структура сценария"
+      "Структура сценария",
+      "Шаблон сценария"
     ],
     "then": [
       "* ",

data/lib/gherkin/gherkin_line.rb

@@ -94,7 +94,7 @@ module Gherkin
         end
 
         unless item =~ /^\S+$/
-          location = {line: @line_number, column: column}
+          location = { line: @line_number, column: column }
           raise ParserException.new('A tag may not contain whitespace', location)
         end
 

data/lib/gherkin/pickles/compiler.rb

@@ -8,10 +8,10 @@ module Gherkin
       def compile(gherkin_document, source)
         pickles = []
 
-        return pickles unless gherkin_document.feature
-        feature = gherkin_document.feature
-        language = feature.language
-        tags = feature.tags
+        return pickles unless gherkin_document[:feature]
+        feature = gherkin_document[:feature]
+        language = feature[:language]
+        tags = feature[:tags]
 
         compile_feature(pickles, language, tags, feature, source)
         pickles
@@ -21,14 +21,14 @@ module Gherkin
 
       def compile_feature(pickles, language, tags, feature, source)
         feature_background_steps = []
-        feature.children.each do |child|
-          if child.background
-            feature_background_steps.concat(child.background.steps)
-          elsif child.rule
-            compile_rule(pickles, language, tags, feature_background_steps, child.rule, source)
+        feature[:children].each do |child|
+          if child[:background]
+            feature_background_steps.concat(child[:background][:steps])
+          elsif child[:rule]
+            compile_rule(pickles, language, tags, feature_background_steps, child[:rule], source)
           else
-            scenario = child.scenario
-            if scenario.examples.empty?
+            scenario = child[:scenario]
+            if scenario[:examples].empty?
               compile_scenario(tags, feature_background_steps, scenario, language, pickles, source)
             else
               compile_scenario_outline(tags, feature_background_steps, scenario, language, pickles, source)
@@ -38,15 +38,15 @@ module Gherkin
       end
 
       def compile_rule(pickles, language, feature_tags, feature_background_steps, rule, source)
-        tags = [].concat(feature_tags).concat(rule.tags)
+        tags = [].concat(feature_tags).concat(rule[:tags])
 
         rule_background_steps = feature_background_steps.dup
-        rule.children.each do |child|
-          if child.background
-            rule_background_steps.concat(child.background.steps)
+        rule[:children].each do |child|
+          if child[:background]
+            rule_background_steps.concat(child[:background][:steps])
           else
-            scenario = child.scenario
-            if scenario.examples.empty?
+            scenario = child[:scenario]
+            if scenario[:examples].empty?
               compile_scenario(tags, rule_background_steps, scenario, language, pickles, source)
             else
               compile_scenario_outline(tags, rule_background_steps, scenario, language, pickles, source)
@@ -56,51 +56,51 @@ module Gherkin
       end
 
       def compile_scenario(inherited_tags, background_steps, scenario, language, pickles, source)
-        steps = scenario.steps.empty? ? [] : [].concat(pickle_steps(background_steps))
+        steps = scenario[:steps].empty? ? [] : [].concat(pickle_steps(background_steps))
 
-        tags = [].concat(inherited_tags).concat(scenario.tags)
+        tags = [].concat(inherited_tags).concat(scenario[:tags])
 
-        scenario.steps.each do |step|
+        scenario[:steps].each do |step|
           steps.push(pickle_step(step))
         end
 
-        pickle = Cucumber::Messages::Pickle.new(
-          uri: source.uri,
+        pickle = {
+          uri: source[:uri],
           id: @id_generator.new_id,
           tags: pickle_tags(tags),
-          name: scenario.name,
+          name: scenario[:name],
           language: language,
-          ast_node_ids: [scenario.id],
+          astNodeIds: [scenario[:id]],
           steps: steps
-        )
+        }
         pickles.push(pickle)
       end
 
       def compile_scenario_outline(inherited_tags, background_steps, scenario, language, pickles, source)
-        scenario.examples.reject { |examples| examples.table_header.nil? }.each do |examples|
-          variable_cells = examples.table_header.cells
-          examples.table_body.each do |values_row|
-            value_cells = values_row.cells
-            steps = scenario.steps.empty? ? [] : [].concat(pickle_steps(background_steps))
-            tags = [].concat(inherited_tags).concat(scenario.tags).concat(examples.tags)
-
-            scenario.steps.each do |scenario_outline_step|
-              step_props = pickle_step_props(scenario_outline_step, variable_cells, values_row)
-              steps.push(Cucumber::Messages::Pickle::PickleStep.new(step_props))
+        scenario[:examples].reject { |examples| examples[:tableHeader].nil? }.each do |examples|
+          variable_cells = examples[:tableHeader][:cells]
+          examples[:tableBody].each do |values_row|
+            value_cells = values_row[:cells]
+            steps = scenario[:steps].empty? ? [] : [].concat(pickle_steps(background_steps))
+            tags = [].concat(inherited_tags).concat(scenario[:tags]).concat(examples[:tags])
+
+            scenario[:steps].each do |scenario_step|
+              step = pickle_step_props(scenario_step, variable_cells, values_row)
+              steps.push(step)
             end
 
-            pickle = Cucumber::Messages::Pickle.new(
-              uri: source.uri,
+            pickle = {
+              uri: source[:uri],
               id: @id_generator.new_id,
-              name: interpolate(scenario.name, variable_cells, value_cells),
+              name: interpolate(scenario[:name], variable_cells, value_cells),
               language: language,
               steps: steps,
               tags: pickle_tags(tags),
-              ast_node_ids: [
-                scenario.id,
-                values_row.id
+              astNodeIds: [
+                scenario[:id],
+                values_row[:id]
               ],
-            )
+            }
             pickles.push(pickle)
 
           end
@@ -110,7 +110,7 @@ module Gherkin
       def interpolate(name, variable_cells, value_cells)
         variable_cells.each_with_index do |variable_cell, n|
           value_cell = value_cells[n]
-          name = name.gsub('<' + variable_cell.value + '>', value_cell.value)
+          name = name.gsub('<' + variable_cell[:value] + '>', value_cell[:value])
         end
         name
       end
@@ -122,57 +122,57 @@ module Gherkin
       end
 
       def pickle_step(step)
-        Cucumber::Messages::Pickle::PickleStep.new(pickle_step_props(step, [], nil))
+        pickle_step_props(step, [], nil)
       end
 
       def pickle_step_props(step, variable_cells, values_row)
-        value_cells = values_row ? values_row.cells : []
+        value_cells = values_row ? values_row[:cells] : []
         props = {
           id: @id_generator.new_id,
-          ast_node_ids: [step.id],
-          text: interpolate(step.text, variable_cells, value_cells),
+          astNodeIds: [step[:id]],
+          text: interpolate(step[:text], variable_cells, value_cells),
         }
         if values_row
-          props[:ast_node_ids].push(values_row.id)
+          props[:astNodeIds].push(values_row[:id])
         end
 
-        if step.data_table
-          data_table = Cucumber::Messages::PickleStepArgument.new(
-            data_table: pickle_data_table(step.data_table, variable_cells, value_cells)
-          )
+        if step[:dataTable]
+          data_table = {
+            dataTable: pickle_data_table(step[:dataTable], variable_cells, value_cells)
+          }
           props[:argument] = data_table
         end
-        if step.doc_string
-          doc_string = Cucumber::Messages::PickleStepArgument.new(
-            doc_string: pickle_doc_string(step.doc_string, variable_cells, value_cells)
-          )
+        if step[:docString]
+          doc_string = {
+            docString: pickle_doc_string(step[:docString], variable_cells, value_cells)
+          }
           props[:argument] = doc_string
         end
         props
       end
 
       def pickle_data_table(data_table, variable_cells, value_cells)
-        Cucumber::Messages::PickleStepArgument::PickleTable.new(
-          rows: data_table.rows.map do |row|
-            Cucumber::Messages::PickleStepArgument::PickleTable::PickleTableRow.new(
-              cells: row.cells.map do |cell|
-                Cucumber::Messages::PickleStepArgument::PickleTable::PickleTableRow::PickleTableCell.new(
-                  value: interpolate(cell.value, variable_cells, value_cells)
-                )
+        {
+          rows: data_table[:rows].map do |row|
+            {
+              cells: row[:cells].map do |cell|
+                {
+                  value: interpolate(cell[:value], variable_cells, value_cells)
+                }
               end
-            )
+            }
           end
-        )
+        }
       end
 
       def pickle_doc_string(doc_string, variable_cells, value_cells)
         props = {
-          content: interpolate(doc_string.content, variable_cells, value_cells)
+          content: interpolate(doc_string[:content], variable_cells, value_cells)
         }
-        if doc_string.media_type
-          props[:media_type] = interpolate(doc_string.media_type, variable_cells, value_cells)
+        if doc_string[:mediaType]
+          props[:mediaType] = interpolate(doc_string[:mediaType], variable_cells, value_cells)
         end
-        Cucumber::Messages::PickleStepArgument::PickleDocString.new(props)
+        props
       end
 
       def pickle_tags(tags)
@@ -180,10 +180,10 @@ module Gherkin
       end
 
       def pickle_tag(tag)
-        Cucumber::Messages::Pickle::PickleTag.new(
-          name: tag.name,
-          ast_node_id: tag.id
-        )
+        {
+          name: tag[:name],
+          astNodeId: tag[:id]
+        }
       end
     end
   end

data/lib/gherkin/query.rb

@@ -5,7 +5,7 @@ module Gherkin
     end
 
     def update(message)
-      update_feature(message.gherkin_document.feature) if message.gherkin_document
+      update_feature(message[:gherkinDocument][:feature]) if message[:gherkinDocument]
     end
 
     def location(ast_node_id)
@@ -17,33 +17,33 @@ module Gherkin
 
     def update_feature(feature)
       return if feature.nil?
-      store_nodes_location(feature.tags)
+      store_nodes_location(feature[:tags])
 
-      feature.children.each do |child|
-        update_rule(child.rule) if child.rule
-        update_background(child.background) if child.background
-        update_scenario(child.scenario) if child.scenario
+      feature[:children].each do |child|
+        update_rule(child[:rule]) if child[:rule]
+        update_background(child[:background]) if child[:background]
+        update_scenario(child[:scenario]) if child[:scenario]
       end
     end
 
     def update_rule(rule)
-      rule.children.each do |child|
-        update_background(child.background) if child.background
-        update_scenario(child.scenario) if child.scenario
+      rule[:children].each do |child|
+        update_background(child[:background]) if child[:background]
+        update_scenario(child[:scenario]) if child[:scenario]
       end
     end
 
     def update_background(background)
-      update_steps(background.steps)
+      update_steps(background[:steps])
     end
 
     def update_scenario(scenario)
       store_node_location(scenario)
-      store_nodes_location(scenario.tags)
-      update_steps(scenario.steps)
-      scenario.examples.each do |examples|
-        store_nodes_location(examples.tags)
-        store_nodes_location(examples.table_body)
+      store_nodes_location(scenario[:tags])
+      update_steps(scenario[:steps])
+      scenario[:examples].each do |examples|
+        store_nodes_location(examples[:tags] || [])
+        store_nodes_location(examples[:tableBody] || [])
       end
     end
 
@@ -56,7 +56,7 @@ module Gherkin
     end
 
     def store_node_location(node)
-      @ast_node_locations[node.id] = node.location
+      @ast_node_locations[node[:id]] = node[:location]
     end
   end
 end

data/lib/gherkin/stream/parser_message_stream.rb

@@ -23,25 +23,25 @@ module Gherkin
           enumerated = true
 
           sources.each do |source|
-            y.yield(Cucumber::Messages::Envelope.new(source: source)) if @options[:include_source]
+            y.yield({source: source}) if @options[:include_source]
             begin
               gherkin_document = nil
 
               if @options[:include_gherkin_document]
                 gherkin_document = build_gherkin_document(source)
-                y.yield(Cucumber::Messages::Envelope.new(gherkin_document: gherkin_document))
+                y.yield({gherkinDocument: gherkin_document})
               end
               if @options[:include_pickles]
                 gherkin_document ||= build_gherkin_document(source)
                 pickles = @compiler.compile(gherkin_document, source)
                 pickles.each do |pickle|
-                  y.yield(Cucumber::Messages::Envelope.new(pickle: pickle))
+                  y.yield({pickle: pickle})
                 end
               end
             rescue CompositeParserException => err
-              yield_parse_errors(y, err.errors, source.uri)
+              yield_parse_errors(y, err.errors, source[:uri])
             rescue ParserException => err
-              yield_parse_errors(y, [err], source.uri)
+              yield_parse_errors(y, [err], source[:uri])
             end
           end
         end
@@ -51,28 +51,28 @@ module Gherkin
 
       def yield_parse_errors(y, errors, uri)
         errors.each do |err|
-          parse_error = Cucumber::Messages::ParseError.new(
-            source: Cucumber::Messages::SourceReference.new(
+          parse_error = {
+            source: {
               uri: uri,
-              location: Cucumber::Messages::Location.new(
+              location: {
                 line: err.location[:line],
                 column: err.location[:column]
-              )
-            ),
+              }.delete_if {|k,v| v.nil?}
+            },
             message: err.message
-          )
-          y.yield(Cucumber::Messages::Envelope.new(parse_error: parse_error))
+          }
+          y.yield({parseError: parse_error})
         end
       end
 
       def sources
         Enumerator.new do |y|
           @paths.each do |path|
-            source = Cucumber::Messages::Source.new(
+            source = {
               uri: path,
               data: File.open(path, 'r:UTF-8', &:read),
-              media_type: 'text/x.cucumber.gherkin+plain'
-            )
+              mediaType: 'text/x.cucumber.gherkin+plain'
+            }
             y.yield(source)
           end
           @sources.each do |source|
@@ -84,12 +84,12 @@ module Gherkin
       def build_gherkin_document(source)
         if @options[:default_dialect]
           token_matcher = TokenMatcher.new(@options[:default_dialect])
-          gd = @parser.parse(source.data, token_matcher)
+          gd = @parser.parse(source[:data], token_matcher)
         else
-          gd = @parser.parse(source.data)
+          gd = @parser.parse(source[:data])
         end
-        gd[:uri] = source.uri
-        Cucumber::Messages::GherkinDocument.new(gd)
+        gd[:uri] = source[:uri]
+        gd
       end
     end
   end

data/lib/gherkin/token_scanner.rb

@@ -25,7 +25,7 @@ module Gherkin
     end
 
     def read
-      location = {line: @line_number += 1, column: 0}
+      location = {line: @line_number += 1}
       if @io.nil? || line = @io.gets
         gherkin_line = line ? GherkinLine.new(line, location[:line]) : nil
         Token.new(gherkin_line, location)

data/spec/gherkin/query_spec.rb

@@ -3,20 +3,17 @@ require 'gherkin'
 require 'gherkin/query'
 
 describe Gherkin::Query do
-  let(:subject) { Gherkin::Query.new() }
+  let(:subject) { Gherkin::Query.new }
 
   def filter_messages_by_attribute(messages, attribute)
-    messages.map do |message|
-      return unless message.respond_to?(attribute)
-      message.send(attribute)
-    end.compact
+    messages.select { |message| message.has_key?(attribute) }.map { |message| message[attribute] }
   end
 
   def find_message_by_attribute(messages, attribute)
     filter_messages_by_attribute(messages, attribute).first
   end
 
-  let(:gherkin_document) { find_message_by_attribute(messages, :gherkin_document) }
+  let(:gherkin_document) { find_message_by_attribute(messages, :gherkinDocument) }
 
   let(:messages) {
     Gherkin.from_source(
@@ -80,8 +77,8 @@ describe Gherkin::Query do
       }
     end
 
-    let(:background) { find_message_by_attribute(gherkin_document.feature.children, :background) }
-    let(:scenarios) { filter_messages_by_attribute(gherkin_document.feature.children, :scenario) }
+    let(:background) { find_message_by_attribute(gherkin_document[:feature][:children], :background) }
+    let(:scenarios) { filter_messages_by_attribute(gherkin_document[:feature][:children], :scenario) }
     let(:scenario) { scenarios.first }
 
     it 'raises an exception when the AST node ID is unknown' do
@@ -89,68 +86,68 @@ describe Gherkin::Query do
     end
 
     it 'provides the location of a scenario' do
-      expect(subject.location(scenario.id)).to eq(scenario.location)
+      expect(subject.location(scenario[:id])).to eq(scenario[:location])
     end
 
     it 'provides the location of an examples table row' do
-      node = scenarios.last.examples.first.table_body.first
-      expect(subject.location(node.id)).to eq(node.location)
+      node = scenarios.last[:examples].first[:tableBody].first
+      expect(subject.location(node[:id])).to eq(node[:location])
     end
 
     context 'when querying steps' do
-      let(:background_step) { background.steps.first }
-      let(:scenario_step) { scenario.steps.first }
+      let(:background_step) { background[:steps].first }
+      let(:scenario_step) { scenario[:steps].first }
 
       it 'provides the location of a background step' do
-        expect(subject.location(background_step.id)).to eq(background_step.location)
+        expect(subject.location(background_step[:id])).to eq(background_step[:location])
       end
 
       it 'provides the location of a scenario step' do
-        expect(subject.location(scenario_step.id)).to eq(scenario_step.location)
+        expect(subject.location(scenario_step[:id])).to eq(scenario_step[:location])
       end
     end
 
     context 'when querying tags' do
-      let(:feature_tag) { gherkin_document.feature.tags.first }
-      let(:scenario_tag) { scenario.tags.first }
-      let(:example_tag) { scenarios.last.examples.first.tags.first }
+      let(:feature_tag) { gherkin_document[:feature][:tags].first }
+      let(:scenario_tag) { scenario[:tags].first }
+      let(:example_tag) { scenarios.last[:examples].first[:tags].first }
 
       it 'provides the location of a feature tags' do
-        expect(subject.location(feature_tag.id)).to eq(feature_tag.location)
+        expect(subject.location(feature_tag[:id])).to eq(feature_tag[:location])
       end
 
       it 'provides the location of a scenario tags' do
-        expect(subject.location(scenario_tag.id)).to eq(scenario_tag.location)
+        expect(subject.location(scenario_tag[:id])).to eq(scenario_tag[:location])
       end
 
       it 'provides the location of a scenario example tags' do
-        expect(subject.location(example_tag.id)).to eq(example_tag.location)
+        expect(subject.location(example_tag[:id])).to eq(example_tag[:location])
       end
     end
 
     context 'when children are scoped in a Rule' do
-      let(:rule) { find_message_by_attribute(gherkin_document.feature.children, :rule) }
-      let(:rule_background) { find_message_by_attribute(rule.children, :background) }
-      let(:rule_background_step) { rule_background.steps.first }
-      let(:rule_scenario) { find_message_by_attribute(rule.children, :scenario) }
-      let(:rule_scenario_step) { rule_scenario.steps.first }
-      let(:rule_scenario_tag) { rule_scenario.tags.first }
+      let(:rule) { find_message_by_attribute(gherkin_document[:feature][:children], :rule) }
+      let(:rule_background) { find_message_by_attribute(rule[:children], :background) }
+      let(:rule_background_step) { rule_background[:steps].first }
+      let(:rule_scenario) { find_message_by_attribute(rule[:children], :scenario) }
+      let(:rule_scenario_step) { rule_scenario[:steps].first }
+      let(:rule_scenario_tag) { rule_scenario[:tags].first }
 
       it 'provides the location of a background step' do
-        expect(subject.location(rule_background_step.id)).to eq(rule_background_step.location)
+        expect(subject.location(rule_background_step[:id])).to eq(rule_background_step[:location])
       end
 
       it 'provides the location of a scenario' do
-        expect(subject.location(rule_scenario.id)).to eq(rule_scenario.location)
+        expect(subject.location(rule_scenario[:id])).to eq(rule_scenario[:location])
       end
 
       it 'provides the location of a scenario tag' do
-        expect(subject.location(rule_scenario_tag.id)).to eq(rule_scenario_tag.location)
+        expect(subject.location(rule_scenario_tag[:id])).to eq(rule_scenario_tag[:location])
       end
 
       it 'provides the location of a scenario step' do
-        expect(subject.location(rule_scenario_step.id)).to eq(rule_scenario_step.location)
+        expect(subject.location(rule_scenario_step[:id])).to eq(rule_scenario_step[:location])
       end
     end
   end
-end
+end

data/spec/gherkin/stream/parser_message_stream_spec.rb

@@ -11,11 +11,11 @@ module Gherkin
       }
 
       let(:source_feature) {
-        Cucumber::Messages::Source.new({
+        {
           uri: '//whatever/uri',
           data: feature_content,
-          media_type: 'text/x.cucumber.gherkin+plain'
-        })
+          mediaType: 'text/x.cucumber.gherkin+plain'
+        }
       }
 
       let(:options) {
@@ -25,10 +25,10 @@ module Gherkin
       }
 
       let(:gherkin_document) {
-        ParserMessageStream.new([], [source_feature], options).messages.first.gherkin_document
+        ParserMessageStream.new([], [source_feature], options).messages.first[:gherkinDocument]
       }
 
-      let(:scenario_id) { gherkin_document.feature.children.first.scenario.id }
+      let(:scenario_id) { gherkin_document[:feature][:children].first[:scenario][:id] }
 
       context '#messages' do
         it "raises an exception on second iteration" do
@@ -64,4 +64,4 @@ module Gherkin
       end
     end
   end
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cucumber-gherkin
 version: !ruby/object:Gem::Version
-  version: 18.1.1
+  version: 19.0.0
 platform: ruby
 authors:
 - Gáspár Nagy
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-04-22 00:00:00.000000000 Z
+date: 2021-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cucumber-messages
@@ -18,20 +18,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '15.0'
+        version: '16.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 15.0.0
+        version: 16.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '15.0'
+        version: '16.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 15.0.0
+        version: 16.0.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -95,7 +95,6 @@ files:
 - lib/gherkin/pickles/compiler.rb
 - lib/gherkin/query.rb
 - lib/gherkin/stream/parser_message_stream.rb
-- lib/gherkin/stream/subprocess_message_stream.rb
 - lib/gherkin/token.rb
 - lib/gherkin/token_formatter_builder.rb
 - lib/gherkin/token_matcher.rb
@@ -107,7 +106,6 @@ files:
 - spec/gherkin/parser_spec.rb
 - spec/gherkin/query_spec.rb
 - spec/gherkin/stream/parser_message_stream_spec.rb
-- spec/gherkin/stream/subprocess_message_stream_spec.rb
 homepage: https://github.com/cucumber/gherkin-ruby
 licenses:
 - MIT
@@ -136,13 +134,12 @@ requirements: []
 rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
-summary: cucumber-gherkin-18.1.1
+summary: cucumber-gherkin-19.0.0
 test_files:
 - spec/capture_warnings.rb
-- spec/gherkin/gherkin_line_spec.rb
 - spec/gherkin/dialect_spec.rb
+- spec/gherkin/gherkin_line_spec.rb
+- spec/gherkin/gherkin_spec.rb
 - spec/gherkin/parser_spec.rb
-- spec/gherkin/stream/parser_message_stream_spec.rb
-- spec/gherkin/stream/subprocess_message_stream_spec.rb
 - spec/gherkin/query_spec.rb
-- spec/gherkin/gherkin_spec.rb
+- spec/gherkin/stream/parser_message_stream_spec.rb

data/lib/gherkin/stream/subprocess_message_stream.rb

@@ -1,26 +0,0 @@
-require 'open3'
-require 'cucumber/messages'
-
-module Gherkin
-  module Stream
-    class SubprocessMessageStream
-      def initialize(gherkin_executable, paths, print_source, print_ast, print_pickles)
-        @gherkin_executable, @paths, @print_source, @print_ast, @print_pickles = gherkin_executable, paths, print_source, print_ast, print_pickles
-      end
-
-      def messages
-        args = [@gherkin_executable]
-        args.push('--no-source') unless @print_source
-        args.push('--no-ast') unless @print_ast
-        args.push('--no-pickles') unless @print_pickles
-        args = args.concat(@paths)
-        stdin, stdout, stderr, wait_thr = Open3.popen3(*args)
-        if(stdout.eof?)
-          error = stderr.read
-          raise error
-        end
-        Cucumber::Messages::BinaryToMessageEnumerator.new(stdout)
-      end
-    end
-  end
-end

data/spec/gherkin/stream/subprocess_message_stream_spec.rb

@@ -1,18 +0,0 @@
-require 'rspec'
-require 'gherkin/stream/subprocess_message_stream'
-
-module Gherkin
-  module Stream
-    describe SubprocessMessageStream do
-      it "works" do
-        cucumber_messages = SubprocessMessageStream.new(
-          "./bin/gherkin",
-          ["testdata/good/minimal.feature"],
-          true, true, true
-        )
-        messages = cucumber_messages.messages.to_a
-        expect(messages.length).to eq(3)
-      end
-    end
-  end
-end