cuke_modeler 3.2.0 → 3.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4b152c6307169c73e75c9e2b4798d29cab2c7b8ad7ed086c12a854739940d2eb
-  data.tar.gz: a50e43b9e28d514d22c0a756be7197e9a5395cdf38fcde50d34e8b1c0c41df53
+  metadata.gz: abf3eb894f4814405982ec3e2e664b9b6b0ede9b4c3f41ac99148680e251fdf0
+  data.tar.gz: 31e87cc947478d94ad6e5316315698b2af7a7280ecc062a670f9c70e399038fe
 SHA512:
-  metadata.gz: 627d1c76575e4c2ed4b97ac2ee2db83c920997bc1296bdf6ecfc530ba92250d585c011fa9e315b2c52c28cd9c1f219da7cf1e79fe44e23d0ba868db3de48ffda
-  data.tar.gz: 3f1c554b800ed1a194d800d13ce9b39e5e4dd5655780e6e3ef007e7e2480d3139d5d8feec128d9db470cf3b8d0a996a5116af0a0770e80e20ee1899cbf661b3a
+  metadata.gz: cc973033937d9bad34a2a47da77901850e6ce2e9de6cf875a0d51f6fe634e64f48cf42d4a4ca154e308982dff0e945bd002df98a48e725c8a5705e2f78720522
+  data.tar.gz: 73b177f6e22947a5301fbfae5a90fde84394e50adf5d7790f783d8fdea7f2b46c2b7025c0a483f80ce31f3707970051d8b7b3717299fd60adbbf6ab736e4cac6

data/CHANGELOG.md

@@ -6,7 +6,47 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-Nothing yet...
+Noting yet...
+
+
+## [3.7.0] - 2021-02-18
+
+### Added
+ - Support added for more versions of the `cucumber-gherkin` gem
+   - 17.x
+
+
+## [3.6.0] - 2021-01-05
+
+### Added
+ - Ruby 3.x is now supported
+ - All models are now `Enumerable`. However, some methods such as `Enumerable#max` and `Enumerable#sort` do not work 
+   because models do not meaningfully compare to each other.
+
+### Deprecated
+ - `Model#each_descendant` and `Model#each_model` will be removed on the next major release. `Model#each` and methods in 
+ the `Enumerable` module now provide this kind of functionality.
+
+### Fixed
+ - `Row#children` now returns the row's `Cell` models instead of returning an empty array
+
+
+## [3.5.0] - 2020-12-19
+
+### Added
+ - Support added for more versions of the `cucumber-gherkin` gem
+   - 16.x
+
+## [3.4.0] - 2020-09-02
+
+### Added
+ - `Feature#has_background?` and `Rule#has_background?` now both have a more conventional name via the alias `#background?`
+
+## [3.3.0] - 2020-08-15
+
+### Added
+ - Support added for more versions of the `cucumber-gherkin` gem
+   - 15.x
 
 ## [3.2.0] - 2020-07-27
 
@@ -312,7 +352,7 @@ Nothing yet...
 
 ### Fixed
 
- - Fixed a bug that was causing object comparison using #== to not 
+ - Fixed a bug that was causing object comparison using `#==` to not 
    work when comparing some models to other types of objects.
 
 
@@ -323,7 +363,12 @@ Nothing yet...
  - Initial release
 
 
-[Unreleased]: https://github.com/enkessler/cuke_modeler/compare/v3.2.0...HEAD
+[Unreleased]: https://github.com/enkessler/cuke_modeler/compare/v3.7.0...HEAD
+[3.7.0]: https://github.com/enkessler/cuke_modeler/compare/v3.6.0...v3.7.0
+[3.6.0]: https://github.com/enkessler/cuke_modeler/compare/v3.5.0...v3.6.0
+[3.5.0]: https://github.com/enkessler/cuke_modeler/compare/v3.4.0...v3.5.0
+[3.4.0]: https://github.com/enkessler/cuke_modeler/compare/v3.3.0...v3.4.0
+[3.3.0]: https://github.com/enkessler/cuke_modeler/compare/v3.2.0...v3.3.0
 [3.2.0]: https://github.com/enkessler/cuke_modeler/compare/v3.1.0...v3.2.0
 [3.1.0]: https://github.com/enkessler/cuke_modeler/compare/v3.0.0...v3.1.0
 [3.0.0]: https://github.com/enkessler/cuke_modeler/compare/v2.1.0...v3.0.0

