gherkin 7.0.4 → 8.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e4b01f45decc72c0d17d4c1ea68c653671414abfb36c887140ef8a060bc4f277
-  data.tar.gz: dee6817d1308ddab1bb14fda79e730c27eaf09130646f3e7947a51943f9d043a
+  metadata.gz: 03d427e820bf0e7c744cbe67f7f9173ade3a528dd7a3f02c94ef6b261d54fe7b
+  data.tar.gz: 01d2c0fca9b02b4a0c6c480ab47c10178210814c86e7dd6f4ffcdde9540dcfda
 SHA512:
-  metadata.gz: 1dba2967b674ce4ad491da5cb289ece8e2c59d1a30988b3d9664aa378e2e1c69981c600eb6edc7561ef3dbe20ae74de8b656b9eaefeadc994ee1cc4ae5fc44d4
-  data.tar.gz: 633ea2dc1e7459abd5aab2d0271c072c4788f6e59628b0e1a4c175375de3cdf818a898d5e6b2d41422af27020794794a81d081324c582dbdcc9edc39439f88b7
+  metadata.gz: c638788e4c6926086d5271cf414665d3fdaebf464643283238ca6f86cb000d1650c69017c5bc11260c2770a093b0c9538ab2ab0df73e44b2d9ef1c7e4f208475
+  data.tar.gz: 4960487bbdde80f6d74df8e81fd4d3983a1fe2c998ea5d9842cfc8db9ab4607cf0c4909f5c89a2b1f19a0e8614eaabd0b673ed27d79488651da1caf51606cecb

data/bin/gherkin

@@ -4,12 +4,16 @@ $LOAD_PATH.unshift(File.join(File.dirname(__FILE__),"../lib"))
 
 require 'optparse'
 require 'json'
-require 'gherkin/gherkin'
+require 'cucumber/messages'
+require 'gherkin'
+require 'gherkin/stream/subprocess_message_stream'
+require 'gherkin/stream/protobuf_message_stream'
 
 options = {
   include_source: true,
   include_gherkin_document: true,
-  include_pickles: true
+  include_pickles: true,
+  json: false
 }
 
 OptionParser.new do |opts|
@@ -22,14 +26,21 @@ OptionParser.new do |opts|
   opts.on("--[no-]pickles", "Don't print pickle messages") do |v|
     options[:include_pickles] = v
   end
+  opts.on("--json", "Print messages as JSON") do |v|
+    options[:json] = v
+  end
 end.parse!
 
-def include_messages(messages)
+def process_messages(messages, options)
   messages.each do |message|
-    json = message.class.encode_json(message)
-    ob = JSON.parse(json)
-    remove_empties(ob)
-    puts JSON.generate(ob)
+    if options[:json]
+      json = message.class.encode_json(message)
+      ob = JSON.parse(json)
+      remove_empties(ob)
+      puts JSON.generate(ob)
+    else
+      message.write_delimited_to(STDOUT)
+    end
   end
 end
 
@@ -49,12 +60,23 @@ def remove_empties(ob)
   end
 end
 
-messages = ARGV.empty? ? 
+gherkin_executable = ENV['GHERKIN_EXECUTABLE']
+if ARGV.empty?
+  # Read protobuf from STDIN
+  messages = Gherkin::Stream::ProtobufMessageStream.new(STDIN).messages
+elsif gherkin_executable
   # Read protobuf from STDIN
