cuke_modeler 2.1.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e45af46cbcc095433e4bf40fd868daed964bbbc53dac06d3d3de6ca6a4c2db1
-  data.tar.gz: 36e8660c3f4e993732113f79979168ac59b1bd33c35e8722fc06abdf4e54ce85
+  metadata.gz: 12a7bac33e0fe407f250239e15637b732497d9d106893ae9d08943bb2497821c
+  data.tar.gz: 26e6cf550dfdec1f87109651d73c01f403a97235277497ea7dc09017448a9a7c
 SHA512:
-  metadata.gz: 39109727b23ffbed1015bc7d690367a10c8f8a88e12d099ba973fcd722cfc5fd0f15e9c5dfeef4a61793850b75a46feb9933f1bba66845cb7ccd72c323d26c36
-  data.tar.gz: 11848c5307c7da2a0669e80dfef83cf535ba1259e3c04d05897b12ab5057760419f239ff7eaaebbc37fec33e7610cc11c771f81128d05f7a779794ad70770978
+  metadata.gz: 129e84d0e7d10a7b217c040d7f6cab3590096e76345f679f61a51b3833c0c771fbb2299d997fd319851042d4a40bb2990310112d7fa8836d260ff91107d760cd
+  data.tar.gz: 7dd7f4ebd77a9c9b898f4f07fcd33fe1e9216205b9d745ce7da5cff54dc6ba5febe6ed129594287d2c006165ef08a9717c88710b5cae346d15fe98c3e90844fe

data/CHANGELOG.md

@@ -8,6 +8,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 Nothing yet...
 
+## [3.0.0] - 2020-06-08
+
+### Changed
+ - This gem now wraps the `cucumber-gherkin` gem instead of the `gherkin` gem, now that `cucumber-gherkin` has superseded `gherkin`.
+ - Support for versions of Ruby earlier than 2.3 has been dropped due to that being the minimum required version of Ruby required by the `cucumber-gherkin` gem.
+ - When using the parsing functionality provided by this gem, the standardized AST returned when parsing Gherkin text is now returned directly as a Hash instead of also being wrapped in an array. The array was an artifact of basing the AST on the earliest versions of `gherkin` that were supported.
+ - No longer including every file in the Git repository as part of the gem. Only the files needed for using the gem (and the informative ones like the README) will be packaged into the released gem.
+
+### Added
+ - Support added for more versions of the `cucumber-gherkin` gem
+   - 13.x
+   - 12.x
+   - 11.x
+   - 10.x
+   - 9.x
+
 ## [2.1.0] - 2020-05-27
 
 ### Added
@@ -287,7 +303,8 @@ Nothing yet...
  - Initial release
 
 
-[Unreleased]: https://github.com/enkessler/cuke_modeler/compare/v2.1.0...HEAD
+[Unreleased]: https://github.com/enkessler/cuke_modeler/compare/v3.0.0...HEAD
+[3.0.0]: https://github.com/enkessler/cuke_modeler/compare/v2.1.0...v3.0.0
 [2.1.0]: https://github.com/enkessler/cuke_modeler/compare/v2.0.0...v2.1.0
 [2.0.0]: https://github.com/enkessler/cuke_modeler/compare/v1.5.1...v2.0.0
 [1.5.1]: https://github.com/enkessler/cuke_modeler/compare/v1.5.0...v1.5.1

data/README.md