data/LICENSE.txt

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

data/README.md

@@ -4,15 +4,15 @@ Basic stuff:
 [![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)
+[![Cucumber Docs](http://img.shields.io/badge/Documentation-Features-green.svg)](https://github.com/enkessler/cuke_modeler/tree/master/testing/cucumber/features)
 [![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)](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)
+[![Build Status](https://travis-ci.org/enkessler/cuke_modeler.svg?branch=master)](https://travis-ci.org/enkessler/cuke_modeler)
+[![Build status](https://ci.appveyor.com/api/projects/status/is8xqvoqn3pjh9l0/branch/master?svg=true)](https://ci.appveyor.com/project/enkessler/cuke-modeler)
+[![Coverage Status](https://coveralls.io/repos/github/enkessler/cuke_modeler/badge.svg?branch=master)](https://coveralls.io/github/enkessler/cuke_modeler?branch=master)
 [![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)](https://inch-ci.org/github/enkessler/cuke_modeler)
+[![Inline docs](http://inch-ci.org/github/enkessler/cuke_modeler.svg?branch=master)](https://inch-ci.org/github/enkessler/cuke_modeler)
 
 ---
 
@@ -84,12 +84,12 @@ an entire test suite!
 
 For more information on the different models (which more or less have the same relation 
 to each other as described in the AST [here](https://github.com/cucumber/cucumber/tree/master/gherkin#ast)) and how to use them, see the 
-[documentation](https://app.cucumber.pro/projects/cuke_modeler).
+[documentation](https://github.com/enkessler/cuke_modeler/tree/master/testing/cucumber/features).
 
 ## Modeling dialects other than English
 
 The modeling functionality provided by this gem will work with any dialect that 
-is supported by the **gherkin** gem. For modeling at the feature level or higher, 
+is supported by the **cucumber-gherkin** gem. For modeling at the feature level or higher, 
 no additional effort is needed because the `# language` header at the top of a 
 feature already indicates that a non-default dialect is being used.
 

data/cuke_modeler.gemspec

@@ -1,17 +1,29 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'cuke_modeler/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "cuke_modeler"
+  spec.name          = 'cuke_modeler'
   spec.version       = CukeModeler::VERSION
-  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 '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.authors       = ['Eric Kessler']
+  spec.email         = ['morrow748@gmail.com']
+  spec.summary       = 'A gem providing functionality to model Gherkin based test suites.'
+  spec.description   = ['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.'].join
   spec.homepage      = 'https://github.com/enkessler/cuke_modeler'
-  spec.license       = "MIT"
+  spec.license       = 'MIT'
+
+  spec.metadata = {
+    'bug_tracker_uri'   => 'https://github.com/enkessler/cuke_modeler/issues',
+    'changelog_uri'     => 'https://github.com/enkessler/cuke_modeler/blob/master/CHANGELOG.md',
+    'documentation_uri' => 'https://www.rubydoc.info/gems/cuke_modeler',
+    'homepage_uri'      => 'https://github.com/enkessler/cuke_modeler',
+    'source_code_uri'   => 'https://github.com/enkessler/cuke_modeler'
+  }
 
   # 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.
@@ -20,19 +32,26 @@ Gem::Specification.new do |spec|
     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.require_paths = ['lib']
 
-  spec.required_ruby_version = '>= 2.3', '< 3.0'
+  spec.required_ruby_version = '>= 2.3', '< 4.0'
 
-  spec.add_runtime_dependency 'cucumber-gherkin', '< 15.0'
+  spec.add_runtime_dependency 'cucumber-gherkin', '< 18.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', '<= 0.16.1'
-  spec.add_development_dependency 'racatt', '~> 1.0'
+  spec.add_development_dependency 'childprocess', '< 5.0'
   spec.add_development_dependency 'coveralls', '< 1.0.0'
+  spec.add_development_dependency 'ffi', '< 2.0' # This is an invisible dependency for the `childprocess` gem on Windows
+  # Cucumber 4.x is the earliest version to use cucumber-gherkin
+  spec.add_development_dependency 'cucumber', '>= 4.0.0', '< 6.0.0'
   spec.add_development_dependency 'rainbow', '< 4.0.0'
+  spec.add_development_dependency 'rake', '< 14.0.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  # RuboCop drops Ruby 2.3 support after this version and we need to maintain Ruby 2.3 compatibility when writing code
+  # for this gem
+  spec.add_development_dependency 'rubocop', '< 0.82.0'
+  # Coveralls gem does not support any newer version than this
+  spec.add_development_dependency 'simplecov', '<= 0.16.1'
   spec.add_development_dependency 'test-unit', '< 4.0.0'
+  spec.add_development_dependency 'yard', '< 1.0'
 end

data/lib/cuke_modeler.rb

@@ -1,10 +1,9 @@
 # The top level namespace used by this gem
-
 module CukeModeler
 end
 
 
-require "cuke_modeler/version"
+require 'cuke_modeler/version'
 
 require 'cuke_modeler/parsing'
 require 'cuke_modeler/containing'

data/lib/cuke_modeler/adapters/gherkin_10_adapter.rb

@@ -4,7 +4,8 @@ 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.
+  # 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
 

data/lib/cuke_modeler/adapters/gherkin_11_adapter.rb

@@ -4,7 +4,8 @@ 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.
+  # 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
 

data/lib/cuke_modeler/adapters/gherkin_12_adapter.rb

@@ -4,7 +4,8 @@ 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.
+  # 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
 

data/lib/cuke_modeler/adapters/gherkin_13_adapter.rb

@@ -4,7 +4,8 @@ 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.
+  # 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
 

data/lib/cuke_modeler/adapters/gherkin_14_adapter.rb

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

data/lib/cuke_modeler/adapters/gherkin_15_adapter.rb

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

data/lib/cuke_modeler/adapters/gherkin_16_adapter.rb

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

data/lib/cuke_modeler/adapters/gherkin_17_adapter.rb

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

data/lib/cuke_modeler/adapters/gherkin_9_adapter.rb

@@ -1,345 +1,363 @@
+# Some things just aren't going to get better due to the inherent complexity of the AST
+# rubocop:disable Metrics/ClassLength, Metrics/AbcSize, Metrics/MethodLength
+
 module CukeModeler
 
   # NOT A PART OF THE PUBLIC API
-  # An adapter that can convert the output of version 9.x of the *cucumber-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
 
     # 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))
+    def adapt(ast)
+      adapted_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
+      # Saving off the original data and removing parsed data for child elements in order to avoid duplicating data
+      save_original_data(adapted_ast, ast)
+      clear_child_elements(adapted_ast, [[:feature],
+                                         [:comments]])
 
-      adapt_feature!(parsed_ast[:feature]) if parsed_ast[:feature]
-      parsed_ast['feature'] = parsed_ast.delete(:feature)
+      adapted_ast['comments'] = adapt_comments(ast)
+      adapted_ast['feature'] = adapt_feature(ast[:feature])
 
-      parsed_ast
+      adapted_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))
+    def adapt_feature(feature_ast)
+      return nil unless feature_ast
 
-      # 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]
+      adapted_feature = {}
 
-      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]
+      # Saving off the original data and removing parsed data for child elements in order to avoid duplicating data
+      save_original_data(adapted_feature, feature_ast)
+      clear_child_elements(adapted_feature, [[:tags],
+                                             [:children]])
 
-      parsed_feature['elements'] = []
-      if parsed_feature[:children]
-        adapt_child_elements!(parsed_feature[:children])
-        parsed_feature['elements'].concat(parsed_feature.delete(:children))
-      end
+      adapted_feature['keyword'] = feature_ast[:keyword]
+      adapted_feature['name'] = feature_ast[:name]
+      adapted_feature['description'] = feature_ast[:description] || ''
+      adapted_feature['line'] = feature_ast[:location][:line]
 
-      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
+      adapted_feature['elements'] = adapt_child_elements(feature_ast)
+      adapted_feature['tags'] = adapt_tags(feature_ast)
+
+      adapted_feature
     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))
+    def adapt_background(background_ast)
+      adapted_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]
+      # Saving off the original data and removing parsed data for child elements in order to avoid duplicating data
+      save_original_data(adapted_background, background_ast)
+      clear_child_elements(adapted_background, [[: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]
+      adapted_background['type'] = 'Background'
+      adapted_background['keyword'] = background_ast[:background][:keyword]
+      adapted_background['name'] = background_ast[:background][:name]
+      adapted_background['description'] = background_ast[:background][:description] || ''
+      adapted_background['line'] = background_ast[:background][: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
+      adapted_background['steps'] = adapt_steps(background_ast[:background])
+
+      adapted_background
     end
 
     # Adapts the AST sub-tree that is rooted at the given rule node.
-    def adapt_rule!(parsed_rule)
-      # Saving off the original data
-      parsed_rule['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_rule))
+    def adapt_rule(rule_ast)
+      adapted_rule = {}
 
-      # Removing parsed data for child elements in order to avoid duplicating data
-      parsed_rule['cuke_modeler_parsing_data'][:rule][:children] = nil if parsed_rule['cuke_modeler_parsing_data'][:rule][:children]
+      # Saving off the original data and removing parsed data for child elements in order to avoid duplicating data
+      save_original_data(adapted_rule, rule_ast)
+      clear_child_elements(adapted_rule, [[:rule, :children]])
 
-      parsed_rule['type'] = 'Rule'
-      parsed_rule['keyword'] = parsed_rule[:rule].delete(:keyword)
-      parsed_rule['name'] = parsed_rule[:rule].delete(:name)
-      parsed_rule['description'] = parsed_rule[:rule].delete(:description) || ''
-      parsed_rule['line'] = parsed_rule[:rule].delete(:location)[:line]
+      adapted_rule['type'] = 'Rule'
+      adapted_rule['keyword'] = rule_ast[:rule][:keyword]
+      adapted_rule['name'] = rule_ast[:rule][:name]
+      adapted_rule['description'] = rule_ast[:rule][:description] || ''
+      adapted_rule['line'] = rule_ast[:rule][:location][:line]
 
-      parsed_rule['elements'] = []
-      if parsed_rule[:rule][:children]
-        adapt_child_elements!(parsed_rule[:rule][:children])
-        parsed_rule['elements'].concat(parsed_rule[:rule].delete(:children))
-      end
+      adapted_rule['elements'] = adapt_child_elements(rule_ast[:rule])
+
+      adapted_rule
     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
+    def adapt_scenario(test_ast)
+      adapted_scenario = {}
 
-      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
+      # Saving off the original data and removing parsed data for child elements in order to avoid duplicating data
+      save_original_data(adapted_scenario, test_ast)
+      clear_child_elements(adapted_scenario, [[:scenario, :tags],
+                                              [:scenario, :steps]])
 
-    # 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
+      adapted_scenario['type'] = 'Scenario'
+      adapted_scenario['keyword'] = test_ast[:scenario][:keyword]
+      adapted_scenario['name'] = test_ast[:scenario][:name]
+      adapted_scenario['description'] = test_ast[:scenario][:description] || ''
+      adapted_scenario['line'] = test_ast[:scenario][:location][:line]
 
-      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
+      adapted_scenario['tags'] = adapt_tags(test_ast[:scenario])
+      adapted_scenario['steps'] = adapt_steps(test_ast[:scenario])
 
-      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
+      adapted_scenario
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given outline node.
+    def adapt_outline(test_ast)
+      adapted_outline = {}
+
+      # Saving off the original data and removing parsed data for child elements in order to avoid duplicating data
+      save_original_data(adapted_outline, test_ast)
+      clear_child_elements(adapted_outline, [[:scenario, :tags],
+                                             [:scenario, :steps],
+                                             [:scenario, :examples]])
+
+      adapted_outline['type'] = 'ScenarioOutline'
+      adapted_outline['keyword'] = test_ast[:scenario][:keyword]
+      adapted_outline['name'] = test_ast[:scenario][:name]
+      adapted_outline['description'] = test_ast[:scenario][:description] || ''
+      adapted_outline['line'] = test_ast[:scenario][:location][:line]
+
+      adapted_outline['tags'] = adapt_tags(test_ast[:scenario])
+      adapted_outline['steps'] = adapt_steps(test_ast[:scenario])
+      adapted_outline['examples'] = adapt_examples(test_ast[:scenario])
+
+      adapted_outline
     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))
+    def adapt_example(example_ast)
+      adapted_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]
+      # Saving off the original data and removing parsed data for child elements in order to avoid duplicating data
+      save_original_data(adapted_example, example_ast)
+      clear_child_elements(adapted_example, [[:tags],
+                                             [:table_header],
+                                             [: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) || ''
+      adapted_example['keyword'] = example_ast[:keyword]
+      adapted_example['name'] = example_ast[:name]
+      adapted_example['line'] = example_ast[:location][:line]
+      adapted_example['description'] = example_ast[:description] || ''
 
-      parsed_example['rows'] = []
+      adapted_example['rows'] = []
+      adapted_example['rows'] << adapt_table_row(example_ast[:table_header]) if example_ast[:table_header]
 
-      if parsed_example[:table_header]
-        adapt_table_row!(parsed_example[:table_header])
-        parsed_example['rows'] << parsed_example.delete(:table_header)
+      example_ast[:table_body]&.each do |row|
+        adapted_example['rows'] << adapt_table_row(row)
       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
+      adapted_example['tags'] = adapt_tags(example_ast)
 
-      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
+      adapted_example
     end
 
     # Adapts the AST sub-tree that is rooted at the given tag node.
-    def adapt_tag!(parsed_tag)
+    def adapt_tag(tag_ast)
+      adapted_tag = {}
+
       # Saving off the original data
-      parsed_tag['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_tag))
+      save_original_data(adapted_tag, tag_ast)
 
-      parsed_tag['name'] = parsed_tag.delete(:name)
-      parsed_tag['line'] = parsed_tag.delete(:location)[:line]
+      adapted_tag['name'] = tag_ast[:name]
+      adapted_tag['line'] = tag_ast[:location][:line]
+
+      adapted_tag
     end
 
     # Adapts the AST sub-tree that is rooted at the given comment node.
-    def adapt_comment!(parsed_comment)
+    def adapt_comment(comment_ast)
+      adapted_comment = {}
+
       # Saving off the original data
-      parsed_comment['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_comment))
+      save_original_data(adapted_comment, comment_ast)
 
-      parsed_comment['text'] = parsed_comment.delete(:text)
-      parsed_comment['line'] = parsed_comment.delete(:location)[:line]
+      adapted_comment['text'] = comment_ast[:text]
+      adapted_comment['line'] = comment_ast[:location][:line]
+
+      adapted_comment
     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
+    def adapt_step(step_ast)
+      adapted_step = {}
+
+      # Saving off the original data and removing parsed data for child elements in order to avoid duplicating data
+      save_original_data(adapted_step, step_ast)
+      clear_child_elements(adapted_step, [[:data_table],
+                                          [:doc_string]])
+
+      adapted_step['keyword'] = step_ast[:keyword]
+      adapted_step['name'] = step_ast[:text]
+      adapted_step['line'] = step_ast[:location][:line]
+
+      if step_ast[:doc_string]
+        adapted_step['doc_string'] = adapt_doc_string(step_ast[:doc_string])
+      elsif step_ast[:data_table]
+        adapted_step['table'] = adapt_step_table(step_ast[:data_table])
       end
+
+      adapted_step
     end
 
     # Adapts the AST sub-tree that is rooted at the given doc string node.
-    def adapt_doc_string!(parsed_doc_string)
+    def adapt_doc_string(doc_string_ast)
+      adapted_doc_string = {}
+
       # Saving off the original data
-      parsed_doc_string['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_doc_string))
+      save_original_data(adapted_doc_string, doc_string_ast)
+
+      adapted_doc_string['value'] = doc_string_ast[:content]
+      adapted_doc_string['content_type'] = doc_string_ast[:media_type]
+      adapted_doc_string['line'] = doc_string_ast[:location][:line]
 
-      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]
+      adapted_doc_string
     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))
+    def adapt_step_table(step_table_ast)
+      adapted_step_table = {}
 
-      # Removing parsed data for child elements in order to avoid duplicating data
-      parsed_step_table['cuke_modeler_parsing_data'][:rows] = nil
+      # Saving off the original data and removing parsed data for child elements in order to avoid duplicating data
+      save_original_data(adapted_step_table, step_table_ast)
+      clear_child_elements(adapted_step_table, [[:rows]])
 
-      parsed_step_table['rows'] = []
-      parsed_step_table[:rows].each do |row|
-        adapt_table_row!(row)
+      adapted_step_table['rows'] = []
+      step_table_ast[:rows].each do |row|
+        adapted_step_table['rows'] << 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]
+      adapted_step_table['line'] = step_table_ast[:location][:line]
+
+      adapted_step_table
     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))
+    def adapt_table_row(table_row_ast)
+      adapted_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
+      # Saving off the original data and removing parsed data for child elements in order to avoid duplicating data
+      save_original_data(adapted_table_row, table_row_ast)
+      clear_child_elements(adapted_table_row, [[:cells]])
 
-      parsed_table_row['line'] = parsed_table_row.delete(:location)[:line]
+      adapted_table_row['line'] = table_row_ast[:location][:line]
 
-      parsed_table_row['cells'] = []
-      parsed_table_row[:cells].each do |row|
-        adapt_table_cell!(row)
+      adapted_table_row['cells'] = []
+      table_row_ast[:cells].each do |row|
+        adapted_table_row['cells'] << adapt_table_cell(row)
       end
-      parsed_table_row['cells'].concat(parsed_table_row.delete(:cells))
+
+      adapted_table_row
     end
 
     # Adapts the AST sub-tree that is rooted at the given cell node.
-    def adapt_table_cell!(parsed_cell)
+    def adapt_table_cell(cell_ast)
+      adapted_cell = {}
+
       # Saving off the original data
-      parsed_cell['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_cell))
+      save_original_data(adapted_cell, cell_ast)
 
-      parsed_cell['value'] = parsed_cell.delete(:value)
-      parsed_cell['line'] = parsed_cell.delete(:location)[:line]
+      adapted_cell['value'] = cell_ast[:value]
+      adapted_cell['line'] = cell_ast[:location][:line]
+
+      adapted_cell
     end
 
 
     private
 
 
-    def adapt_child_elements!(parsed_children)
-      background_child = parsed_children.find { |child| child[:background] }
-      rule_children = parsed_children.select { |child| child[:rule] }
-      remaining_children = parsed_children.reject { |child| child[:background] || child[:rule] }
+    def adapt_comments(file_ast)
+      return [] unless file_ast[:comments]
+
+      file_ast[:comments].map { |comment| adapt_comment(comment) }
+    end
+
+    def adapt_tags(element_ast)
+      return [] unless element_ast[:tags]
+
+      element_ast[:tags].map { |tag| adapt_tag(tag) }
+    end
+
+    def adapt_steps(element_ast)
+      return [] unless element_ast[:steps]
+
+      element_ast[:steps].map { |step| adapt_step(step) }
+    end
+
+    def adapt_examples(element_ast)
+      return [] unless element_ast[:examples]
+
+      element_ast[:examples].map { |example| adapt_example(example) }
+    end
+
+    def adapt_child_elements(element_ast)
+      return [] unless element_ast[:children]
+
+      adapted_children = []
+
+      element_ast[:children].each do |child_element|
+        adapted_children << if child_element[:background]
+                              adapt_background(child_element)
+                            elsif child_element[:rule]
+                              adapt_rule(child_element)
+                            else
+                              adapt_test(child_element)
+                            end
+      end
 
-      adapt_background!(background_child) if background_child
-      adapt_rules!(rule_children)
-      adapt_tests!(remaining_children)
+      adapted_children
     end
 
-    def adapt_rules!(parsed_rules)
-      parsed_rules.each do |rule|
-        adapt_rule!(rule)
+    def adapt_test(test_ast)
+      if (test_node?(test_ast) && test_has_examples?(test_ast)) ||
+         (test_node?(test_ast) && test_uses_outline_keyword?(test_ast))
+
+        adapt_outline(test_ast)
+      elsif test_node?(test_ast)
+        adapt_scenario(test_ast)
+      else
+        raise(ArgumentError, "Unknown test type with keys: #{test_ast.keys}")
       end
     end
 
-    def adapt_tests!(parsed_tests)
-      parsed_tests.each do |test|
-        adapt_test!(test)
+    def save_original_data(adapted_ast, raw_ast)
+      adapted_ast['cuke_modeler_parsing_data'] = Marshal.load(Marshal.dump(raw_ast))
+    end
+
+    def clear_child_elements(ast, child_paths)
+      child_paths.each do |traversal_path|
+        if ast['cuke_modeler_parsing_data'].dig(*traversal_path)
+          bury(ast['cuke_modeler_parsing_data'], traversal_path, nil)
+        end
       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}")
+    def bury(hash, traversal_path, value)
+      keys = *traversal_path
+
+      current = hash
+      (keys.count - 1).times do |index|
+        current = hash[keys[index]]
       end
+
+      current[keys.last] = value
+    end
+
+    def test_node?(ast_node)
+      ast_node[:scenario]
+    end
+
+    def test_has_examples?(ast_node)
+      ast_node[:scenario][:examples]
+    end
+
+    def test_uses_outline_keyword?(test_ast)
+      Parsing.dialects[Parsing.dialect]['scenarioOutline'].include?(test_ast[:scenario][:keyword])
     end
 
   end
 end
+
+# rubocop:enable Metrics/ClassLength, Metrics/AbcSize, Metrics/MethodLength