-  Gherkin::ProtobufCucumberMessages.new(STDIN).messages
-  :
-  Gherkin::Gherkin.from_paths(
+  messages = Gherkin::Stream::SubprocessMessageStream.new(
+    gherkin_executable,
+    ARGV,
+    options[:include_source],
+    options[:include_gherkin_document],
+    options[:include_pickles]
+  ).messages
+else
+  messages = Gherkin.from_paths(
     ARGV,
     options
   )
-include_messages(messages)
+end
+process_messages(messages, options)

data/lib/gherkin.rb

@@ -0,0 +1,42 @@
+require 'gherkin/stream/parser_message_stream'
+
+module Gherkin
+  DEFAULT_OPTIONS = {
+    include_source: true,
+    include_gherkin_document: true,
+    include_pickles: true
+  }.freeze
+
+  def self.from_paths(paths, options={})
+    Stream::ParserMessageStream.new(
+        paths,
+        [],
+        options
+    ).messages
+  end
+
+  def self.from_sources(sources, options={})
+    Stream::ParserMessageStream.new(
+        [],
+        sources,
+        options
+    ).messages
+  end
+
+  def self.from_source(uri, data, options={})
+    from_sources([encode_source_message(uri, data)], options)
+  end
+
+  private
+
+  def self.encode_source_message(uri, data)
+    Cucumber::Messages::Source.new({
+      uri: uri,
+      data: data,
+      media: Cucumber::Messages::Media.new({
+        encoding: :UTF8,
+        content_type: 'text/x.cucumber.gherkin+plain'
+      })
+    })
+  end
+end

data/lib/gherkin/ast_builder.rb

@@ -0,0 +1,260 @@
+require 'cucumber/messages'
+require 'gherkin/ast_node'
+
+module Gherkin
+  class AstBuilder
+    def initialize
+      reset
+    end
+
+    def reset
+      @stack = [AstNode.new(:None)]
+      @comments = []
+    end
+
+    def start_rule(rule_type)
+      @stack.push AstNode.new(rule_type)
+    end
+
+    def end_rule(rule_type)
+      node = @stack.pop
+      current_node.add(node.rule_type, transform_node(node))
+    end
+
+    def build(token)
+      if token.matched_type == :Comment
+        @comments.push(Cucumber::Messages::GherkinDocument::Comment.new(
+          location: get_location(token, 0),
+          text: token.matched_text
+        ))
+      else
+        current_node.add(token.matched_type, token)
+      end
+    end
+
+    def get_result
+      current_node.get_single(:GherkinDocument)
+    end
+
+    def current_node
+      @stack.last
+    end
+
+    def get_location(token, column)
+      column = column == 0 ? token.location[:column] : column
+      Cucumber::Messages::Location.new(
+        line: token.location[:line],
+        column: column
+      )
+    end
+
+    def get_tags(node)
+      tags = []
+      tags_node = node.get_single(:Tags)
+      return tags unless tags_node
+
+      tags_node.get_tokens(:TagLine).each do |token|
+        token.matched_items.each do |tag_item|
+          tags.push(Cucumber::Messages::GherkinDocument::Feature::Tag.new(
+            location: get_location(token, tag_item.column),
+            name: tag_item.text
+          ))
+        end
+      end
+
+      tags
+    end
+
+    def get_table_rows(node)
+      rows = node.get_tokens(:TableRow).map do |token|
+        Cucumber::Messages::GherkinDocument::Feature::TableRow.new(
+          location: get_location(token, 0),
+          cells: get_cells(token)
+        )
+      end
+      ensure_cell_count(rows)
+      rows
+    end
+
+    def ensure_cell_count(rows)
+      return if rows.empty?
+      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)
+        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)
+    end
+
+    def get_steps(node)
+      node.get_items(:Step)
+    end
+
+    def transform_node(node)
+      case node.rule_type
+      when :Step
+        step_line = node.get_token(:StepLine)
+        data_table = node.get_single(:DataTable)
+        doc_string = node.get_single(:DocString)
+
+        props = {
+          location: get_location(step_line, 0),
+          keyword: step_line.matched_keyword,
+          text: step_line.matched_text
+        }
+        props[:data_table] = data_table if data_table
+        props[:doc_string] = doc_string if doc_string
+
+        Cucumber::Messages::GherkinDocument::Feature::Step.new(props)
+      when :DocString
+        separator_token = node.get_tokens(:DocStringSeparator)[0]
+        content_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")
+
+        props = {
+          location: get_location(separator_token, 0),
+          content: content,
+          delimiter: separator_token.matched_keyword
+        }
+        props[:content_type] = content_type if content_type
+        Cucumber::Messages::GherkinDocument::Feature::Step::DocString.new(props)
+      when :DataTable
+        rows = get_table_rows(node)
+        Cucumber::Messages::GherkinDocument::Feature::Step::DataTable.new(
+          location: rows[0].location,
+          rows: rows,
+        )
+      when :Background
+        background_line = node.get_token(:BackgroundLine)
+        description = get_description(node)
+        steps = get_steps(node)
+
+        props = {
+          location: get_location(background_line, 0),
+          keyword: background_line.matched_keyword,
+          name: background_line.matched_text,
+          steps: steps
+        }
+        props[:description] = description if description
+        Cucumber::Messages::GherkinDocument::Feature::Background.new(props)
+      when :ScenarioDefinition
+        tags = get_tags(node)
+        scenario_node = node.get_single(:Scenario)
+        scenario_line = scenario_node.get_token(:ScenarioLine)
+        description = get_description(scenario_node)
+        steps = get_steps(scenario_node)
+        examples = scenario_node.get_items(:ExamplesDefinition)
+        props = {
+          tags: tags,
+          location: get_location(scenario_line, 0),
+          keyword: scenario_line.matched_keyword,
+          name: scenario_line.matched_text,
+          steps: steps,
+          examples: examples
+        }
+        props[:description] = description if description
+        Cucumber::Messages::GherkinDocument::Feature::Scenario.new(props)
+      when :ExamplesDefinition
+        tags = get_tags(node)
+        examples_node = node.get_single(:Examples)
+        examples_line = examples_node.get_token(:ExamplesLine)
+        description = get_description(examples_node)
+        rows = examples_node.get_single(:ExamplesTable)
+
+        table_header = rows.nil? ? nil : rows.first
+        table_body = rows.nil? ? nil : rows[1..-1]
+
+        props = {
+          tags: tags,
+          location: get_location(examples_line, 0),
+          keyword: examples_line.matched_keyword,
+          name: examples_line.matched_text,
+        }
+        props[:table_header] = table_header if table_header
+        props[:table_body] = table_body if table_body
+        props[:description] = description if description
+        Cucumber::Messages::GherkinDocument::Feature::Scenario::Examples.new(props)
+      when :ExamplesTable
+        get_table_rows(node)
+      when :Description
+        line_tokens = node.get_tokens(:Other)
+        # Trim trailing empty lines
+        last_non_empty = line_tokens.rindex { |token| !token.line.trimmed_line_text.empty? }
+        description = line_tokens[0..last_non_empty].map { |token| token.matched_text }.join("\n")
+        return description
+      when :Feature
+        header = node.get_single(:FeatureHeader)
+        return unless header
+        tags = get_tags(header)
+        feature_line = header.get_token(:FeatureLine)
+        return unless feature_line
+        children = []
+        background = node.get_single(:Background)
+        children.push(Cucumber::Messages::GherkinDocument::Feature::FeatureChild.new(background: background)) if background
+        node.get_items(:ScenarioDefinition).each do |scenario|
+          children.push(Cucumber::Messages::GherkinDocument::Feature::FeatureChild.new(scenario: scenario))
+        end
+        node.get_items(:Rule).each do |rule|
+          children.push(Cucumber::Messages::GherkinDocument::Feature::FeatureChild.new(rule: rule))
+        end
+        description = get_description(header)
+        language = feature_line.matched_gherkin_dialect
+
+        props = {
+          tags: tags,
+          location: get_location(feature_line, 0),
+          language: language,
+          keyword: feature_line.matched_keyword,
+          name: feature_line.matched_text,
+          children: children,
+        }
+        props[:description] = description if description
+
+        Cucumber::Messages::GherkinDocument::Feature.new(props)
+      when :Rule
+        header = node.get_single(:RuleHeader)
+        return unless header
+        rule_line = header.get_token(:RuleLine)
+        return unless rule_line
+        children = []
+        background = node.get_single(:Background)
+        children.push(Cucumber::Messages::GherkinDocument::Feature::FeatureChild::RuleChild.new(background: background)) if background
+        node.get_items(:ScenarioDefinition).each do |scenario|
+          children.push(Cucumber::Messages::GherkinDocument::Feature::FeatureChild::RuleChild.new(scenario: scenario))
+        end
+        description = get_description(header)
+
+        Cucumber::Messages::GherkinDocument::Feature::FeatureChild::Rule.new(
+          location: get_location(rule_line, 0),
+          keyword: rule_line.matched_keyword,
+          name: rule_line.matched_text,
+          description: description,
+          children: children,
+        )
+      when :GherkinDocument
+        feature = node.get_single(:Feature)
+        {
+          feature: feature,
+          comments: @comments
+        }
+      else
+        return node
+      end
+    end
+  end
+end

