cucumber-gherkin 19.0.3 → 20.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1434d3799777dd48f76c2da9aa87c2fc368ba0de7a0e91a6beaf3f67b35f5b49
-  data.tar.gz: 95693b179a0f88d682d9702aaabda60c034c8357e1ffbf0f7f0774735989eed6
+  metadata.gz: ad9f2d6bb3c1594a8a5d18f8da1bdd37c4e19398f96786332291710beae19124
+  data.tar.gz: 983b5a2d737845653dcec99d6e9f7c3c055c592de4f120c118d31db375fd30ab
 SHA512:
-  metadata.gz: 778fa521711be7b29cf0f104e39fb0f82dfbfa8e770c625e701180cd261ca60d777ca16bf652bcb2353db9b2b981dc88386a70a43daf3204d6b144348e638e0d
-  data.tar.gz: 73964905ed87feb8772807819aceefb6046b58d883f31ce55d8605b08e98186cc7f1e59b28c5811938017ac5b92b504d3f0d3ef03f8a5fed21213f92b90b9139
+  metadata.gz: c2d52892a66d0bd8bdf409c8024c07dd0761ad4451501379113ff30845b4a66258611ea14e7dd8f087daede5a10ecf42214bc4e55ed6b484096f52fb7258fbaa
+  data.tar.gz: 460f947e61b2401924bb6899fd08a4b35205432e6b3eb312037a17ffa249d98effc30e10b686d63c15676b74c265351ed4451f4df0dbff5bce6a0be5efe8a246

data/bin/gherkin

@@ -31,7 +31,7 @@ end.parse!
 
 def process_messages(messages, options)
   messages.each do |message|
