cucumber-core 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 53a124c933b4697ed6128b46c307617ea4399559
-  data.tar.gz: e80a381d06f95b5416035f91a004d00cbd68057e
+  metadata.gz: 0f56999cf96221b9de93c823a5559efeb56bfb34
+  data.tar.gz: 1e955adc2d60f414a53e6775d0e6adc44b4eafa5
 SHA512:
-  metadata.gz: 0b1e3a4359e8ccaeef234bfa1492e678145bf1f07320ffbf1e01814b2efd405da9ae10abb31347ac10642e49935183032b1f7a094631219c48d7a4b984c5e6cf
-  data.tar.gz: e7d0c05ae5e57937e6858c91485157175e69d32332457db403a69d1e8b44e9a99bf95cc68e2bdb1b265ad5decaa69086fbca3a0d48e6cf97ca6cf64b4b54e855
+  metadata.gz: 529edb34199a3bea271b93d0f09de3e4b2c24dc7f4c198ff553fe029b7d0b5c1a7a4a18d744586725351d5e1f9795c6caec1e8e35b64e2c77eab858ad3d8052e
+  data.tar.gz: 42aa0c463801d3aaba42d95c2bbdd0519a8d5344da0ef6c594d7a6bd704329947c5265aea47e3eee601e20c043fac8ca31b25afc5e75a9d1630b85ead562bd80

data/HISTORY.md

@@ -1,6 +1,14 @@
 ## [In Git](https://github.com/cucumber/cucumber-ruby-core/compare/v1.2.0...master)
 
