cucumber-gherkin 17.0.1 → 19.0.0

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)
@@ -37,14 +37,16 @@ module Gherkin
         end
       end
 
-      def compile_rule(pickles, language, tags, feature_background_steps, rule, source)
+      def compile_rule(pickles, language, feature_tags, feature_background_steps, rule, source)
+        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)
@@ -53,52 +55,52 @@ module Gherkin
         end
       end
 
-      def compile_scenario(feature_tags, background_steps, scenario, language, pickles, source)
-        steps = scenario.steps.empty? ? [] : [].concat(pickle_steps(background_steps))
+      def compile_scenario(inherited_tags, background_steps, scenario, language, pickles, source)
+        steps = scenario[:steps].empty? ? [] : [].concat(pickle_steps(background_steps))
 
-        tags = [].concat(feature_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(feature_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(feature_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))
+      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)
             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
@@ -108,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
@@ -120,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)
@@ -178,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/gherkin_line_spec.rb

@@ -2,7 +2,17 @@ require 'rspec'
 require 'gherkin/gherkin_line'
 
 describe Gherkin::GherkinLine do
-  context '#table_cell' do
+  context '#tags' do
+    def tags(line)
+      Gherkin::GherkinLine.new(line, 12).tags.map(&:text)
+    end
+
+    it 'allows any non-space characters in a tag' do
+      expect(tags("   @foo:bar  @zap🥒yo")).to eq(['@foo:bar', '@zap🥒yo'])
+    end
+  end
+
+  context '#table_cells' do
     def cells_text(line)
       Gherkin::GherkinLine.new(line, 12).table_cells.map(&:text)
     end

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