cucumber-gherkin 9.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e29214ad6a0eae41b18a082346911c0bae2fdd0297e8b878549c2d8c8cd241ac
+  data.tar.gz: 1a3dd2275a2bf3e4999f360135b7f86342e84a30d146668ecf83ad111b103faa
+SHA512:
+  metadata.gz: 3889715de4087bae76cc68de729ec3d4fd613ad7fc07f815d6f47ec94d517fa364cc38a93620f132c3db5aeb2cafe25261f52328f90022ad1631f0271b18631b
+  data.tar.gz: 529b1867c7dfcfca824ee6a8a35bcfe7542bf42a5f6ed1c067d66c5f79ea26430c7ab7e82f27ce426c210684aee72802c951ffc2714189538b01987cfb4b6847

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Cucumber Ltd, Gaspar Nagy, Björn Rasmusson, Peter Sergeant
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,10 @@
+[![Build Status](https://secure.travis-ci.org/cucumber/gherkin-ruby.svg)](http://travis-ci.org/cucumber/gherkin-ruby)
+
+Gherkin parser/compiler for Ruby. Please see [Gherkin](https://github.com/cucumber/gherkin) for details.
+
+## To build
+
+~~~bash
+cd <project_root>/ruby
+make
+~~~

data/bin/gherkin

@@ -0,0 +1,68 @@
+#!/usr/bin/env ruby
+$VERBOSE=nil # Shut up JRuby warnings on Travis
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__),"../lib"))
+
+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
+}
+
+OptionParser.new do |opts|
+  opts.on("--[no-]source", "Don't print source messages") do |v|
+    options[:include_source] = v
+  end
+  opts.on("--[no-]ast", "Don't print ast messages") do |v|
+    options[:include_gherkin_document] = v
+  end
+  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
+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
+  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
+else
+  messages = Gherkin.from_paths(
+    ARGV,
+    options
+  )
+end
+process_messages(messages, options)

data/bin/gherkin-ruby

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+load(File.dirname(__FILE__) + '/gherkin')

data/lib/gherkin.rb

@@ -0,0 +1,39 @@
+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_type: 'text/x.cucumber.gherkin+plain'
+    })
+  end
+end

data/lib/gherkin/ast_builder.rb

@@ -0,0 +1,257 @@
+require 'cucumber/messages'
+require 'gherkin/ast_node'
+
+module Gherkin
+  class AstBuilder
+    def initialize(id_generator)
+      @id_generator = id_generator
+      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,
+            id: @id_generator.new_id
+          ))
+        end
+      end
+
+      tags
+    end
+
+    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
+    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)
+
+        Cucumber::Messages::GherkinDocument::Feature::Step.new(
+          location: get_location(step_line, 0),
+          keyword: step_line.matched_keyword,
+          text: step_line.matched_text,
+          data_table: data_table,
+          doc_string: doc_string,
+          id: @id_generator.new_id
+        )
+      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,
+        )
+      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)
+
+        Cucumber::Messages::GherkinDocument::Feature::Background.new(
+          location: get_location(background_line, 0),
+          keyword: background_line.matched_keyword,
+          name: background_line.matched_text,
+          description: description,
+          steps: steps
+        )
+      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)
+        Cucumber::Messages::GherkinDocument::Feature::Scenario.new(
+          id: @id_generator.new_id,
+          tags: tags,
+          location: get_location(scenario_line, 0),
+          keyword: scenario_line.matched_keyword,
+          name: scenario_line.matched_text,
+          description: description,
+          steps: steps,
+          examples: examples
+        )
+      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]
+
+        Cucumber::Messages::GherkinDocument::Feature::Scenario::Examples.new(
+          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,
+        )
+      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
+
+        Cucumber::Messages::GherkinDocument::Feature.new(
+          tags: tags,
+          location: get_location(feature_line, 0),
+          language: language,
+          keyword: feature_line.matched_keyword,
+          name: feature_line.matched_text,
+          description: description,
+          children: children,
+        )
+      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

@@ -0,0 +1,62 @@
+require 'json'
+
+module Gherkin
+  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)
+      spec = DIALECTS[name]
+      return nil unless spec
+      new(spec)
+    end
+
+    def initialize(spec)
+      @spec = spec
+    end
+
+    def feature_keywords
+      @spec.fetch('feature')
+    end
+
+    def rule_keywords
+      @spec.fetch('rule')
+    end
+
+    def scenario_keywords
+      @spec.fetch('scenario')
+    end
+
+    def scenario_outline_keywords
+      @spec.fetch('scenarioOutline')
+    end
+
+    def examples_keywords
+      @spec.fetch('examples')
+    end
+
+    def background_keywords
+      @spec.fetch('background')
+    end
+
+    def given_keywords
+      @spec.fetch('given')
+    end
+
+    def when_keywords
+      @spec.fetch('when')
+    end
+
+    def then_keywords
+      @spec.fetch('then')
+    end
+
+    def and_keywords
+      @spec.fetch('and')
+    end
+
+    def but_keywords
+      @spec.fetch('but')
+    end
+  end
+end