cuke_modeler 1.3.0 → 2.1.0

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2014-2017 Eric Kessler, et al
+Copyright (c) 2014-2020 Eric Kessler, et al
 
 MIT License
 

data/README.md

@@ -1,11 +1,20 @@
+Basic stuff:
 [![Gem Version](https://badge.fury.io/rb/cuke_modeler.svg)](https://rubygems.org/gems/cuke_modeler)
-[![Dependency Status](https://gemnasium.com/enkessler/cuke_modeler.svg)](https://gemnasium.com/enkessler/cuke_modeler)
+[![Project License](https://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/licenses/mit-license.php)
+[![Downloads](https://img.shields.io/gem/dt/cuke_modeler.svg)](https://rubygems.org/gems/cuke_modeler)
+
+User stuff:
+[![Cucumber Docs](http://img.shields.io/badge/Documentation-Features-green.svg)](https://app.cucumber.pro/projects/cuke_modeler)
+[![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)
-[![Code Quality](https://codeclimate.com/github/enkessler/cuke_modeler/badges/gpa.svg)](https://codeclimate.com/github/enkessler/cuke_modeler)
-[![Project License](https://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/licenses/mit-license.php)
+[![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)
 
+---
 
 # CukeModeler
 
@@ -18,7 +27,7 @@ the rescue by providing a modeling layer that is easier to work with.
  
 Whether you just want something that will let you easily inspect your test 
 suite or you are looking for a foundation tool upon which to build something 
-Really Neat, this gem has you covered.
+[Really Neat](#projects), this gem has you covered.
 
 
 ## Installation
@@ -74,7 +83,7 @@ One could, if so inclined, use this method to dynamically edit or even create
 an entire test suite!
 
 For more information on the different models and how to use them, see the 
-[documentation](http://www.relishapp.com/enkessler/CukeModeler/docs).
+[documentation](https://app.cucumber.pro/projects/cuke_modeler).
 
 ## Modeling dialects other than English
 
@@ -108,18 +117,19 @@ that feature is ultimately run with SpecFlow (Cucumber for C#), Lettuce
 (Cucumber for Python), or some other flavor of Cucumber. 
 
 
-### Other gems that are (or soon will be) powered by **cuke_modeler**
+### <a id="projects"></a>Other gems that are powered by **cuke_modeler**
 
   * [cql](https://github.com/enkessler/cql)
   * [cuketagger](https://github.com/enkessler/cuketagger)
   * [cuke_cataloger](https://github.com/enkessler/cuke_cataloger)
   * [cuke_slicer](https://github.com/grange-insurance/cuke_slicer)
+  * [cuke_linter](https://github.com/enkessler/cuke_linter)
 
 
 ## Contributing
 
 1. Fork it
-2. Create your feature branch (off of the development branch)
+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'`

data/Rakefile

@@ -1,56 +1,73 @@
 require "bundler/gem_tasks"
+require 'rake'
+require 'racatt'
 require 'coveralls/rake/task'
+require 'rainbow'
 
-require 'racatt'
+
+Rainbow.enabled = true
+
+namespace 'racatt' do
+  Racatt.create_tasks
+end
 
 
 namespace 'cuke_modeler' do
 
+  desc 'Removes the current code coverage data'
   task :clear_coverage do
     code_coverage_directory = "#{File.dirname(__FILE__)}/coverage"
 
     FileUtils.remove_dir(code_coverage_directory, true)
   end
 
+  desc 'Check documentation with RDoc'
+  task :check_documentation do
+    output = `rdoc lib -C`
+    puts output
 
-  Racatt.create_tasks
-
-  # Redefining the task from 'racatt' in order to clear the code coverage results
-  task :test_everything => :clear_coverage
+    if output =~ /100.00% documented/
+      puts Rainbow('All code documented').green
+    else
+      raise Rainbow('Parts of the gem are undocumented').red
+    end
+  end
 
+  desc 'Run all of the tests'
+  task :test_everything => [:clear_coverage] do
+    rspec_args = '--tag ~@wip --pattern "testing/rspec/spec/**/*_spec.rb" --force-color'
 
-  # The task that CI will use
-  Coveralls::RakeTask.new
-  task :ci_build => [:smart_test, 'coveralls:push']
+    cucumber_version = Gem.loaded_specs['cucumber'].version.version
 
-  desc 'Test gem based on Ruby/dependency versions'
-  task :smart_test do |t, args|
-    rspec_args = '--tag ~@wip --pattern testing/rspec/spec/**/*_spec.rb'
-    cucumber_args = 'testing/cucumber/features -r testing/cucumber/support -r testing/cucumber/step_definitions -f progress -t ~@wip'
+    if cucumber_version =~ /^[123]\./
+      cucumber_args = 'testing/cucumber/features -r testing/cucumber/support -r testing/cucumber/step_definitions -f progress -t ~@wip --color'
+    else
+      cucumber_args = "testing/cucumber/features -r testing/cucumber/support -r testing/cucumber/step_definitions -f progress -t 'not @wip' --color"
+    end
 
-    Rake::Task['cuke_modeler:test_everything'].invoke(rspec_args, cucumber_args)
+    Rake::Task['racatt:test_everything'].invoke(rspec_args, cucumber_args)
   end
 
+  # creates coveralls:push task
+  Coveralls::RakeTask.new
 
-  # The task used to publish the current feature file documentation to Relish
-  desc 'Publish feature files to Relish'
-  task :publish_features do
-    # Get existing versions
-    this_dir = File.dirname(__FILE__)
-    output = `relish versions enkessler/CukeModeler`
-
-    # Add the current version if it doesn't exist
-    unless output =~ /#{Regexp.escape(CukeModeler::VERSION)}/
-      output = `relish versions:add enkessler/CukeModeler:#{CukeModeler::VERSION}`
-      puts output
+  desc 'The task that CI will run. Do not run locally.'
+  task :ci_build => ['cuke_modeler:test_everything', 'coveralls:push']
+
+  desc 'Check that things look good before trying to release'
+  task :prerelease_check do
+    begin
+      Rake::Task['cuke_modeler:test_everything'].invoke
+      Rake::Task['cuke_modeler:check_documentation'].invoke
+    rescue => e
+      puts Rainbow("Something isn't right!").red
+      raise e
     end
 
-    # Publish the features
-    output = `relish push enkessler/CukeModeler:#{CukeModeler::VERSION} path #{this_dir}/testing/cucumber`
-    puts output
+    puts Rainbow('All is well. :)').green
   end
 
 end
 
 
-task :default => 'cuke_modeler:smart_test'
+task :default => 'cuke_modeler:test_everything'

data/appveyor.yml

@@ -2,37 +2,77 @@ version: '1.0.{build}'
 
 environment:
   matrix:
-    - RUBY_VERSION: 193
+
+    # Gherkin 2.x does not appear to support 32-bit Ruby 2.x and it's not worth it to investigate if this is true or not
+    - RUBY_VERSION: 24-x64
       BUNDLE_GEMFILE: testing/gemfiles/gherkin2.gemfile
-      # AppVeyor does not have a 64-bit Ruby 1.9.3
-      # Gherkin 2.x does not appear to support 32-bit Ruby 2.x and it's not worth it to investigate if this is true or not
-    - RUBY_VERSION: 23-x64
+    - RUBY_VERSION: 25-x64
       BUNDLE_GEMFILE: testing/gemfiles/gherkin2.gemfile
 
-    - RUBY_VERSION: 193
+    - RUBY_VERSION: 24
+      BUNDLE_GEMFILE: testing/gemfiles/gherkin3.gemfile
+    - RUBY_VERSION: 24-x64
       BUNDLE_GEMFILE: testing/gemfiles/gherkin3.gemfile
-      # AppVeyor does not have a 64-bit Ruby 1.9.3
-    - RUBY_VERSION: 23
+    - RUBY_VERSION: 25
       BUNDLE_GEMFILE: testing/gemfiles/gherkin3.gemfile
-    - RUBY_VERSION: 23-x64
+    - RUBY_VERSION: 25-x64
       BUNDLE_GEMFILE: testing/gemfiles/gherkin3.gemfile
 
-    - RUBY_VERSION: 193
+    - RUBY_VERSION: 24
       BUNDLE_GEMFILE: testing/gemfiles/gherkin4.gemfile
-      # AppVeyor does not have a 64-bit Ruby 1.9.3
-    - RUBY_VERSION: 23
+    - RUBY_VERSION: 24-x64
       BUNDLE_GEMFILE: testing/gemfiles/gherkin4.gemfile
-    - RUBY_VERSION: 23-x64
+    - RUBY_VERSION: 25
+      BUNDLE_GEMFILE: testing/gemfiles/gherkin4.gemfile
+    - RUBY_VERSION: 25-x64
       BUNDLE_GEMFILE: testing/gemfiles/gherkin4.gemfile
 
-    - RUBY_VERSION: 193
+    - RUBY_VERSION: 24
+      BUNDLE_GEMFILE: testing/gemfiles/gherkin5.gemfile
+    - RUBY_VERSION: 24-x64
       BUNDLE_GEMFILE: testing/gemfiles/gherkin5.gemfile
-      # AppVeyor does not have a 64-bit Ruby 1.9.3
-    - RUBY_VERSION: 23
+    - RUBY_VERSION: 25
       BUNDLE_GEMFILE: testing/gemfiles/gherkin5.gemfile
-    - RUBY_VERSION: 23-x64
+    - RUBY_VERSION: 25-x64
       BUNDLE_GEMFILE: testing/gemfiles/gherkin5.gemfile
 
+      # Gherkin 6.x+ requires at least Ruby 2.2
+    - RUBY_VERSION: 24
+      BUNDLE_GEMFILE: testing/gemfiles/gherkin6.gemfile
+    - RUBY_VERSION: 24-x64
+      BUNDLE_GEMFILE: testing/gemfiles/gherkin6.gemfile
+    - RUBY_VERSION: 25
+      BUNDLE_GEMFILE: testing/gemfiles/gherkin6.gemfile
+    - RUBY_VERSION: 25-x64
+      BUNDLE_GEMFILE: testing/gemfiles/gherkin6.gemfile
+
+    - RUBY_VERSION: 24
+      BUNDLE_GEMFILE: testing/gemfiles/gherkin7.gemfile
+    - RUBY_VERSION: 24-x64
+      BUNDLE_GEMFILE: testing/gemfiles/gherkin7.gemfile
+    - RUBY_VERSION: 25
+      BUNDLE_GEMFILE: testing/gemfiles/gherkin7.gemfile
+    - RUBY_VERSION: 25-x64
+      BUNDLE_GEMFILE: testing/gemfiles/gherkin7.gemfile
+
+    - RUBY_VERSION: 24
+      BUNDLE_GEMFILE: testing/gemfiles/gherkin8.gemfile
+    - RUBY_VERSION: 24-x64
+      BUNDLE_GEMFILE: testing/gemfiles/gherkin8.gemfile
+    - RUBY_VERSION: 25
+      BUNDLE_GEMFILE: testing/gemfiles/gherkin8.gemfile
+    - RUBY_VERSION: 25-x64
+      BUNDLE_GEMFILE: testing/gemfiles/gherkin8.gemfile
+
+    - RUBY_VERSION: 24
+      BUNDLE_GEMFILE: testing/gemfiles/gherkin9.gemfile
+    - RUBY_VERSION: 24-x64
+      BUNDLE_GEMFILE: testing/gemfiles/gherkin9.gemfile
+    - RUBY_VERSION: 25
+      BUNDLE_GEMFILE: testing/gemfiles/gherkin9.gemfile
+    - RUBY_VERSION: 25-x64
+      BUNDLE_GEMFILE: testing/gemfiles/gherkin9.gemfile
+
 install:
   - set PATH=C:\Ruby%RUBY_VERSION%\bin;%PATH%
   - bundle install
@@ -45,4 +85,4 @@ before_test:
   - bundle -v
 
 test_script:
-  - bundle exec rake
+  - bundle exec rake cuke_modeler:ci_build

data/cuke_modeler.gemspec

@@ -18,15 +18,18 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency 'gherkin', '< 6.0'
+  spec.required_ruby_version = '>= 1.8.7', '< 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_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency 'bundler', '< 3.0'
   spec.add_development_dependency "rake", '< 13.0.0'
-  spec.add_development_dependency 'cucumber', '< 3.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 'racatt', '~> 1.0'
   spec.add_development_dependency 'coveralls', '< 1.0.0'
+  spec.add_development_dependency 'rainbow', '< 4.0.0'
 end

data/lib/cuke_modeler/adapters/gherkin_2_adapter.rb

@@ -1,5 +1,6 @@
 module CukeModeler
 
+  # NOT A PART OF THE PUBLIC API
   # An adapter that can convert the output of version 2.x of the *gherkin* gem into input that is consumable by this gem.
 
   class Gherkin2Adapter

data/lib/cuke_modeler/adapters/gherkin_3_adapter.rb

@@ -1,5 +1,6 @@
 module CukeModeler
 
+  # NOT A PART OF THE PUBLIC API
   # An adapter that can convert the output of version 3.x of the *gherkin* gem into input that is consumable by this gem.
 
   class Gherkin3Adapter

data/lib/cuke_modeler/adapters/gherkin_4_adapter.rb

@@ -1,6 +1,7 @@
 module CukeModeler
 
-  # An adapter that can convert the output of version 4.x and 5.x of the *gherkin* gem into input that is consumable by this gem.
+  # NOT A PART OF THE PUBLIC API
+  # An adapter that can convert the output of version 4.x of the *gherkin* gem into input that is consumable by this gem.
 
   class Gherkin4Adapter
 

data/lib/cuke_modeler/adapters/gherkin_5_adapter.rb

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

data/lib/cuke_modeler/adapters/gherkin_6_adapter.rb

@@ -0,0 +1,310 @@
+module CukeModeler
+
+  # NOT A PART OF THE PUBLIC API
+  # An adapter that can convert the output of version 6.x of the *gherkin* gem into input that is consumable by this gem.
+
+  class Gherkin6Adapter
+
+    # 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
+      parsed_ast['cuke_modeler_parsing_data'][:comments] = nil
+
+      # Comments are stored on the feature file in gherkin 4.x
+      parsed_ast['comments'] = []
+      parsed_ast[:comments].each do |comment|
+        adapt_comment!(comment)
+      end
+      parsed_ast['comments'].concat(parsed_ast.delete(:comments))
+
+      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
+      parsed_feature['cuke_modeler_parsing_data'][:children] = nil
+
+      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'] = []
+      adapt_child_elements!(parsed_feature[:children])
+      parsed_feature['elements'].concat(parsed_feature.delete(:children))
+
+      parsed_feature['tags'] = []
+      parsed_feature[:tags].each do |tag|
+        adapt_tag!(tag)
+      end
+      parsed_feature['tags'].concat(parsed_feature.delete(:tags))
+    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
+
+      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'] = []
+      parsed_background[:background][:steps].each do |step|
+        adapt_step!(step)
+      end
+      parsed_background['steps'].concat(parsed_background[:background].delete(:steps))
+    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
+      parsed_test['cuke_modeler_parsing_data'][:scenario][:steps] = nil
+
+      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'] = []
+      parsed_test[:scenario][:tags].each do |tag|
+        adapt_tag!(tag)
+      end
+      parsed_test['tags'].concat(parsed_test[:scenario].delete(:tags))
+
+      parsed_test['steps'] = []
+      parsed_test[:scenario][:steps].each do |step|
+        adapt_step!(step)
+      end
+      parsed_test['steps'].concat(parsed_test[:scenario].delete(:steps))
+    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
+      parsed_test['cuke_modeler_parsing_data'][:scenario][:steps] = nil
+      parsed_test['cuke_modeler_parsing_data'][:scenario][:examples] = nil
+
+      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'] = []
+      parsed_test[:scenario][:tags].each do |tag|
+        adapt_tag!(tag)
+      end
+      parsed_test['tags'].concat(parsed_test[:scenario].delete(:tags))
+
+      parsed_test['steps'] = []
+      parsed_test[:scenario][:steps].each do |step|
+        adapt_step!(step)
+      end
+      parsed_test['steps'].concat(parsed_test[:scenario].delete(:steps))
+
+      parsed_test['examples'] = []
+      parsed_test[:scenario][:examples].each do |step|
+        adapt_example!(step)
+      end
+      parsed_test['examples'].concat(parsed_test[:scenario].delete(:examples))
+    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
+      parsed_example['cuke_modeler_parsing_data'][:table_header] = nil
+      parsed_example['cuke_modeler_parsing_data'][:table_body] = nil
+
+      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'] = []
+      parsed_example[:tags].each do |tag|
+        adapt_tag!(tag)
+      end
+      parsed_example['tags'].concat(parsed_example.delete(:tags))
+    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
+      parsed_step['cuke_modeler_parsing_data'][:doc_string] = nil
+
+      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(:content_type).strip # TODO: fix bug in Gherkin so that this whitespace is already trimmed off
+      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)
+      return if parsed_children.empty?
+
+      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)
+      return unless 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].any?
+          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