-    STDOUT.write(JSON.fast_generate(message))
+    STDOUT.write(message.to_json)
     STDOUT.write("\n")
   end
 end

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,
-      mediaType: 'text/x.cucumber.gherkin+plain'
-    }
+      media_type: '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({
+        @comments.push(Cucumber::Messages::Comment.new(
           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({
+          tags.push(Cucumber::Messages::Tag.new(
             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::TableRow.new(
           id: @id_generator.new_id,
           location: get_location(token, 0),
           cells: get_cells(token)
-        }
+        )
       end
       ensure_cell_count(rows)
       rows
@@ -81,20 +81,20 @@ 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
-          raise AstBuilderException.new("inconsistent cell count within the table", row[:location])
+        if row.cells.length != cell_count
+          raise AstBuilderException.new("inconsistent cell count within the table", row.location.to_h)
         end
       end
     end
 
     def get_cells(table_row_token)
       table_row_token.matched_items.map do |cell_item|
-        {
+        Cucumber::Messages::TableCell.new(
           location: get_location(table_row_token, cell_item.column),
           value: cell_item.text
-        }
+        )
       end
     end
 
@@ -113,45 +113,45 @@ module Gherkin
         data_table = node.get_single(:DataTable)
         doc_string = node.get_single(:DocString)
 
-        step = {
+        step = Cucumber::Messages::Step.new(
           location: get_location(step_line, 0),
           keyword: step_line.matched_keyword,
           text: step_line.matched_text,
-          dataTable: data_table,
-          docString: doc_string,
+          data_table: data_table,
+          doc_string: 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::DocString.new(
           location: get_location(separator_token, 0),
           content: content,
           delimiter: separator_token.matched_keyword,
-          mediaType: media_type,
-        }.delete_if {|k,v| v.nil?}
+          media_type: media_type
+        )
       when :DataTable
         rows = get_table_rows(node)
-        {
-          location: rows[0][:location],
-          rows: rows,
-        }.delete_if {|k,v| v.nil?}
+        Cucumber::Messages::DataTable.new(
+          location: rows[0].location,
+          rows: rows
+        )
       when :Background
         background_line = node.get_token(:BackgroundLine)
         description = get_description(node)
         steps = get_steps(node)
 
-        {
+        Cucumber::Messages::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)
@@ -159,7 +159,7 @@ module Gherkin
         description = get_description(scenario_node)
         steps = get_steps(scenario_node)
         examples = scenario_node.get_items(:ExamplesDefinition)
-        {
+        Cucumber::Messages::Scenario.new(
           id: @id_generator.new_id,
           tags: tags,
           location: get_location(scenario_line, 0),
@@ -168,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)
@@ -179,16 +179,16 @@ module Gherkin
         table_header = rows.nil? ? nil : rows.first
         table_body = rows.nil? ? [] : rows[1..-1]
 
-        {
+        Cucumber::Messages::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,
-          tableHeader: table_header,
-          tableBody: table_body,
-        }.delete_if {|k,v| v.nil?}
+          table_header: table_header,
+          table_body: table_body
+        )
       when :ExamplesTable
         get_table_rows(node)
       when :Description
@@ -205,17 +205,17 @@ module Gherkin
         return unless feature_line
         children = []
         background = node.get_single(:Background)
-        children.push({background: background}) if background
+        children.push(Cucumber::Messages::FeatureChild.new(background: background)) if background
         node.get_items(:ScenarioDefinition).each do |scenario|
-          children.push({scenario: scenario})
+          children.push(Cucumber::Messages::FeatureChild.new(scenario: scenario))
         end
         node.get_items(:Rule).each do |rule|
-          children.push({rule: rule})
+          children.push(Cucumber::Messages::FeatureChild.new(rule: rule))
         end
         description = get_description(header)
         language = feature_line.matched_gherkin_dialect
 
-        {
+        Cucumber::Messages::Feature.new(
           tags: tags,
           location: get_location(feature_line, 0),
           language: language,
@@ -223,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
@@ -232,13 +232,13 @@ module Gherkin
         tags = get_tags(header)
         children = []
         background = node.get_single(:Background)
-        children.push({background: background}) if background
+        children.push(Cucumber::Messages::RuleChild.new(background: background)) if background
         node.get_items(:ScenarioDefinition).each do |scenario|
-          children.push({scenario: scenario})
+          children.push(Cucumber::Messages::RuleChild.new(scenario: scenario))
         end
         description = get_description(header)
 
-        {
+        Cucumber::Messages::Rule.new(
           id: @id_generator.new_id,
           tags: tags,
           location: get_location(rule_line, 0),
@@ -246,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)
-        {
+        Cucumber::Messages::GherkinDocument.new(
           comments: @comments,
           feature: feature
-        }.delete_if {|k,v| v.nil?}
+        )
       else
         return node
       end

data/lib/gherkin/gherkin-languages.json

@@ -1013,6 +1013,46 @@
       "* ",
       "Blimey! "
     ]
+  },
+    "en-tx": {
+    "and": [
+      "Come hell or high water "
+    ],
+    "background": [
+      "Lemme tell y'all a story"
+    ],
+    "but": [
+      "Well now hold on, I'll you what "
+    ],
+    "examples": [
+      "Now that's a story longer than a cattle drive in July"
+    ],
+    "feature": [
+      "This ain’t my first rodeo",
+      "All gussied up"
+    ],
+    "given": [
+      "Fixin' to ",
+      "All git out "
+    ],
+    "name": "Texas",
+    "native": "Texas",
+    "rule": [
+      "Rule "
+    ],
+    "scenario": [
+      "All hat and no cattle"
+    ],
+    "scenarioOutline": [
+      "Serious as a snake bite",
+      "Busy as a hound in flea season"
+    ],
+    "then": [
+      "There’s no tree but bears some fruit "
+    ],
+    "when": [
+      "Quick out of the chute "
+    ]
   },
   "eo": {
     "and": [
@@ -2566,7 +2606,8 @@
     "name": "Polish",
     "native": "polski",
     "rule": [
-      "Rule"
+      "Zasada",
+      "Reguła"
     ],
     "scenario": [
       "Przykład",

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 = {
-          uri: source[:uri],
+        pickle = Cucumber::Messages::Pickle.new(
+          uri: source.uri,
           id: @id_generator.new_id,
           tags: pickle_tags(tags),
-          name: scenario[:name],
+          name: scenario.name,
           language: language,
-          astNodeIds: [scenario[:id]],
+          ast_node_ids: [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[: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)
+        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_step|
+              step_props = pickle_step_props(scenario_step, variable_cells, values_row)
+              steps.push(Cucumber::Messages::PickleStep.new(**step_props))
             end
 
-            pickle = {
-              uri: source[:uri],
+            pickle = Cucumber::Messages::Pickle.new(
+              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),
-              astNodeIds: [
-                scenario[:id],
-                values_row[:id]
-              ],
-            }
+              ast_node_ids: [
+                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)
-        pickle_step_props(step, [], nil)
+        Cucumber::Messages::PickleStep.new(**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,
-          astNodeIds: [step[:id]],
-          text: interpolate(step[:text], variable_cells, value_cells),
+          ast_node_ids: [step.id],
+          text: interpolate(step.text, variable_cells, value_cells),
         }
         if values_row
-          props[:astNodeIds].push(values_row[:id])
+          props[:ast_node_ids].push(values_row.id)
         end
 
-        if step[:dataTable]
-          data_table = {
-            dataTable: pickle_data_table(step[:dataTable], variable_cells, value_cells)
-          }
+        if step.data_table
+          data_table = Cucumber::Messages::PickleStepArgument.new(
+            data_table: pickle_data_table(step.data_table, variable_cells, value_cells)
+          )
           props[:argument] = data_table
         end
-        if step[:docString]
-          doc_string = {
-            docString: pickle_doc_string(step[:docString], variable_cells, value_cells)
-          }
+        if step.doc_string
+          doc_string = Cucumber::Messages::PickleStepArgument.new(
+            doc_string: pickle_doc_string(step.doc_string, variable_cells, value_cells)
+          )
           props[:argument] = doc_string
         end
         props
       end
 
       def pickle_data_table(data_table, 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)
-                }
+        Cucumber::Messages::PickleTable.new(
+          rows: data_table.rows.map do |row|
+            Cucumber::Messages::PickleTableRow.new(
+              cells: row.cells.map do |cell|
+                Cucumber::Messages::PickleTableCell.new(
+                  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[:mediaType]
-          props[:mediaType] = interpolate(doc_string[:mediaType], variable_cells, value_cells)
+        if doc_string.media_type
+          props[:media_type] = interpolate(doc_string.media_type, variable_cells, value_cells)
         end
-        props
+        Cucumber::Messages::PickleDocString.new(**props)
       end
 
       def pickle_tags(tags)
@@ -180,10 +180,10 @@ module Gherkin
       end
 
       def pickle_tag(tag)
-        {
-          name: tag[:name],
-          astNodeId: tag[:id]
-        }
+        Cucumber::Messages::PickleTag.new(
+          name: tag.name,
+          ast_node_id: tag.id
+        )
       end
     end
   end

data/lib/gherkin/query.rb

@@ -5,7 +5,7 @@ module Gherkin
     end
 
     def update(message)
-      update_feature(message[:gherkinDocument][:feature]) if message[:gherkinDocument]
+      update_feature(message.gherkin_document.feature) if message.gherkin_document
     end
 
     def location(ast_node_id)
@@ -17,33 +17,36 @@ 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]
+      return if rule.nil?
+      store_nodes_location(rule.tags)
+
+      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[:tableBody] || [])
+      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 || [])
       end
     end
 
@@ -56,7 +59,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({source: source}) if @options[:include_source]
+            y.yield(Cucumber::Messages::Envelope.new(source: source)) if @options[:include_source]
             begin
               gherkin_document = nil
 
               if @options[:include_gherkin_document]
                 gherkin_document = build_gherkin_document(source)
-                y.yield({gherkinDocument: gherkin_document})
+                y.yield(Cucumber::Messages::Envelope.new(gherkin_document: 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({pickle: pickle})
+                  y.yield(Cucumber::Messages::Envelope.new(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 = {
-            source: {
+          parse_error = Cucumber::Messages::ParseError.new(
+            source: Cucumber::Messages::SourceReference.new(
               uri: uri,
-              location: {
+              location: Cucumber::Messages::Location.new(
                 line: err.location[:line],
                 column: err.location[:column]
-              }.delete_if {|k,v| v.nil?}
-            },
+              )
+            ),
             message: err.message
-          }
-          y.yield({parseError: parse_error})
+          )
+          y.yield(Cucumber::Messages::Envelope.new(parse_error: parse_error))
         end
       end
 
       def sources
         Enumerator.new do |y|
           @paths.each do |path|
-            source = {
+            source = Cucumber::Messages::Source.new(
               uri: path,
               data: File.open(path, 'r:UTF-8', &:read),
-              mediaType: 'text/x.cucumber.gherkin+plain'
-            }
+              media_type: 'text/x.cucumber.gherkin+plain'
+            )
             y.yield(source)
           end
           @sources.each do |source|
@@ -84,12 +84,15 @@ 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]
-        gd
+        Cucumber::Messages::GherkinDocument.new(
+          uri: source.uri,
+          feature: gd.feature,
+          comments: gd.comments
+        )
       end
     end
   end

data/spec/gherkin/query_spec.rb

@@ -6,16 +6,19 @@ describe Gherkin::Query do
   let(:subject) { Gherkin::Query.new }
 
   def filter_messages_by_attribute(messages, attribute)
-    messages.select { |message| message.has_key?(attribute) }.map { |message| message[attribute] }
+    messages.map do |message|
+      return unless message.respond_to?(attribute)
+      message.send(attribute)
+    end.compact
   end
 
   def find_message_by_attribute(messages, attribute)
     filter_messages_by_attribute(messages, attribute).first
   end
 
-  let(:gherkin_document) { find_message_by_attribute(messages, :gherkinDocument) }
+  let(:gherkin_document) { find_message_by_attribute(messages, :gherkin_document) }
 
-  let(:messages) {
+  let(:messages) do
     Gherkin.from_source(
       "some/path",
       feature_content,
@@ -23,9 +26,9 @@ describe Gherkin::Query do
         include_gherkin_document: true
       }
     ).to_a
-  }
+  end
 
-  let(:feature_content) {
+  let(:feature_content) do
     """
     @feature-tag
     Feature: my feature
@@ -40,12 +43,12 @@ describe Gherkin::Query do
       Scenario Outline: with examples
         Given a <Status> step
 
-        @example-tag
+        @examples-tag
         Examples:
           | Status |
           | passed |
 
-
+      @rule-tag
       Rule: this is a rule
         Background:
           Given the passed step in the rule background
@@ -53,32 +56,29 @@ describe Gherkin::Query do
         @ruled-scenario-tag
         Scenario: a ruled scenario
           Given a step in the ruled scenario
-      """
-  }
+    """
+  end
 
-  context '#update' do
+  describe '#update' do
     context 'when the feature file is empty' do
       let(:feature_content) { '' }
 
       it 'does not fail' do
-        expect {
-          messages.each { |message|
-            subject.update(message)
-          }
-        }.not_to raise_exception
+        expect do
+          messages.each { |message| subject.update(message) }
+        end.not_to raise_exception
       end
     end
   end
 
-  context '#location' do
+  describe '#location' do
     before do
-      messages.each { |message|
-        subject.update(message)
-      }
+      messages.each { |message| subject.update(message) }
     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(:rule) { find_message_by_attribute(gherkin_document.feature.children, :rule) }
+    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
@@ -86,67 +86,71 @@ 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[:tableBody].first
-      expect(subject.location(node[:id])).to eq(node[:location])
+      node = scenarios.last.examples.first.table_body.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(:rule_tag) { rule.tags.first }
+      let(:scenario_tag) { scenario.tags.first }
+      let(:examples_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 scenario examples tags' do
+        expect(subject.location(examples_tag.id)).to eq(examples_tag.location)
       end
 
-      it 'provides the location of a scenario example tags' do
-        expect(subject.location(example_tag[:id])).to eq(example_tag[:location])
+      it 'provides the location of a rule tag' do
+        expect(subject.location(rule_tag.id)).to eq(rule_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_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

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,
-          mediaType: 'text/x.cucumber.gherkin+plain'
-        }
+          media_type: 'text/x.cucumber.gherkin+plain'
+        )
       }
 
       let(:options) {
@@ -25,10 +25,10 @@ module Gherkin
       }
 
       let(:gherkin_document) {
-        ParserMessageStream.new([], [source_feature], options).messages.first[:gherkinDocument]
+        ParserMessageStream.new([], [source_feature], options).messages.first.gherkin_document
       }
 
-      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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cucumber-gherkin
 version: !ruby/object:Gem::Version
-  version: 19.0.3
+  version: 20.0.0
 platform: ruby
 authors:
 - Gáspár Nagy
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-05-24 00:00:00.000000000 Z
+date: 2021-07-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cucumber-messages
@@ -18,20 +18,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '16.0'
+        version: '17.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 16.0.1
+        version: 17.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '16.0'
+        version: '17.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 16.0.1
+        version: 17.0.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -41,7 +41,7 @@ dependencies:
         version: '13.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 13.0.3
+        version: 13.0.5
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -51,7 +51,7 @@ dependencies:
         version: '13.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 13.0.3
+        version: 13.0.5
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -134,12 +134,12 @@ requirements: []
 rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
-summary: cucumber-gherkin-19.0.3
+summary: cucumber-gherkin-20.0.0
 test_files:
 - spec/capture_warnings.rb
-- spec/gherkin/dialect_spec.rb
 - spec/gherkin/gherkin_line_spec.rb
-- spec/gherkin/gherkin_spec.rb
+- spec/gherkin/dialect_spec.rb
 - spec/gherkin/parser_spec.rb
-- spec/gherkin/query_spec.rb
 - spec/gherkin/stream/parser_message_stream_spec.rb
+- spec/gherkin/query_spec.rb
+- spec/gherkin/gherkin_spec.rb