data/lib/gherkin/ast_node.rb

@@ -0,0 +1,30 @@
+module Gherkin
+  class AstNode
+    attr_reader :rule_type
+
+    def initialize(rule_type)
+      @rule_type = rule_type
+      @_sub_items = Hash.new { |hash, key| hash[key] = [] } # returns [] for unknown key
+    end
+
+    def add(rule_type, obj)
+      @_sub_items[rule_type].push(obj)
+    end
+
+    def get_single(rule_type)
+      @_sub_items[rule_type].first
+    end
+
+    def get_items(rule_type)
+      @_sub_items[rule_type]
+    end
+
+    def get_token(token_type)
+      get_single(token_type)
+    end
+
+    def get_tokens(token_type)
+      @_sub_items[token_type]
+    end
+  end
+end

data/lib/gherkin/dialect.rb

@@ -1,18 +1,8 @@
 require 'json'
-require 'open3'
-require 'c21e/exe_file'
-require 'gherkin/exe_file_path'
 
 module Gherkin
-  def self.dialects_json
-    gherkin_executable = C21e::ExeFile.new(EXE_FILE_PATH).target_file
-    data, = Open3.capture2e(gherkin_executable, '--dialects')
-    data
-  end
-
-  private_class_method :dialects_json
-
-  DIALECTS = JSON.parse(dialects_json)
+  DIALECT_FILE_PATH = File.expand_path("gherkin-languages.json", File.dirname(__FILE__))
+  DIALECTS = JSON.parse File.open(DIALECT_FILE_PATH, 'r:UTF-8').read
 
   class Dialect
     def self.for(name)