@@ -8,11 +8,11 @@ User stuff:
 [![Yard Docs](http://img.shields.io/badge/Documentation-API-blue.svg)](https://www.rubydoc.info/gems/cuke_modeler)
 
 Developer stuff:
-[![Build Status](https://travis-ci.org/enkessler/cuke_modeler.svg?branch=dev)](https://travis-ci.org/enkessler/cuke_modeler)
-[![Build status](https://ci.appveyor.com/api/projects/status/is8xqvoqn3pjh9l0/branch/dev?svg=true)](https://ci.appveyor.com/project/enkessler/cuke-modeler/branch/dev)
-[![Coverage Status](https://coveralls.io/repos/github/enkessler/cuke_modeler/badge.svg?branch=dev)](https://coveralls.io/github/enkessler/cuke_modeler?branch=dev)
+[![Build Status](https://travis-ci.org/enkessler/cuke_modeler.svg)](https://travis-ci.org/enkessler/cuke_modeler)
+[![Build status](https://ci.appveyor.com/api/projects/status/is8xqvoqn3pjh9l0?svg=true)](https://ci.appveyor.com/project/enkessler/cuke-modeler)
+[![Coverage Status](https://coveralls.io/repos/github/enkessler/cuke_modeler/badge.svg)](https://coveralls.io/github/enkessler/cuke_modeler)
 [![Maintainability](https://api.codeclimate.com/v1/badges/83986d8f7a918fed9707/maintainability)](https://codeclimate.com/github/enkessler/cuke_modeler/maintainability)
-[![Inline docs](http://inch-ci.org/github/enkessler/cuke_modeler.svg?branch=dev)](https://inch-ci.org/github/enkessler/cuke_modeler?branch=dev)
+[![Inline docs](http://inch-ci.org/github/enkessler/cuke_modeler.svg)](https://inch-ci.org/github/enkessler/cuke_modeler)
 
 ---
 
@@ -21,7 +21,7 @@ Developer stuff:
 There comes a time in every programmer's adventures with Cucumber when they 
 want to do Really Cool Stuff with their tests. This usually necessitates 
 scanning all of their feature files and playing with the output. While the 
-**[gherkin](https://github.com/cucumber/gherkin)** gem does a fine job of parsing feature files, reading or even manipulating 
+**[cucumber-gherkin](https://github.com/cucumber/cucumber/tree/master/gherkin)** gem does a fine job of parsing feature files, reading or even manipulating 
 the resulting Abstract Syntax Tree is not always fun. **cuke_modeler** comes to 
 the rescue by providing a modeling layer that is easier to work with.
  
@@ -126,13 +126,10 @@ that feature is ultimately run with SpecFlow (Cucumber for C#), Lettuce
   * [cuke_linter](https://github.com/enkessler/cuke_linter)
 
 
-## Contributing
+## Development and Contributing
 
-1. Fork it
-2. Create your feature branch (**off of the development branch**)
-   `git checkout -b my-new-feature`
-3. Commit your changes
-   `git commit -am 'Add some feature'`
-4. Push to the branch
-   `git push origin my-new-feature`
-5. Create new Pull Request
+See [CONTRIBUTING.md](https://github.com/enkessler/cuke_modeler/blob/master/CONTRIBUTING.md)
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/cuke_modeler.gemspec

@@ -9,27 +9,30 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Eric Kessler"]
   spec.email         = ["morrow748@gmail.com"]
   spec.summary       = %q{A gem providing functionality to model Gherkin based test suites.}
-  spec.description   = %q{This gem facilitates modeling a test suite that is written in Gherkin (e.g. Cucumber, SpecFlow, Lettuce, etc.). It does this by providing an abstraction layer on top of the Abstract Syntax Tree that the 'gherkin' gem generates when parsing features, as well as providing models for feature files and directories in order to be able to have a fully traversable model tree of a test suite's structure. These models can then be analyzed or manipulated more easily than the underlying AST layer.}
+  spec.description   = %q{This gem facilitates modeling a test suite that is written in Gherkin (e.g. Cucumber, SpecFlow, Lettuce, etc.). It does this by providing an abstraction layer on top of the Abstract Syntax Tree that the 'cucumber-gherkin' gem generates when parsing features, as well as providing models for feature files and directories in order to be able to have a fully traversable model tree of a test suite's structure. These models can then be analyzed or manipulated more easily than the underlying AST layer.}
   spec.homepage      = 'https://github.com/enkessler/cuke_modeler'
   spec.license       = "MIT"
 
-  spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path('', __dir__)) do
+    source_controlled_files = `git ls-files -z`.split("\x0")
+    source_controlled_files.keep_if { |file| file =~ %r{^(lib|testing/cucumber/features)} }
+    source_controlled_files + ['README.md', 'LICENSE.txt', 'CHANGELOG.md', 'cuke_modeler.gemspec']
+  end
   spec.require_paths = ["lib"]
 
-  spec.required_ruby_version = '>= 1.8.7', '< 3.0'
+  spec.required_ruby_version = '>= 2.3', '< 3.0'
 
-  spec.add_runtime_dependency 'gherkin', '< 10.0'
-  spec.add_runtime_dependency('json', '>= 1.0', '< 3.0')
-  spec.add_runtime_dependency('multi_json', '~> 1.0')
+  spec.add_runtime_dependency 'cucumber-gherkin', '< 14.0'
 
   spec.add_development_dependency 'bundler', '< 3.0'
   spec.add_development_dependency "rake", '< 13.0.0'
   spec.add_development_dependency 'cucumber', '< 5.0.0'
   spec.add_development_dependency 'rspec', '~> 3.0'
-  spec.add_development_dependency 'simplecov', '< 1.0.0'
+  spec.add_development_dependency 'simplecov', '<= 0.16.1'
   spec.add_development_dependency 'racatt', '~> 1.0'
   spec.add_development_dependency 'coveralls', '< 1.0.0'
   spec.add_development_dependency 'rainbow', '< 4.0.0'
+  spec.add_development_dependency 'test-unit', '< 4.0.0'
 end

data/lib/cuke_modeler/adapters/gherkin_10_adapter.rb

@@ -0,0 +1,12 @@
+require_relative 'gherkin_9_adapter'
+
+
+module CukeModeler
+
+  # NOT A PART OF THE PUBLIC API
+  # An adapter that can convert the output of version 10.x of the *cucumber-gherkin* gem into input that is consumable by this gem.
+
+  class Gherkin10Adapter < Gherkin9Adapter
+
+  end
+end

data/lib/cuke_modeler/adapters/gherkin_11_adapter.rb

@@ -0,0 +1,12 @@
+require_relative 'gherkin_9_adapter'
+
+
+module CukeModeler
+
+  # NOT A PART OF THE PUBLIC API
+  # An adapter that can convert the output of version 11.x of the *cucumber-gherkin* gem into input that is consumable by this gem.
+
+  class Gherkin11Adapter < Gherkin9Adapter
+
+  end
+end

data/lib/cuke_modeler/adapters/gherkin_12_adapter.rb

@@ -0,0 +1,12 @@
+require_relative 'gherkin_9_adapter'
+
+
+module CukeModeler
+
+  # NOT A PART OF THE PUBLIC API
+  # An adapter that can convert the output of version 12.x of the *cucumber-gherkin* gem into input that is consumable by this gem.
+
+  class Gherkin12Adapter < Gherkin9Adapter
+
+  end
+end

data/lib/cuke_modeler/adapters/gherkin_13_adapter.rb

@@ -0,0 +1,12 @@
+require_relative 'gherkin_9_adapter'
+
+
+module CukeModeler
+
+  # NOT A PART OF THE PUBLIC API
+  # An adapter that can convert the output of version 13.x of the *cucumber-gherkin* gem into input that is consumable by this gem.
+
+  class Gherkin13Adapter < Gherkin9Adapter
+
+  end
+end

data/lib/cuke_modeler/adapters/gherkin_9_adapter.rb

@@ -1,12 +1,320 @@
-require_relative 'gherkin_7_adapter'
-
 module CukeModeler
 
   # NOT A PART OF THE PUBLIC API
-  # An adapter that can convert the output of version 9.x of the *gherkin* gem into input that is consumable by this gem.
+  # An adapter that can convert the output of version 9.x of the *cucumber-gherkin* gem into input that is consumable by this gem.
 
-  class Gherkin9Adapter < Gherkin7Adapter
+  class Gherkin9Adapter
 
-  end
+    # Adapts the given AST into the shape that this gem expects
+    def adapt(parsed_ast)
+      # Saving off the original data
+      parsed_ast['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_ast))
+
+      # Removing parsed data for child elements in order to avoid duplicating data
+      parsed_ast['cuke_modeler_parsing_data'][:feature] = nil if parsed_ast['cuke_modeler_parsing_data'][:feature]
+      parsed_ast['cuke_modeler_parsing_data'][:comments] = nil if parsed_ast['cuke_modeler_parsing_data'][:comments]
+
+      parsed_ast['comments'] = []
+      if parsed_ast[:comments]
+        parsed_ast[:comments].each do |comment|
+          adapt_comment!(comment)
+        end
+        parsed_ast['comments'].concat(parsed_ast.delete(:comments))
+      end
+
+      adapt_feature!(parsed_ast[:feature]) if parsed_ast[:feature]
+      parsed_ast['feature'] = parsed_ast.delete(:feature)
+
+      parsed_ast
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given feature node.
+    def adapt_feature!(parsed_feature)
+      # Saving off the original data
+      parsed_feature['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_feature))
+
+      # Removing parsed data for child elements in order to avoid duplicating data
+      parsed_feature['cuke_modeler_parsing_data'][:tags] = nil if parsed_feature['cuke_modeler_parsing_data'][:tags]
+      parsed_feature['cuke_modeler_parsing_data'][:children] = nil if parsed_feature['cuke_modeler_parsing_data'][:children]
+
+      parsed_feature['keyword'] = parsed_feature.delete(:keyword)
+      parsed_feature['name'] = parsed_feature.delete(:name)
+      parsed_feature['description'] = parsed_feature.delete(:description) || ''
+      parsed_feature['line'] = parsed_feature.delete(:location)[:line]
+
+      parsed_feature['elements'] = []
+      if parsed_feature[:children]
+        adapt_child_elements!(parsed_feature[:children])
+        parsed_feature['elements'].concat(parsed_feature.delete(:children))
+      end
+
+      parsed_feature['tags'] = []
+      if parsed_feature[:tags]
+        parsed_feature[:tags].each do |tag|
+          adapt_tag!(tag)
+        end
+        parsed_feature['tags'].concat(parsed_feature.delete(:tags))
+      end
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given background node.
+    def adapt_background!(parsed_background)
+      # Saving off the original data
+      parsed_background['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_background))
+
+      # Removing parsed data for child elements in order to avoid duplicating data
+      parsed_background['cuke_modeler_parsing_data'][:background][:steps] = nil if parsed_background['cuke_modeler_parsing_data'][:background][:steps]
+
+      parsed_background['type'] = 'Background'
+      parsed_background['keyword'] = parsed_background[:background].delete(:keyword)
+      parsed_background['name'] = parsed_background[:background].delete(:name)
+      parsed_background['description'] = parsed_background[:background].delete(:description) || ''
+      parsed_background['line'] = parsed_background[:background].delete(:location)[:line]
+
+      parsed_background['steps'] = []
+      if parsed_background[:background][:steps]
+        parsed_background[:background][:steps].each do |step|
+          adapt_step!(step)
+        end
+        parsed_background['steps'].concat(parsed_background[:background].delete(:steps))
+      end
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given scenario node.
+    def adapt_scenario!(parsed_test)
+      # Removing parsed data for child elements in order to avoid duplicating data
+      parsed_test['cuke_modeler_parsing_data'][:scenario][:tags] = nil if parsed_test['cuke_modeler_parsing_data'][:scenario][:tags]
+      parsed_test['cuke_modeler_parsing_data'][:scenario][:steps] = nil if parsed_test['cuke_modeler_parsing_data'][:scenario][:steps]
+
+      parsed_test['type'] = 'Scenario'
+      parsed_test['keyword'] = parsed_test[:scenario].delete(:keyword)
+      parsed_test['name'] = parsed_test[:scenario].delete(:name)
+      parsed_test['description'] = parsed_test[:scenario].delete(:description) || ''
+      parsed_test['line'] = parsed_test[:scenario].delete(:location)[:line]
+
+      parsed_test['tags'] = []
+      if parsed_test[:scenario][:tags]
+        parsed_test[:scenario][:tags].each do |tag|
+          adapt_tag!(tag)
+        end
+        parsed_test['tags'].concat(parsed_test[:scenario].delete(:tags))
+      end
+
+      parsed_test['steps'] = []
+      if parsed_test[:scenario][:steps]
+        parsed_test[:scenario][:steps].each do |step|
+          adapt_step!(step)
+        end
+        parsed_test['steps'].concat(parsed_test[:scenario].delete(:steps))
+      end
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given outline node.
+    def adapt_outline!(parsed_test)
+      # Removing parsed data for child elements in order to avoid duplicating data
+      parsed_test['cuke_modeler_parsing_data'][:scenario][:tags] = nil if parsed_test['cuke_modeler_parsing_data'][:scenario][:tags]
+      parsed_test['cuke_modeler_parsing_data'][:scenario][:steps] = nil if parsed_test['cuke_modeler_parsing_data'][:scenario][:steps]
+      parsed_test['cuke_modeler_parsing_data'][:scenario][:examples] = nil if parsed_test['cuke_modeler_parsing_data'][:scenario][:examples]
+
+      parsed_test['type'] = 'ScenarioOutline'
+      parsed_test['keyword'] = parsed_test[:scenario].delete(:keyword)
+      parsed_test['name'] = parsed_test[:scenario].delete(:name)
+      parsed_test['description'] = parsed_test[:scenario].delete(:description) || ''
+      parsed_test['line'] = parsed_test[:scenario].delete(:location)[:line]
+
+      parsed_test['tags'] = []
+      if parsed_test[:scenario][:tags]
+        parsed_test[:scenario][:tags].each do |tag|
+          adapt_tag!(tag)
+        end
+        parsed_test['tags'].concat(parsed_test[:scenario].delete(:tags))
+      end
+
+      parsed_test['steps'] = []
+      if parsed_test[:scenario][:steps]
+        parsed_test[:scenario][:steps].each do |step|
+          adapt_step!(step)
+        end
+        parsed_test['steps'].concat(parsed_test[:scenario].delete(:steps))
+      end
+
+      parsed_test['examples'] = []
+      if parsed_test[:scenario][:examples]
+        parsed_test[:scenario][:examples].each do |step|
+          adapt_example!(step)
+        end
+        parsed_test['examples'].concat(parsed_test[:scenario].delete(:examples))
+      end
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given example node.
+    def adapt_example!(parsed_example)
+      # Saving off the original data
+      parsed_example['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_example))
+
+      # Removing parsed data for child elements in order to avoid duplicating data
+      parsed_example['cuke_modeler_parsing_data'][:tags] = nil if parsed_example['cuke_modeler_parsing_data'][:tags]
+      parsed_example['cuke_modeler_parsing_data'][:table_header] = nil if parsed_example['cuke_modeler_parsing_data'][:table_header]
+      parsed_example['cuke_modeler_parsing_data'][:table_body] = nil if parsed_example['cuke_modeler_parsing_data'][:table_body]
+
+      parsed_example['keyword'] = parsed_example.delete(:keyword)
+      parsed_example['name'] = parsed_example.delete(:name)
+      parsed_example['line'] = parsed_example.delete(:location)[:line]
+      parsed_example['description'] = parsed_example.delete(:description) || ''
+
+      parsed_example['rows'] = []
+
+      if parsed_example[:table_header]
+        adapt_table_row!(parsed_example[:table_header])
+        parsed_example['rows'] << parsed_example.delete(:table_header)
+      end
+
+      if parsed_example[:table_body]
+        parsed_example[:table_body].each do |row|
+          adapt_table_row!(row)
+        end
+        parsed_example['rows'].concat(parsed_example.delete(:table_body))
+      end
+
+      parsed_example['tags'] = []
+      if parsed_example[:tags]
+        parsed_example[:tags].each do |tag|
+          adapt_tag!(tag)
+        end
+        parsed_example['tags'].concat(parsed_example.delete(:tags))
+      end
+    end
 
+    # Adapts the AST sub-tree that is rooted at the given tag node.
+    def adapt_tag!(parsed_tag)
+      # Saving off the original data
+      parsed_tag['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_tag))
+
+      parsed_tag['name'] = parsed_tag.delete(:name)
+      parsed_tag['line'] = parsed_tag.delete(:location)[:line]
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given comment node.
+    def adapt_comment!(parsed_comment)
+      # Saving off the original data
+      parsed_comment['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_comment))
+
+      parsed_comment['text'] = parsed_comment.delete(:text)
+      parsed_comment['line'] = parsed_comment.delete(:location)[:line]
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given step node.
+    def adapt_step!(parsed_step)
+      # Saving off the original data
+      parsed_step['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_step))
+
+      # Removing parsed data for child elements in order to avoid duplicating data
+      parsed_step['cuke_modeler_parsing_data'][:data_table] = nil if parsed_step['cuke_modeler_parsing_data'][:data_table]
+      parsed_step['cuke_modeler_parsing_data'][:doc_string] = nil if parsed_step['cuke_modeler_parsing_data'][:doc_string]
+
+      parsed_step['keyword'] = parsed_step.delete(:keyword)
+      parsed_step['name'] = parsed_step.delete(:text)
+      parsed_step['line'] = parsed_step.delete(:location)[:line]
+
+      case
+        when parsed_step[:doc_string]
+          adapt_doc_string!(parsed_step[:doc_string])
+          parsed_step['doc_string'] = parsed_step.delete(:doc_string)
+        when parsed_step[:data_table]
+          adapt_step_table!(parsed_step[:data_table])
+          parsed_step['table'] = parsed_step.delete(:data_table)
+        else
+          # Step has no extra argument
+      end
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given doc string node.
+    def adapt_doc_string!(parsed_doc_string)
+      # Saving off the original data
+      parsed_doc_string['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_doc_string))
+
+      parsed_doc_string['value'] = parsed_doc_string.delete(:content)
+      parsed_doc_string['content_type'] = parsed_doc_string.delete(:media_type)
+      parsed_doc_string['line'] = parsed_doc_string.delete(:location)[:line]
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given table node.
+    def adapt_step_table!(parsed_step_table)
+      # Saving off the original data
+      parsed_step_table['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_step_table))
+
+      # Removing parsed data for child elements in order to avoid duplicating data
+      parsed_step_table['cuke_modeler_parsing_data'][:rows] = nil
+
+      parsed_step_table['rows'] = []
+      parsed_step_table[:rows].each do |row|
+        adapt_table_row!(row)
+      end
+      parsed_step_table['rows'].concat(parsed_step_table.delete(:rows))
+      parsed_step_table['line'] = parsed_step_table.delete(:location)[:line]
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given row node.
+    def adapt_table_row!(parsed_table_row)
+      # Saving off the original data
+      parsed_table_row['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_table_row))
+
+      # Removing parsed data for child elements in order to avoid duplicating data which the child elements will themselves include
+      parsed_table_row['cuke_modeler_parsing_data'][:cells] = nil
+
+      parsed_table_row['line'] = parsed_table_row.delete(:location)[:line]
+
+      parsed_table_row['cells'] = []
+      parsed_table_row[:cells].each do |row|
+        adapt_table_cell!(row)
+      end
+      parsed_table_row['cells'].concat(parsed_table_row.delete(:cells))
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given cell node.
+    def adapt_table_cell!(parsed_cell)
+      # Saving off the original data
+      parsed_cell['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_cell))
+
+      parsed_cell['value'] = parsed_cell.delete(:value)
+      parsed_cell['line'] = parsed_cell.delete(:location)[:line]
+    end
+
+
+    private
+
+
+    def adapt_child_elements!(parsed_children)
+      background_child = parsed_children.find { |child| child[:background] }
+
+      if background_child
+        adapt_background!(background_child)
+
+        remaining_children = parsed_children.reject { |child| child[:background] }
+      end
+
+      adapt_tests!(remaining_children || parsed_children)
+    end
+
+    def adapt_tests!(parsed_tests)
+      parsed_tests.each do |test|
+        adapt_test!(test)
+      end
+    end
+
+    def adapt_test!(parsed_test)
+      # Saving off the original data
+      parsed_test['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_test))
+
+      case
+        when (parsed_test[:scenario] && parsed_test[:scenario][:examples]) || (parsed_test[:scenario] && Parsing.dialects[Parsing.dialect]['scenarioOutline'].include?(parsed_test[:scenario][:keyword]))
+          adapt_outline!(parsed_test)
+        when parsed_test[:scenario]
+          adapt_scenario!(parsed_test)
+        else
+          raise(ArgumentError, "Unknown test type with keys: #{parsed_test.keys}")
+      end
+    end
+
+  end
 end