gherkin 2.12.2 → 3.2.0

data/lib/gherkin/pickles/compiler.rb

@@ -0,0 +1,164 @@
+require_relative '../dialect'
+
+module Gherkin
+  module Pickles
+    class Compiler
+      def compile(feature, path)
+        pickles = []
+        dialect = Dialect.for(feature[:language])
+
+        feature_tags = feature[:tags]
+        background_steps = get_background_steps(feature[:background], path)
+
+        feature[:scenarioDefinitions].each do |scenario_definition|
+          if(scenario_definition[:type] == :Scenario)
+            compile_scenario(feature_tags, background_steps, scenario_definition, dialect, path, pickles)
+          else
+            compile_scenario_outline(feature_tags, background_steps, scenario_definition, dialect, path, pickles)
+          end
+        end
+        return pickles
+      end
+
+    private
+
+      def compile_scenario(feature_tags, background_steps, scenario, dialect, path, pickles)
+        steps = [].concat(background_steps)
+
+        tags = [].concat(feature_tags).concat(scenario[:tags])
+
+        scenario[:steps].each do |step|
+          steps.push(pickle_step(step, path))
+        end
+
+        pickle = {
+          tags: pickle_tags(tags, path),
+          name: scenario[:keyword] + ": " + scenario[:name],
+          locations: [pickle_location(scenario[:location], path)],
+          steps: steps
+        }
+        pickles.push(pickle)
+      end
+
+      def compile_scenario_outline(feature_tags, background_steps, scenario_outline, dialect, path, pickles)
+        keyword = dialect.scenario_keywords[0]
+        scenario_outline[:examples].each do |examples|
+          variable_cells = examples[:tableHeader][:cells]
+          examples[:tableBody].each do |values|
+            value_cells = values[:cells]
+            steps = [].concat(background_steps)
+            tags = [].concat(feature_tags).concat(scenario_outline[:tags]).concat(examples[:tags])
+
+            scenario_outline[:steps].each do |scenario_outline_step|
+              step_text = interpolate(scenario_outline_step[:text], variable_cells, value_cells);
+              arguments = create_pickle_arguments(scenario_outline_step[:argument], variable_cells, value_cells, path)
+              pickle_step = {
+                text: step_text,
+                arguments: arguments,
+                locations: [
+                  pickle_location(values[:location], path),
+                  pickle_step_location(scenario_outline_step, path)
+                ]
+              }
+              steps.push(pickle_step)
+            end
+
+            pickle = {
+              name: keyword + ": " + interpolate(scenario_outline[:name], variable_cells, value_cells),
+              steps: steps,
+              tags: pickle_tags(tags, path),
+              locations: [
+                pickle_location(values[:location], path),
+                pickle_location(scenario_outline[:location], path)
+              ]
+            }
+            pickles.push(pickle);
+
+          end
+        end
+      end
+
+      def create_pickle_arguments(argument, variable_cells, value_cells, path)
+        result = []
+        return result if argument.nil?
+        if (argument[:type] == :DataTable)
+          table = {
+            rows: argument[:rows].map do |row|
+              {
+                cells: row[:cells].map do |cell|
+                  {
+                    location: pickle_location(cell[:location], path),
+                    value: interpolate(cell[:value], variable_cells, value_cells)
+                  }
+                end
+              }
+            end
+          }
+          result.push(table)
+        elsif (argument[:type] == :DocString)
+          doc_string = {
+            location: pickle_location(argument[:location], path),
+            content: interpolate(argument[:content], variable_cells, value_cells)
+          }
+          result.push(doc_string)
+        else
+          raise 'Internal error'
+        end
+        result
+      end
+
+      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])
+        end
+        name
+      end
+
+      def get_background_steps(background, path)
+        if(background)
+          background[:steps].map do |step|
+            pickle_step(step, path)
+          end
+        else
+          []
+        end
+      end
+
+      def pickle_step(step, path)
+        {
+          text: step[:text],
+          arguments: create_pickle_arguments(step[:argument], [], [], path),
+          locations: [pickle_step_location(step, path)]
+        }
+      end
+
+      def pickle_step_location(step, path)
+        {
+          path: path,
+          line: step[:location][:line],
+          column: step[:location][:column] + (step[:keyword] ? step[:keyword].length : 0)
+        }
+      end
+
+      def pickle_location(location, path)
+        {
+          path: path,
+          line: location[:line],
+          column: location[:column]
+        }
+      end
+
+      def pickle_tags(tags, path)
+        tags.map {|tag| pickle_tag(tag, path)}
+      end
+
+      def pickle_tag(tag, path)
+        {
+          name: tag[:name],
+          location: pickle_location(tag[:location], path)
+        }
+      end
+    end
+  end
+end

data/lib/gherkin/token.rb