-...
+### New Features
+
+ * Add factory method to Cucumber::Core::Ast::Location that uses the output from Proc#source_location (@brasmusson)
+ * Integrate Gherkin3 parser (@brassmusson)
+
+### Bugfixes
+
+ * Make sure that `after_test_step` is sent also when a test step is interrupted by (a timeout in) an around hook ([cucumber/cucumber-ruby#909](https://github.com/cucumber/cucumber-ruby/issues/909) @brasmusson)
+ * Improve the check that a test_step quacks like a Cucumber::Core::Test::Step ([95](https://github.com/cucumber/cucumber-ruby-core/issues/95) @brasmusson)
 
 ## [v1.2.0](https://github.com/cucumber/cucumber-ruby-core/compare/v1.1.3...v1.2.0)
 
@@ -68,7 +76,7 @@
 
 ### Bugfixes
 
- * Handle empty feature files (#[77](https://github.com/cucumber/cucumber-ruby-core/pull/77), [cucumber/cucumber#771](https://github.com/cucumber/cucumber/issues/771) [@brasmusson](https://github.com/brasmusson))
+ * Handle empty feature files (#[77](https://github.com/cucumber/cucumber-ruby-core/pull/77), [cucumber/cucumber-ruby#771](https://github.com/cucumber/cucumber-ruby/issues/771) [@brasmusson](https://github.com/brasmusson))
  * Run after hooks in reverse order (#[69](https://github.com/cucumber/cucumber-ruby-core/pull/69) [@erran](https://github.com/erran))
 
 ## [v1.0.0.beta.3](https://github.com/cucumber/cucumber-ruby-core/compare/v1.0.0.beta.2...v1.0.0.beta.3)

data/cucumber-core.gemspec

@@ -14,7 +14,7 @@ Gem::Specification.new do |s|
   s.license     = "MIT"
   s.required_ruby_version = ">= 1.9.3"
 
-  s.add_dependency 'gherkin', '~> 2.12.0'
+  s.add_dependency 'gherkin3', '~> 3.1.0'
 
   s.add_development_dependency 'bundler',   '>= 1.3.5'
   s.add_development_dependency 'rake',      '>= 0.9.2'

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

@@ -10,9 +10,7 @@ module Cucumber
         include HasLocation
         include DescribesItself
 
-        def initialize(gherkin_statement, language, location, comments, keyword, name, description, raw_steps)
-          @gherkin_statement = gherkin_statement
-          @language = language
+        def initialize(location, comments, keyword, name, description, raw_steps)
           @location = location
           @comments = comments
           @keyword = keyword
@@ -21,11 +19,10 @@ module Cucumber
           @raw_steps = raw_steps
         end
 
-        attr_reader :language, :description, :raw_steps
-        private     :language, :raw_steps
+        attr_reader :description, :raw_steps
+        private     :raw_steps
 
         attr_reader :comments, :keyword, :location
-        attr_reader :gherkin_statement
 
         def children
           raw_steps

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

@@ -1,6 +1,3 @@
-require 'gherkin/rubify'
-require 'gherkin/lexer/i18n_lexer'
-require 'gherkin/formatter/escaping'
 require 'cucumber/core/ast/describes_itself'
 require 'cucumber/core/ast/location'
 
@@ -30,15 +27,13 @@ module Cucumber
         include DescribesItself
         include HasLocation
 
-        include ::Gherkin::Rubify
-
         # Creates a new instance. +raw+ should be an Array of Array of String
         # or an Array of Hash
         # You don't typically create your own DataTable objects - Cucumber will do
         # it internally and pass them to your Step Definitions.
         #
-        def initialize(raw, location)
-          raw = ensure_array_of_array(rubify(raw))
+        def initialize(rows, location)
+          raw = ensure_array_of_array(rows)
           verify_rows_are_same_length(raw)
           @raw = raw.freeze
           @location = location

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

@@ -5,7 +5,11 @@ module Cucumber
         def describe_to(visitor, *args)
           visitor.send(description_for_visitors, self, *args) do |child_visitor|
             children.each do |child|
-              child.describe_to(child_visitor, *args)
+              begin
+                child.describe_to(child_visitor, *args)
+              rescue => e
+                raise e.class, "Failed describing child of #{self.inspect} - #{e.message}", e.backtrace
+              end
             end
           end
           self

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

@@ -25,8 +25,8 @@ module Cucumber
 
         attr_reader :content_type, :content
 
-        def initialize(string, content_type, location)
-          @content = string
+        def initialize(content, content_type, location)
+          @content = content
           @content_type = content_type
           @location = location
           super @content

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

@@ -11,8 +11,7 @@ module Cucumber
         include HasLocation
         include DescribesItself
 
-        def initialize(gherkin_statement, location, comments, tags, keyword, name, description, header, example_rows)
-          @gherkin_statement = gherkin_statement
+        def initialize(location, comments, tags, keyword, name, description, header, example_rows)
           @location = location
           @comments = comments
           @tags = tags
@@ -23,7 +22,7 @@ module Cucumber
           @example_rows = example_rows
         end
 
-        attr_reader :gherkin_statement, :location, :comments, :tags, :keyword,
+        attr_reader :location, :tags, :keyword, :comments,
                     :header, :example_rows
 
         private
@@ -109,6 +108,7 @@ module Cucumber
           end
         end
       end
+      class Examples < ExamplesTable; end
     end
   end
 end

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

@@ -1,6 +1,7 @@
 require 'cucumber/core/ast/describes_itself'
 require 'cucumber/core/ast/names'
 require 'cucumber/core/ast/location'
+require 'gherkin3/dialect'
 
 module Cucumber
   module Core
@@ -11,12 +12,11 @@ module Cucumber
         include HasLocation
         include DescribesItself
 
-        attr_reader :gherkin_statement, :language, :location, :background,
+        attr_reader :language, :location, :background,
                     :comments, :tags, :keyword, :description,
                     :feature_elements
 
-        def initialize(gherkin_statement, language, location, background, comments, tags, keyword, name, description, feature_elements)
-          @gherkin_statement = gherkin_statement
+        def initialize(language, location, background, comments, tags, keyword, name, description, scenario_definitions)
           @language = language
           @location = location
           @background = background
@@ -25,7 +25,7 @@ module Cucumber
           @keyword = keyword
           @name = name
           @description = description
-          @feature_elements = feature_elements
+          @feature_elements = scenario_definitions
         end
 
         def children
@@ -34,7 +34,7 @@ module Cucumber
 
         def short_name
           first_line = name.split(/\n/)[0]
-          if first_line =~ /#{language.keywords('feature')}:(.*)/
+          if first_line =~ /#{language.feature_keywords}:(.*)/
             $1.strip
           else
             first_line
@@ -65,6 +65,15 @@ module Cucumber
           self
         end
       end
+
+      class LanguageDelegator < SimpleDelegator
+        attr_reader :iso_code
+
+        def initialize(iso_code, obj)
+          super(obj)
+          @iso_code = iso_code
+        end
+      end
     end
   end
 end

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

@@ -13,9 +13,25 @@ module Cucumber
         def_delegator :filepath, :same_as?
         def_delegator :filepath, :filename, :file
 
-        def self.of_caller
-          file, raw_line = *caller[1].split(':')[0..1]
-          new(file, raw_line.to_i)
+        def self.of_caller(additional_depth = 0)
+          from_file_colon_line(*caller[1 + additional_depth])
+        end
+
+        def self.from_file_colon_line(file_colon_line)
+          file, raw_line = file_colon_line.match(/(.*):(\d+)/)[1..2]
+          from_source_location(file, raw_line.to_i)
+        end
+
+        def self.from_source_location(file, line)
+          file = File.expand_path(file)
+          pwd = File.expand_path(Dir.pwd)
+          pwd.force_encoding(file.encoding)
+          if file.index(pwd)
+            file = file[pwd.length+1..-1]
+          elsif file =~ /.*\/gems\/(.*\.rb)$/
+            file = $1
+          end
+          new(file, line)
         end
 
         def initialize(filepath, raw_lines=WILDCARD)
@@ -63,9 +79,6 @@ module Cucumber
           attr_reader :line
 
           def initialize(raw_data)
-            if Cucumber::JRUBY && raw_data.is_a?(::Java::GherkinFormatterModel::Range)
-              raw_data = Range.new(raw_data.first, raw_data.last)
-            end
             super Array(raw_data).to_set
             @line = data.first
           end

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

@@ -10,15 +10,14 @@ module Cucumber
         include HasLocation
         include DescribesItself
 
-        attr_reader :gherkin_statement, :language, :location, :comments, :keyword, :name, :multiline_arg
+        attr_reader :language, :location, :comments, :keyword, :name, :multiline_arg
 
-        def initialize(gherkin_statement, language, location, comments, keyword, name, multiline_arg)
-          @gherkin_statement, @language, @location, @comments, @keyword, @name, @multiline_arg = gherkin_statement, language, location, comments, keyword, name, multiline_arg
-          @language || raise("Language is required!")
+        def initialize(language, location, comments, keyword, text, multiline_arg)
+          @language, @location, @comments, @keyword, @name, @multiline_arg = language, location, comments, keyword, text, multiline_arg
         end
 
         def to_step(row)
-          Ast::ExpandedOutlineStep.new(self, gherkin_statement, language, row.location, comments, keyword, row.expand(name), replace_multiline_arg(row))
+          Ast::ExpandedOutlineStep.new(self, language, row.location, comments, keyword, row.expand(name), replace_multiline_arg(row))
         end
 
         def inspect

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

@@ -11,23 +11,19 @@ module Cucumber
         include HasLocation
         include DescribesItself
 
-        attr_reader :gherkin_statement, :language, :location, :background,
-                    :comments, :tags, :feature_tags, :keyword,
+        attr_reader :location, :background,
+                    :comments, :tags, :keyword,
                     :description, :raw_steps
         private :raw_steps
 
-        def initialize(gherkin_statement, language, location, background, comments, tags, feature_tags, keyword, name, description, raw_steps)
-          @gherkin_statement = gherkin_statement
-          @language          = language
+        def initialize(location, comments, tags, keyword, name, description, steps)
           @location          = location
-          @background        = background
           @comments          = comments
           @tags              = tags
-          @feature_tags      = feature_tags
           @keyword           = keyword
           @name              = name
           @description       = description
-          @raw_steps         = raw_steps
+          @raw_steps         = steps
         end
 
         def children

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

@@ -1,6 +1,5 @@
 require 'cucumber/core/ast/names'
 require 'cucumber/core/ast/location'
-require 'cucumber/core/ast/empty_background'
 require 'cucumber/core/ast/describes_itself'
 
 module Cucumber
@@ -13,24 +12,19 @@ module Cucumber
 
         MissingExamples = Class.new(StandardError)
 
-        attr_reader :gherkin_statement, :language, :background, :comments,
-                    :tags, :feature_tags, :keyword,
+        attr_reader :comments, :tags, :keyword,
                     :steps, :examples_tables, :line
-        private :language, :background, :feature_tags, :line
+        private :line
 
-        def initialize(gherkin_statement, language, location, background, comments, tags, feature_tags, keyword, name, description, steps, examples_tables)
-          @gherkin_statement = gherkin_statement
-          @language          = language
+        def initialize(location, comments, tags, keyword, name, description, steps, examples)
           @location          = location
-          @background        = background
           @comments          = comments
           @tags              = tags
-          @feature_tags      = feature_tags
           @keyword           = keyword
           @name              = name
           @description       = description
           @steps             = steps
-          @examples_tables   = examples_tables
+          @examples_tables   = examples
         end
 
         private

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

@@ -8,10 +8,10 @@ module Cucumber
         include HasLocation
         include DescribesItself
 
-        attr_reader :keyword, :name, :language, :comments, :exception, :multiline_arg, :gherkin_statement
+        attr_reader :keyword, :name, :language, :comments, :exception, :multiline_arg
 
-        def initialize(gherkin_statement, language, location, comments, keyword, name, multiline_arg)
-          @gherkin_statement, @language, @location, @comments, @keyword, @name, @multiline_arg = gherkin_statement, language, location, comments, keyword, name, multiline_arg
+        def initialize(language, location, comments, keyword, name, multiline_arg)
+          @language, @location, @comments, @keyword, @name, @multiline_arg = language, location, comments, keyword, name, multiline_arg
         end
 
         def to_sexp
@@ -23,9 +23,9 @@ module Cucumber
         end
 
         def actual_keyword(previous_step_keyword = nil)
-          if [language.keywords('and'), language.keywords('but')].flatten.uniq.include? keyword
+          if [language.and_keywords, language.but_keywords].flatten.uniq.include? keyword
             if previous_step_keyword.nil?
-              language.keywords('given').reject{|kw| kw == '* '}[0]
+              language.given_keywords.reject{|kw| kw == '* '}[0]
             else
               previous_step_keyword
             end
@@ -52,14 +52,15 @@ module Cucumber
 
       class ExpandedOutlineStep < Step
 
-        def initialize(outline_step, gherkin_statement, language, location, comments, keyword, name, multiline_arg)
-          @outline_step, @gherkin_statement, @language, @location, @comments, @keyword, @name, @multiline_arg = outline_step, gherkin_statement, language, location, comments, keyword, name, multiline_arg
+        def initialize(outline_step, language, location, comments, keyword, name, multiline_arg)
+          @outline_step, @language, @location, @comments, @keyword, @name, @multiline_arg = outline_step, language, location, comments, keyword, name, multiline_arg
         end
 
         alias :self_match_locations? :match_locations?
 
         def match_locations?(queried_locations)
-          self_match_locations?(queried_locations) or @outline_step.match_locations?(queried_locations)
+          return true if self_match_locations?(queried_locations) 
+          @outline_step.match_locations?(queried_locations)
         end
 
         alias :step_backtrace_line :backtrace_line

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

@@ -1,6 +1,5 @@
 require 'cucumber/core/ast'
 require 'cucumber/core/platform'
-require 'gherkin/rubify'
 
 module Cucumber
   module Core
@@ -9,339 +8,364 @@ module Cucumber
       # Gherkin parser.
       class AstBuilder
 
-        def initialize(path)
-          @path = path
-          @feature_builder = nil
+        def initialize(uri)
+          @uri = uri
         end
 
-        def result
-          return Ast::NullFeature.new unless @feature_builder
-          @feature_builder.result(language)
-        end
-
-        def language=(language)
-          @language = language
-        end
-
-        def uri(uri)
-          @path = uri
-        end
-
-        def feature(node)
-          @feature_builder = FeatureBuilder.new(file, node)
-        end
-
-        def background(node)
-          builder = BackgroundBuilder.new(file, node)
-          @feature_builder.background_builder = builder
-          @current = builder
-        end
-
-        def scenario(node)
-          builder = ScenarioBuilder.new(file, node)
-          @feature_builder.add_child builder
-          @current = builder
-        end
-
-        def scenario_outline(node)
-          builder = ScenarioOutlineBuilder.new(file, node)
-          @feature_builder.add_child builder
-          @current = builder
-        end
-
-        def examples(node)
-          @current.add_examples file, node
-        end
-
-        def step(node)
-          @current.add_step file, node
-        end
-
-        def eof
-        end
-
-        def syntax_error(state, event, legal_events, line)
-          # raise "SYNTAX ERROR"
+        def feature(attributes)
+          FeatureBuilder.new(file, attributes).result
         end
 
         private
 
-        def language
-          @language || raise("Language has not been set")
-        end
-
         def file
-          @path
+          @uri
         end
 
         class Builder
-          attr_reader :file, :node
-          private     :file, :node
+          attr_reader :file, :attributes, :comments, :line
+          private     :file, :attributes, :comments, :line
 
-          def initialize(file, node)
+          def initialize(file, attributes)
             @file = file
-            @node = node
+            @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
-            node.tags.map do |tag|
+            attributes[:tags].map do |tag|
               Ast::Tag.new(
-                Ast::Location.new(file, tag.line),
-                tag.name)
+                Ast::Location.new(file, tag[:location][:line]),
+                tag[:name])
             end
           end
 
           def location
-            Ast::Location.new(file, node.line)
+            Ast::Location.new(file, attributes[:location][:line])
           end
 
-          def comments
-            node.comments.map do |comment|
-              Ast::Comment.new(
-                Ast::Location.new(file, comment.line), 
-                comment.value
-              )
+          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 FeatureBuilder < Builder
-          attr_accessor :background_builder
-          private :background_builder
+          attr_reader :language, :background_builder, :scenario_definition_builders
 
           def initialize(*)
             super
-            @background_builder = nil
+            @language = Ast::LanguageDelegator.new(attributes[:language], ::Gherkin3::Dialect.for(attributes[:language]))
+            @background_builder = BackgroundBuilder.new(file, attributes[:background]) if attributes[:background]
+            @scenario_definition_builders = attributes[:scenario_definitions].map do |sd|
+              sd[:type] == :Scenario ? ScenarioBuilder.new(file, sd) : ScenarioOutlineBuilder.new(file, sd)
+            end
           end
 
-          def result(language)
-            background = background(language)
+          def result
+            handle_comments(all_comments)
             Ast::Feature.new(
-              node,
               language,
               location,
               background,
               comments,
               tags,
-              node.keyword,
-              node.name.lstrip,
-              node.description.rstrip,
-              children.map { |builder| builder.result(background, language, tags) }
+              keyword,
+              name,
+              description,
+              scenario_definitions
             )
           end
 
-          def add_child(child)
-            children << child
+          private
+
+          def background
+            return Ast::EmptyBackground.new unless background_builder
+            background_builder.result(language)
           end
 
-          def children
-            @children ||= []
+          def scenario_definitions
+            scenario_definition_builders.map { |builder| builder.result(language) }
           end
 
-          private
+          def all_comments
+            attributes[:comments].map do |comment|
+              Ast::Comment.new(
+                Ast::Location.new(file, comment[:location][:line]),
+                comment[:text]
+              )
+            end
+          end
 
-          def background(language)
-            return Ast::EmptyBackground.new unless background_builder
-            @background ||= background_builder.result(language)
+          def children
+            (background_builder ? [background_builder] : []) + scenario_definition_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(
-              node,
-              language,
               location,
               comments,
-              node.keyword,
-              node.name,
-              node.description,
+              keyword,
+              name,
+              description,
               steps(language)
             )
           end
 
-          def add_step(file, node)
-            step_builders << ScenarioBuilder::StepBuilder.new(file, node)
-          end
-
-          private
-
           def steps(language)
-            step_builders.map { |step_builder| step_builder.result(language) }
+            step_builders.map { |builder| builder.result(language) }
           end
 
-          def step_builders
-            @step_builders ||= []
+          def children
+            step_builders
           end
-
         end
 
         class ScenarioBuilder < Builder
-          def result(background, language, feature_tags)
+          attr_reader :step_builders
+
+          def initialize(*)
+            super
+            @step_builders = attributes[:steps].map { |step| StepBuilder.new(file, step) }
+          end
+
+          def result(language)
             Ast::Scenario.new(
-              node,
-              language,
               location,
-              background,
               comments,
               tags,
-              feature_tags,
-              node.keyword,
-              node.name,
-              node.description,
+              keyword,
+              name,
+              description,
               steps(language)
             )
           end
 
-          def add_step(file, node)
-            step_builders << StepBuilder.new(file, node)
+          def steps(language)
+            step_builders.map { |builder| builder.result(language) }
           end
 
-          private
+          def children
+            step_builders
+          end
+        end
 
-          def steps(language)
-            step_builders.map { |step_builder| step_builder.result(language) }
+        class StepBuilder < Builder
+          attr_reader :multiline_argument_builder
+
+          def initialize(*)
+            super
+            @multiline_argument_builder = attributes[:argument] ? argument_builder(attributes[:argument]) : nil
           end
 
-          def step_builders
-            @step_builders ||= []
+          def result(language)
+            Ast::Step.new(
+              language,
+              location,
+              comments,
+              keyword,
+              attributes[:text],
+              multiline_argument
+            )
           end
 
-          class StepBuilder < Builder
-            def result(language)
-              Ast::Step.new(
-                node,
-                language,
-                location,
-                comments,
-                node.keyword,
-                node.name,
-                
-                MultilineArgument.from(node.doc_string || node.rows, location)
-              )
-            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
-          def result(background, language, feature_tags)
-            raise ParseError.new("Missing Examples section for Scenario Outline at #{location}") if examples_builders.empty?
+          attr_reader :step_builders, :example_builders
+
+          def initialize(*)
+            super
+            @step_builders = attributes[:steps].map { |step| OutlineStepBuilder.new(file, step) }
+            @example_builders = attributes[:examples].map { |example| ExamplesTableBuilder.new(file, example) }
+          end
+
+          def result(language)
             Ast::ScenarioOutline.new(
-              node,
-              language,
               location,
-              background,
               comments,
               tags,
-              feature_tags,
-              node.keyword,
-              node.name,
-              node.description,
+              keyword,
+              name,
+              description,
               steps(language),
-              examples_tables(language)
+              examples(language)
             )
           end
 
-          def add_examples(file, node)
-            examples_builders << ExamplesTableBuilder.new(file, node)
+          def steps(language)
+            step_builders.map { |builder| builder.result(language) }
           end
 
-          def add_step(file, node)
-            step_builders << StepBuilder.new(file, node)
+          def examples(language)
+            example_builders.map { |builder| builder.result(language) }
           end
 
-          private
-
-          def steps(language)
-            step_builders.map { |step_builder| step_builder.result(language) }
+          def children
+            step_builders + example_builders
           end
+        end
 
-          def step_builders
-            @step_builders ||= []
-          end
+        class ExamplesTableBuilder < Builder
+          attr_reader :header_builder, :example_rows_builders
 
-          def examples_tables(language)
-            examples_builders.map { |examples_builder| examples_builder.result(language) }
+          def initialize(*)
+            super
+            @header_builder = HeaderBuilder.new(file, attributes[:table_header])
+            @example_rows_builders = attributes[:table_body].map do |row_attributes|
+              ExampleRowBuilder.new(file, row_attributes)
+            end
           end
 
-          def examples_builders
-            @examples_builders ||= []
+          def result(language)
+            Ast::Examples.new(
+              location,
+              comments,
+              tags,
+              keyword,
+              name,
+              description,
+              header,
+              example_rows(language)
+            )
           end
 
-          class ExamplesTableBuilder < Builder
+          private
 
-            def result(language)
-              Ast::ExamplesTable.new(
-                node,
-                location,
-                comments,
-                tags,
-                node.keyword,
-                node.name,
-                node.description,
-                header,
-                example_rows(language)
-              )
-            end
+          def header
+            @header = header_builder.result
+          end
 
-            private
+          def example_rows(language)
+            example_rows_builders.each.with_index.map { |builder, index| builder.result(language, header, index) }
+          end
 
-            def header
-              row = node.rows[0]
-              Ast::ExamplesTable::Header.new(row.cells, location, row_comments(row))
+          class HeaderBuilder < Builder
+            def result
+              cells = attributes[:cells].map { |c| c[:value] }
+              Ast::ExamplesTable::Header.new(cells, location, comments)
             end
+          end
 
-            def example_rows(language)
-              _, *raw_examples = *node.rows
-              raw_examples.each_with_index.map do |row, index|
-                header.build_row(row.cells, index + 1, location.on_line(row.line), language, row_comments(row))
-              end
-            end
+          def children
+            [header_builder] + example_rows_builders
+          end
 
-            def row_comments(row)
-              row.comments.map do |comment|
-                Ast::Comment.new(
-                  Ast::Location.new(file, comment.line), 
-                  comment.value
-                )
-              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 StepBuilder < Builder
-            def result(language)
-              Ast::OutlineStep.new(
-                node,
-                language,
-                location,
-                comments,
-                node.keyword,
-                node.name,
-                MultilineArgument.from(node.doc_string || node.rows, location)
-              )
-            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
         end
 
-        module MultilineArgument
-          class << self
-            include ::Gherkin::Rubify
-
-            def from(argument, parent_location)
-              return Ast::EmptyMultilineArgument.new unless argument
-              argument = rubify(argument)
-              case argument
-              when ::Gherkin::Formatter::Model::DocString
-                Ast::DocString.new(argument.value, argument.content_type, parent_location.on_line(argument.line_range))
-              when Array
-                location = parent_location.on_line(argument.first.line..argument.last.line)
-                Ast::DataTable.new(argument.map{|row| row.cells}, location)
-              else
-                raise ArgumentError, "Don't know how to convert #{argument.inspect} into a MultilineArgument"
-              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