data/lib/gherkin/errors.rb

@@ -0,0 +1,45 @@
+module Gherkin
+  class ParserError < StandardError; end
+
+  class ParserException < ParserError
+    attr_reader :location
+
+    def initialize(message, location)
+      @location = location
+      super("(#{location[:line]}:#{location[:column] || 0}): #{message}")
+    end
+  end
+
+  class NoSuchLanguageException < ParserException
+    def initialize(language, location)
+      super "Language not supported: #{language}", location
+    end
+  end
+
+  class AstBuilderException < ParserException; end
+
+  class CompositeParserException < ParserError
+    attr_reader :errors
+
+    def initialize(errors)
+      @errors = errors
+      super "Parser errors:\n" + errors.map(&:message).join("\n")
+    end
+  end
+
+  class UnexpectedTokenException < ParserException
+    def initialize(received_token, expected_token_types, state_comment)
+      message = "expected: #{expected_token_types.join(", ")}, got '#{received_token.token_value.strip}'"
+      column = received_token.location[:column]
+      location =  (column.nil? || column.zero?) ? {line: received_token.location[:line], column: received_token.line.indent + 1} : received_token.location
+      super(message, location)
+    end
+  end
+
+  class UnexpectedEOFException < ParserException
+    def initialize(received_token, expected_token_types, state_comment)
+      message = "unexpected end of file, expected: #{expected_token_types.join(", ")}"
+      super(message, received_token.location)
+    end
+  end
+end