@@ -0,0 +1,18 @@
+module Gherkin
+  class Token < Struct.new(:line, :location)
+    attr_accessor :matched_type, :matched_text, :matched_keyword, :matched_indent,
+                  :matched_items, :matched_gherkin_dialect
+
+    def eof?
+      line.nil?
+    end
+
+    def detach
+      # TODO: detach line - is this needed?
+    end
+
+    def token_value
+      eof? ? "EOF" : line.get_line_text(-1)
+    end
+  end
+end

data/lib/gherkin/token_formatter_builder.rb

@@ -0,0 +1,39 @@
+module Gherkin
+  class TokenFormatterBuilder
+    def initialize
+      reset
+    end
+
+    def reset
+      @tokens_text = ""
+    end
+
+    def build(token)
+      @tokens_text << "#{format_token(token)}\n"
+    end
+
+    def start_rule(rule_type)
+    end
+
+    def end_rule(rule_type)
+    end
+
+    def get_result
+      @tokens_text
+    end
+
+    private
+    def format_token(token)
+      return "EOF" if token.eof?
+
+      sprintf "(%s:%s)%s:%s/%s/%s",
+        token.location[:line],
+        token.location[:column],
+        token.matched_type,
+        token.matched_keyword,
+        token.matched_text,
+        Array(token.matched_items).map { |i| "#{i.column}:#{i.text}"}.join(',')
+    end
+
+  end
+end

data/lib/gherkin/token_matcher.rb

@@ -0,0 +1,169 @@
+require_relative 'dialect'
+require_relative 'errors'
+
+module Gherkin
+  class TokenMatcher
+    LANGUAGE_PATTERN = /^\s*#\s*language\s*:\s*([a-zA-Z\-_]+)\s*$/
+
+    def initialize(dialect_name = 'en')
+      @default_dialect_name = dialect_name
+      change_dialect(dialect_name, nil)
+      reset
+    end
+
+    def reset
+      change_dialect(@default_dialect_name, nil) unless @dialect_name == @default_dialect_name
+      @active_doc_string_separator = nil
+      @indent_to_remove = 0
+    end
+
+    def match_TagLine(token)
+      return false unless token.line.start_with?('@')
+
+      set_token_matched(token, :TagLine, nil, nil, nil, token.line.tags)
+      true
+    end
+
+    def match_FeatureLine(token)
+      match_title_line(token, :FeatureLine, @dialect.feature_keywords)
+    end
+
+    def match_ScenarioLine(token)
+      match_title_line(token, :ScenarioLine, @dialect.scenario_keywords)
+    end
+
+    def match_ScenarioOutlineLine(token)
+      match_title_line(token, :ScenarioOutlineLine, @dialect.scenario_outline_keywords)
+    end
+
+    def match_BackgroundLine(token)
+      match_title_line(token, :BackgroundLine, @dialect.background_keywords)
+    end
+
+    def match_ExamplesLine(token)
+      match_title_line(token, :ExamplesLine, @dialect.examples_keywords)
+    end
+
+    def match_TableRow(token)
+      return false unless token.line.start_with?('|')
+      # TODO: indent
+      set_token_matched(token, :TableRow, nil, nil, nil, token.line.table_cells)
+      true
+    end
+
+    def match_Empty(token)
+      return false unless token.line.empty?
+      set_token_matched(token, :Empty, nil, nil, 0)
+      true
+    end
+
+    def match_Comment(token)
+      return false unless token.line.start_with?('#')
+      text = token.line.get_line_text(0) #take the entire line, including leading space
+      set_token_matched(token, :Comment, text, nil, 0)
+      true
+    end
+
+    def match_Language(token)
+      return false unless token.line.trimmed_line_text =~ LANGUAGE_PATTERN
+
+      dialect_name = $1
+      set_token_matched(token, :Language, dialect_name)
+
+      change_dialect(dialect_name, token.location)
+
+      true
+    end
+
+    def match_DocStringSeparator(token)
+      if @active_doc_string_separator.nil?
+        # open
+        _match_DocStringSeparator(token, '"""', true) ||
+        _match_DocStringSeparator(token, '```', true)
+      else
+        # close
+        _match_DocStringSeparator(token, @active_doc_string_separator, false)
+      end
+    end
+
+    def _match_DocStringSeparator(token, separator, is_open)
+      return false unless token.line.start_with?(separator)
+
+      content_type = nil
+      if is_open
+        content_type = token.line.get_rest_trimmed(separator.length)
+        @active_doc_string_separator = separator
+        @indent_to_remove = token.line.indent
+      else
+        @active_doc_string_separator = nil
+        @indent_to_remove = 0
+      end
+
+      # TODO: Use the separator as keyword. That's needed for pretty printing.
+      set_token_matched(token, :DocStringSeparator, content_type)
+      true
+    end
+
+    def match_EOF(token)
+      return false unless token.eof?
+      set_token_matched(token, :EOF)
+      true
+    end
+
+    def match_Other(token)
+      text = token.line.get_line_text(@indent_to_remove) # take the entire line, except removing DocString indents
+      set_token_matched(token, :Other, unescape_docstring(text), nil, 0)
+      true
+    end
+
+    def match_StepLine(token)
+      keywords = @dialect.given_keywords +
+                 @dialect.when_keywords +
+                 @dialect.then_keywords +
+                 @dialect.and_keywords +
+                 @dialect.but_keywords
+
+      keyword = keywords.detect { |k| token.line.start_with?(k) }
+
+      return false unless keyword
+
+      title = token.line.get_rest_trimmed(keyword.length)
+      set_token_matched(token, :StepLine, title, keyword)
+      return true
+    end
+
+    private
+
+    def change_dialect(dialect_name, location)
+      dialect = Dialect.for(dialect_name)
+      raise NoSuchLanguageException.new(dialect_name, location) if dialect.nil?
+
+      @dialect_name = dialect_name
+      @dialect = dialect
+    end
+
+    def match_title_line(token, token_type, keywords)
+      keyword = keywords.detect { |k| token.line.start_with_title_keyword?(k) }
+
+      return false unless keyword
+
+      title = token.line.get_rest_trimmed(keyword.length + ':'.length)
+      set_token_matched(token, token_type, title, keyword)
+      true
+    end
+
+    def set_token_matched(token, matched_type, text=nil, keyword=nil, indent=nil, items=[])
+      token.matched_type = matched_type
+      token.matched_text = text && text.chomp
+      token.matched_keyword = keyword
+      token.matched_indent = indent || (token.line && token.line.indent) || 0
+      token.matched_items = items
+      token.location[:column] = token.matched_indent + 1
+      token.matched_gherkin_dialect = @dialect_name
+    end
+
+    def unescape_docstring(text)
+      @active_doc_string_separator ? text.gsub("\\\"\\\"\\\"", "\"\"\"") : text
+    end
+  end
+end

