gherkin 5.1.0 → 6.0.10

data/lib/gherkin/pickles/compiler.rb

@@ -1,163 +0,0 @@
-module Gherkin
-  module Pickles
-    class Compiler
-      def compile(gherkin_document)
-        pickles = []
-
-        return pickles unless gherkin_document[:feature]
-        feature = gherkin_document[:feature]
-        feature_tags = feature[:tags]
-        background_steps = []
-
-        feature[:children].each do |scenario_definition|
-          if(scenario_definition[:type] == :Background)
-            background_steps = pickle_steps(scenario_definition)
-          elsif(scenario_definition[:type] == :Scenario)
-            compile_scenario(feature_tags, background_steps, scenario_definition, feature[:language], pickles)
-          else
-            compile_scenario_outline(feature_tags, background_steps, scenario_definition, feature[:language], pickles)
-          end
-        end
-        return pickles
-      end
-
-    private
-
-      def compile_scenario(feature_tags, background_steps, scenario, language, pickles)
-        steps = scenario[:steps].empty? ? [] : [].concat(background_steps)
-
-        tags = [].concat(feature_tags).concat(scenario[:tags])
-
-        scenario[:steps].each do |step|
-          steps.push(pickle_step(step))
-        end
-
-        pickle = {
-          tags: pickle_tags(tags),
-          name: scenario[:name],
-          language: language,
-          locations: [pickle_location(scenario[:location])],
-          steps: steps
-        }
-        pickles.push(pickle)
-      end
-
-      def compile_scenario_outline(feature_tags, background_steps, scenario_outline, language, pickles)
-        scenario_outline[:examples].reject { |examples| examples[:tableHeader].nil? }.each do |examples|
-          variable_cells = examples[:tableHeader][:cells]
-          examples[:tableBody].each do |values|
-            value_cells = values[:cells]
-            steps = scenario_outline[:steps].empty? ? [] : [].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)
-              pickle_step = {
-                text: step_text,
-                arguments: arguments,
-                locations: [
-                  pickle_location(values[:location]),
-                  pickle_step_location(scenario_outline_step)
-                ]
-              }
-              steps.push(pickle_step)
-            end
-
-            pickle = {
-              name: interpolate(scenario_outline[:name], variable_cells, value_cells),
-              language: language,
-              steps: steps,
-              tags: pickle_tags(tags),
-              locations: [
-                pickle_location(values[:location]),
-                pickle_location(scenario_outline[:location])
-              ]
-            }
-            pickles.push(pickle);
-
-          end
-        end
-      end
-
-      def create_pickle_arguments(argument, variable_cells, value_cells)
-        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]),
-                    value: interpolate(cell[:value], variable_cells, value_cells)
-                  }
-                end
-              }
-            end
-          }
-          result.push(table)
-        elsif (argument[:type] == :DocString)
-          doc_string = {
-            location: pickle_location(argument[:location]),
-            content: interpolate(argument[:content], variable_cells, value_cells)
-          }
-          if argument.key?(:contentType)
-            doc_string[:contentType] = interpolate(argument[:contentType], variable_cells, value_cells)
-          end
-          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 pickle_steps(scenario_definition)
-        scenario_definition[:steps].map do |step|
-          pickle_step(step)
-        end
-      end
-
-      def pickle_step(step)
-        {
-          text: step[:text],
-          arguments: create_pickle_arguments(step[:argument], [], []),
-          locations: [pickle_step_location(step)]
-        }
-      end
-
-      def pickle_step_location(step)
-        {
-          line: step[:location][:line],
-          column: step[:location][:column] + (step[:keyword] ? step[:keyword].length : 0)
-        }
-      end
-
-      def pickle_location(location)
-        {
-          line: location[:line],
-          column: location[:column]
-        }
-      end
-
-      def pickle_tags(tags)
-        tags.map {|tag| pickle_tag(tag)}
-      end
-
-      def pickle_tag(tag)
-        {
-          name: tag[:name],
-          location: pickle_location(tag[:location])
-        }
-      end
-    end
-  end
-end

data/lib/gherkin/stream/gherkin_events.rb

@@ -1,71 +0,0 @@
-require 'gherkin/parser'
-require 'gherkin/token_matcher'
-require 'gherkin/pickles/compiler'
-
-module Gherkin
-  module Stream
-    class GherkinEvents
-      def initialize(options, language='en')
-        @options = options
-        @parser = Gherkin::Parser.new
-        @compiler = Gherkin::Pickles::Compiler.new
-        @language = language
-      end
-
-      def enum(source_event)
-        Enumerator.new do |y|
-          uri = source_event[:uri]
-          source = source_event[:data]
-          begin
-            gherkin_document = @parser.parse(source, TokenMatcher.new(@language))
-
-            if (@options[:print_source])
-              y.yield source_event
-            end
-            if (@options[:print_ast])
-              y.yield({
-                type: 'gherkin-document',
-                uri: uri,
-                document: gherkin_document
-              })
-            end
-            if (@options[:print_pickles])
-              pickles = @compiler.compile(gherkin_document)
-              pickles.each do |pickle|
-                y.yield({
-                  type: 'pickle',
-                  uri: uri,
-                  pickle: pickle
-                })
-              end
-            end
-          rescue Gherkin::CompositeParserException => e
-            yield_errors(y, e.errors, uri)
-          rescue Gherkin::ParserError => e
-            yield_errors(y, [e], uri)
-          end
-        end
-      end
-
-      def yield_errors(y, errors, uri)
-        errors.each do |error|
-          y.yield({
-            type: 'attachment',
-            source: {
-              uri: uri,
-              start: {
-                line: error.location[:line],
-                column: error.location[:column]
-              }
-            },
-            data: error.message,
-            media: {
-              encoding: 'utf-8',
-              type: 'text/x.cucumber.stacktrace+plain'
-            }
-          })
-        end
-      end
-    end
-  end
-end

data/lib/gherkin/stream/source_events.rb

@@ -1,26 +0,0 @@
-module Gherkin
-  module Stream
-    class SourceEvents
-      def initialize(paths)
-        @paths = paths
-      end
-
-      def enum
-        Enumerator.new do |y|
-          @paths.each do |path|
-            event = {
-              type: 'source',
-              uri: path,
-              data: File.open(path, 'r:UTF-8', &:read),
-              media: {
-                encoding: 'utf-8',
-                type: 'text/x.cucumber.gherkin+plain'
-              }
-            }
-            y.yield(event)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/gherkin/token.rb

@@ -1,18 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,169 +0,0 @@
-require 'gherkin/dialect'
-require 'gherkin/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