cucumber-core 3.2.1 → 4.0.0

data/lib/cucumber/core/ast/step.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/core/ast/describes_itself'
-require 'cucumber/core/ast/location'
-
-module Cucumber
-  module Core
-    module Ast
-      class Step
-        include HasLocation
-        include DescribesItself
-
-        attr_reader :keyword, :text, :language, :comments, :exception, :multiline_arg
-
-        def initialize(language, location, comments, keyword, text, multiline_arg)
-          @language, @location, @comments, @keyword, @text, @multiline_arg = language, location, comments, keyword, text, multiline_arg
-        end
-
-        def to_s
-          text
-        end
-
-        def backtrace_line
-          "#{location}:in `#{keyword}#{text}'"
-        end
-
-        def actual_keyword(previous_step_keyword = nil)
-          if [language.and_keywords, language.but_keywords].flatten.uniq.include? keyword
-            if previous_step_keyword.nil?
-              language.given_keywords.reject{|kw| kw == '* '}[0]
-            else
-              previous_step_keyword
-            end
-          else
-            keyword
-          end
-        end
-
-        def original_location
-          location
-        end
-
-        def inspect
-          keyword_and_text = [keyword, text].join(": ")
-          %{#<#{self.class} "#{keyword_and_text}" (#{location})>}
-        end
-
-
-        private
-
-        def children
-          [@multiline_arg]
-        end
-
-        def description_for_visitors
-          :step
-        end
-      end
-
-      class ExpandedOutlineStep < Step
-
-        def initialize(outline_step, language, location, comments, keyword, text, multiline_arg)
-          @outline_step, @language, @location, @comments, @keyword, @text, @multiline_arg = outline_step, language, location, comments, keyword, text, multiline_arg
-        end
-
-        def all_locations
-          @outline_step.all_locations
-        end
-
-        def original_location
-          @outline_step.location
-        end
-
-        alias :step_backtrace_line :backtrace_line
-
-        def backtrace_line
-          "#{step_backtrace_line}\n" +
-          "#{@outline_step.location}:in `#{@outline_step.keyword}#{@outline_step.text}'"
-        end
-
-      end
-    end
-  end
-end

data/lib/cucumber/core/gherkin/ast_builder.rb

@@ -1,403 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/core/ast'
-require 'cucumber/core/platform'
-
-module Cucumber
-  module Core
-    module Gherkin
-      # Builds an AST of a feature by listening to events from the
-      # Gherkin parser.
-      class AstBuilder
-
-        def initialize(uri)
-          @uri = uri
-        end
-
-        def feature(attributes)
-          DocumentBuilder.new(file, attributes).feature
-        end
-
-        private
-
-        def file
-          @uri
-        end
-
-        class Builder
-          attr_reader :file, :attributes, :comments, :line
-          private     :file, :attributes, :comments, :line
-
-          def initialize(file, attributes)
-            @file = file
-            @attributes = rubify_keys(attributes.dup)
-            @comments = []
-            @line = @attributes[:location][:line]
-          end
-
-          def handle_comments(comments)
-            remaining_comments = []
-            comments.each do |comment|
-              if line > comment.location.line
-                @comments << comment
-              else
-                remaining_comments << comment
-              end
-            end
-            children.each { |child| remaining_comments = child.handle_comments(remaining_comments) }
-            remaining_comments
-          end
-
-          private
-
-          def keyword
-            attributes[:keyword]
-          end
-
-          def name
-            attributes[:name]
-          end
-
-          def description
-            attributes[:description] ||= ""
-          end
-
-          def tags
-            attributes[:tags].map do |tag|
-              Ast::Tag.new(
-                Ast::Location.new(file, tag[:location][:line]),
-                tag[:name])
-            end
-          end
-
-          def location
-            Ast::Location.new(file, attributes[:location][:line])
-          end
-
-          def children
-            []
-          end
-
-          def rubify_keys(hash)
-            hash.keys.each do |key|
-              if key.downcase != key
-                hash[underscore(key).to_sym] = hash.delete(key)
-              end
-            end
-            return hash
-          end
-
-          def underscore(string)
-            string.to_s.gsub(/::/, '/').
-              gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-              gsub(/([a-z\d])([A-Z])/,'\1_\2').
-              tr("-", "_").
-              downcase
-          end
-        end
-
-        class DocumentBuilder < Builder
-          def initialize(file, attributes)
-            @file = file
-            @attributes = rubify_keys(attributes.dup)
-          end
-
-          def feature
-            return Ast::NullFeature.new unless attributes[:feature]
-            feature_builder = FeatureBuilder.new(file, attributes[:feature])
-            feature_builder.handle_comments(all_comments)
-            feature_builder.result
-          end
-
-          def all_comments
-            attributes[:comments].map do |comment|
-              Ast::Comment.new(
-                Ast::Location.new(file, comment[:location][:line]),
-                comment[:text]
-              )
-            end
-          end
-        end
-
-        class FeatureBuilder < Builder
-          attr_reader :language, :feature_element_builders
-
-          def initialize(*)
-            super
-            @language = Ast::LanguageDelegator.new(attributes[:language], ::Gherkin::Dialect.for(attributes[:language]))
-            @feature_element_builders = attributes[:children].map do |child|
-              case child[:type]
-              when :Background
-                BackgroundBuilder.new(file, child)
-              when :Scenario
-                ScenarioBuilder.new(file, child)
-              else 
-                ScenarioOutlineBuilder.new(file, child)
-              end
-            end
-          end
-
-          def result
-            Ast::Feature.new(
-              language,
-              location,
-              comments,
-              tags,
-              keyword,
-              name,
-              description,
-              feature_elements
-            )
-          end
-
-          private
-
-          def feature_elements
-            feature_element_builders.map { |builder| builder.result(language) }
-          end
-
-          def children
-            feature_element_builders
-          end
-        end
-
-        class BackgroundBuilder < Builder
-          attr_reader :step_builders
-
-          def initialize(*)
-            super
-            @step_builders = attributes[:steps].map { |step| StepBuilder.new(file, step) }
-          end
-
-          def result(language)
-            Ast::Background.new(
-              location,
-              comments,
-              keyword,
-              name,
-              description,
-              steps(language)
-            )
-          end
-
-          def steps(language)
-            step_builders.map { |builder| builder.result(language) }
-          end
-
-          def children
-            step_builders
-          end
-        end
-
-        class ScenarioBuilder < Builder
-          attr_reader :step_builders
-
-          def initialize(*)
-            super
-            @step_builders = attributes[:steps].map { |step| StepBuilder.new(file, step) }
-          end
-
-          def result(language)
-            Ast::Scenario.new(
-              location,
-              comments,
-              tags,
-              keyword,
-              name,
-              description,
-              steps(language)
-            )
-          end
-
-          def steps(language)
-            step_builders.map { |builder| builder.result(language) }
-          end
-
-          def children
-            step_builders
-          end
-        end
-
-        class StepBuilder < Builder
-          attr_reader :multiline_argument_builder
-
-          def initialize(*)
-            super
-            @multiline_argument_builder = attributes[:argument] ? argument_builder(attributes[:argument]) : nil
-          end
-
-          def result(language)
-            Ast::Step.new(
-              language,
-              location,
-              comments,
-              keyword,
-              attributes[:text],
-              multiline_argument
-            )
-          end
-
-          def multiline_argument
-            return Ast::EmptyMultilineArgument.new unless multiline_argument_builder
-            multiline_argument_builder.result
-          end
-
-          def children
-            return [] unless multiline_argument_builder
-            [multiline_argument_builder]
-          end
-
-          private
-
-          def argument_builder(attributes)
-            attributes[:type] == :DataTable ? DataTableBuilder.new(file, attributes) : DocStringBuilder.new(file, attributes) 
-          end
-        end
-
-        class OutlineStepBuilder < StepBuilder
-          def result(language)
-            Ast::OutlineStep.new(
-              language,
-              location,
-              comments,
-              keyword,
-              attributes[:text],
-              multiline_argument
-            )
-          end
-        end
-
-        class ScenarioOutlineBuilder < Builder
-          attr_reader :step_builders, :example_builders
-
-          def initialize(*)
-            super
-            @step_builders = attributes[:steps].map { |step| OutlineStepBuilder.new(file, step) }
-            @example_builders = attributes[:examples] ? attributes[:examples].map { |example| ExamplesTableBuilder.new(file, example) } : []
-          end
-
-          def result(language)
-            Ast::ScenarioOutline.new(
-              location,
-              comments,
-              tags,
-              keyword,
-              name,
-              description,
-              steps(language),
-              examples(language)
-            )
-          end
-
-          def steps(language)
-            step_builders.map { |builder| builder.result(language) }
-          end
-
-          def examples(language)
-            example_builders.map { |builder| builder.result(language) }
-          end
-
-          def children
-            step_builders + example_builders
-          end
-        end
-
-        class ExamplesTableBuilder < Builder
-          attr_reader :header_builder, :example_rows_builders
-
-          def initialize(*)
-            super
-            @header_builder = attributes[:table_header] ? HeaderBuilder.new(file, attributes[:table_header]) : NullHeaderBuilder.new
-            @example_rows_builders = attributes[:table_body] ? attributes[:table_body].map { |row_attributes| ExampleRowBuilder.new(file, row_attributes) } : []
-          end
-
-          def result(language)
-            Ast::Examples.new(
-              location,
-              comments,
-              tags,
-              keyword,
-              name,
-              description,
-              header,
-              example_rows(language)
-            )
-          end
-
-          private
-
-          def header
-            @header = header_builder.result
-          end
-
-          def example_rows(language)
-            example_rows_builders.each.with_index.map { |builder, index| builder.result(language, header, index) }
-          end
-
-          class HeaderBuilder < Builder
-            def result
-              cells = attributes[:cells].map { |c| c[:value] }
-              Ast::ExamplesTable::Header.new(cells, location, comments)
-            end
-          end
-
-          class NullHeaderBuilder < Builder
-            def initialize
-              @line = -1 # this inhibits Builder#handle_comments to put any comments in this object. 
-            end
-
-            def result
-              nil
-            end
-          end
-
-          def children
-            [header_builder] + example_rows_builders
-          end
-
-          class ExampleRowBuilder < Builder
-            def result(language, header, index)
-              cells = attributes[:cells].map { |c| c[:value] }
-              header.build_row(cells, index + 1, location, language, comments)
-            end
-          end
-        end
-
-        class DataTableBuilder < Builder
-          def result
-            Ast::DataTable.new(
-              rows,
-              location
-            )
-          end
-
-          def rows
-            attributes[:rows] = attributes[:rows].map { |r| r[:cells].map { |c| c[:value] } }
-          end
-
-          def location
-            first_line = attributes[:location][:line]
-            last_line = first_line + attributes[:rows].length - 1
-            Ast::Location.new(file, first_line..last_line)
-          end
-        end
-
-        class DocStringBuilder < Builder
-          def result
-            Ast::DocString.new(
-              attributes[:content],
-              attributes[:content_type],
-              doc_string_location
-            )
-          end
-
-          def doc_string_location
-            start_line = attributes[:location][:line]
-            end_line = start_line + attributes[:content].each_line.to_a.length + 1
-            Ast::Location.new(file, start_line..end_line)
-          end
-        end
-
-      end
-    end
-  end
-end