data/lib/gherkin/token_scanner.rb

@@ -0,0 +1,40 @@
+require 'stringio'
+require_relative 'token'
+require_relative 'gherkin_line'
+
+module Gherkin
+  # The scanner reads a gherkin doc (typically read from a .feature file) and
+  # creates a token for line. The tokens are passed to the parser, which outputs
+  # an AST (Abstract Syntax Tree).
+  #
+  # If the scanner sees a # language header, it will reconfigure itself dynamically
+  # to look for Gherkin keywords for the associated language. The keywords are defined
+  # in gherkin-languages.json.
+  class TokenScanner
+    def initialize(source_or_io)
+      @line_number = 0
+
+      case(source_or_io)
+      when String
+        @io = StringIO.new(source_or_io)
+      when StringIO, IO
+        @io = source_or_io
+      else
+        fail ArgumentError, "Please a pass String, StringIO or IO. I got a #{source_or_io.class}"
+      end
+    end
+
+    def read
+      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)
+      else
+        @io.close unless @io.closed? # ARGF closes the last file after final gets
+        @io = nil
+        Token.new(nil, location)
+      end
+    end
+
+  end
+end

data/spec/capture_warnings.rb

@@ -0,0 +1,68 @@
+# With thanks to @myronmarston
+# https://github.com/vcr/vcr/blob/master/spec/capture_warnings.rb
+
+module CaptureWarnings
+  def report_warnings(&block)
+    current_dir = Dir.pwd
+    warnings, errors = capture_error(&block).partition { |line| line.include?('warning') }
+    project_warnings, other_warnings = warnings.uniq.partition { |line| line.include?(current_dir) }
+
+    if errors.any?
+      puts errors.join("\n")
+    end
+
+    if other_warnings.any?
+      puts "#{ other_warnings.count } non-gherkin warnings detected, set VIEW_OTHER_WARNINGS=true to see them."
+      print_warnings('other', other_warnings) if ENV['VIEW_OTHER_WARNINGS']
+    end
+
+    if project_warnings.any?
+      puts "#{ project_warnings.count } gherkin warnings detected"
+      print_warnings('gherkin', project_warnings)
+      fail "Please remove all gherkin warnings."
+    end
+
+    ensure_system_exit_if_required
+  end
+
+  def capture_error(&block)
+    old_stderr = STDERR.clone
+    pipe_r, pipe_w = IO.pipe
+    pipe_r.sync    = true
+    error         = ""
+    reader = Thread.new do
+      begin
+        loop do
+          error << pipe_r.readpartial(1024)
+        end
+      rescue EOFError
+      end
+    end
+    STDERR.reopen(pipe_w)
+    block.call
+  ensure
+    capture_system_exit
+    STDERR.reopen(old_stderr)
+    pipe_w.close
+    reader.join
+    return error.split("\n")
+  end
+
+  def print_warnings(type, warnings)
+    puts
+    puts "-" * 30 + " #{type} warnings: " + "-" * 30
+    puts
+    puts warnings.join("\n")
+    puts
+    puts "-" * 75
+    puts
+  end
+
+  def ensure_system_exit_if_required
+    raise @system_exit if @system_exit
+  end
+
+  def capture_system_exit
+    @system_exit = $!
+  end
+end