cuke_modeler 2.1.0 → 3.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e45af46cbcc095433e4bf40fd868daed964bbbc53dac06d3d3de6ca6a4c2db1
-  data.tar.gz: 36e8660c3f4e993732113f79979168ac59b1bd33c35e8722fc06abdf4e54ce85
+  metadata.gz: ab8068e33b09b4e508b0cd53f77c954052796fbbd33686070cbf6e65cd616378
+  data.tar.gz: 57849a93b03a7d6d0cc56548e4e6482eb61557c4b42a68950c82e3b43542e482
 SHA512:
-  metadata.gz: 39109727b23ffbed1015bc7d690367a10c8f8a88e12d099ba973fcd722cfc5fd0f15e9c5dfeef4a61793850b75a46feb9933f1bba66845cb7ccd72c323d26c36
-  data.tar.gz: 11848c5307c7da2a0669e80dfef83cf535ba1259e3c04d05897b12ab5057760419f239ff7eaaebbc37fec33e7610cc11c771f81128d05f7a779794ad70770978
+  metadata.gz: 3077bf8a1a1defacc92d371db01044c2ea5c7ef44dc7a194079a1e8721b4e8dad598eb4705acc4882d04a5934c27a70103a7eca2795f45ea9f5bebad37d24e7d
+  data.tar.gz: 0a9e2fbae81285bad22f59ef8626fd020be7516a824292fd08387eb38f34d1bc185f41d71084c1be84f331574c7d65145fa3e37ae28d8585ab5369f25adfffa5

data/CHANGELOG.md

@@ -8,6 +8,53 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 Nothing yet...
 
+## [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
+
+### Added
+ - The `Rule` keyword is now a modeled element.
+
+### Deprecated
+ - `Feature#test_case_count` will be removed on the next major release. It's a random analysis method in what is 
+ otherwise a purely abstraction layer library. The [CQL](https://github.com/enkessler/cql) gem is better suited to such tasks.  
+
+## [3.1.0] - 2020-06-28
+
+### Added
+ - Support added for more versions of the `cucumber-gherkin` gem
+   - 14.x
+
+### Fixed
+  - Text is converted to UTF-8 encoding before being passed to the underlying Gherkin gem. This is due to UTF-8 being 
+    the only encoding supported by Gherkin. The `gherkin` gem did the conversion automatically and so this conversion 
+    was not necessary previously but the `cucumber-gherkin` gem does not do any automatic conversion.
+
+## [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 +334,12 @@ 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.4.0...HEAD
+[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
 [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.
  
@@ -82,13 +82,14 @@ and setting their attributes afterward.
 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 
+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).
 
 ## 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.
 
@@ -126,13 +127,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

@@ -1,35 +1,47 @@
-# 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 '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("\n")
   spec.homepage      = 'https://github.com/enkessler/cuke_modeler'
-  spec.license       = "MIT"
+  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)/})
-  spec.require_paths = ["lib"]
+  # 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', '< 16.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 'racatt', '~> 1.0'
   spec.add_development_dependency 'coveralls', '< 1.0.0'
+  # 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 'racatt', '~> 1.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'
 end

data/lib/cuke_modeler.rb

@@ -4,7 +4,7 @@ module CukeModeler
 end
 
 
-require "cuke_modeler/version"
+require 'cuke_modeler/version'
 
 require 'cuke_modeler/parsing'
 require 'cuke_modeler/containing'
@@ -19,6 +19,7 @@ require 'cuke_modeler/models/model'
 require 'cuke_modeler/models/feature_file'
 require 'cuke_modeler/models/directory'
 require 'cuke_modeler/models/feature'
+require 'cuke_modeler/models/rule'
 require 'cuke_modeler/models/background'
 require 'cuke_modeler/models/scenario'
 require 'cuke_modeler/models/outline'

data/lib/cuke_modeler/adapters/gherkin_10_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 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,13 @@
+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,13 @@
+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,13 @@
+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_14_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 14.x of the *cucumber-gherkin* gem into input that is consumable
+  # by this gem.
+
+  class Gherkin14Adapter < Gherkin9Adapter
+
+  end
+end

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_9_adapter.rb

@@ -1,12 +1,364 @@
-require_relative 'gherkin_7_adapter'
+# 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 *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(ast)
+      adapted_ast = {}
+
+      # 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]])
+
+      adapted_ast['comments'] = adapt_comments(ast)
+      adapted_ast['feature'] = adapt_feature(ast[:feature])
+
+      adapted_ast
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given feature node.
+    def adapt_feature(feature_ast)
+      return nil unless feature_ast
+
+      adapted_feature = {}
+
+      # 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]])
+
+      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]
+
+      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(background_ast)
+      adapted_background = {}
+
+      # 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]])
+
+      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]
+
+      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(rule_ast)
+      adapted_rule = {}
+
+      # 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]])
+
+      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]
+
+      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(test_ast)
+      adapted_scenario = {}
+
+      # 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]])
+
+      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]
+
+      adapted_scenario['tags'] = adapt_tags(test_ast[:scenario])
+      adapted_scenario['steps'] = adapt_steps(test_ast[:scenario])
+
+      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(example_ast)
+      adapted_example = {}
+
+      # 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]])
+
+      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] || ''
+
+      adapted_example['rows'] = []
+      adapted_example['rows'] << adapt_table_row(example_ast[:table_header]) if example_ast[:table_header]
+
+      example_ast[:table_body]&.each do |row|
+        adapted_example['rows'] << adapt_table_row(row)
+      end
+
+      adapted_example['tags'] = adapt_tags(example_ast)
+
+      adapted_example
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given tag node.
+    def adapt_tag(tag_ast)
+      adapted_tag = {}
+
+      # Saving off the original data
+      save_original_data(adapted_tag, tag_ast)
+
+      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(comment_ast)
+      adapted_comment = {}
+
+      # Saving off the original data
+      save_original_data(adapted_comment, comment_ast)
+
+      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(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(doc_string_ast)
+      adapted_doc_string = {}
+
+      # Saving off the original data
+      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]
+
+      adapted_doc_string
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given table node.
+    def adapt_step_table(step_table_ast)
+      adapted_step_table = {}
+
+      # 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]])
+
+      adapted_step_table['rows'] = []
+      step_table_ast[:rows].each do |row|
+        adapted_step_table['rows'] << adapt_table_row(row)
+      end
+      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(table_row_ast)
+      adapted_table_row = {}
+
+      # 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]])
+
+      adapted_table_row['line'] = table_row_ast[:location][:line]
+
+      adapted_table_row['cells'] = []
+      table_row_ast[:cells].each do |row|
+        adapted_table_row['cells'] << adapt_table_cell(row)
+      end
+
+      adapted_table_row
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given cell node.
+    def adapt_table_cell(cell_ast)
+      adapted_cell = {}
+
+      # Saving off the original data
+      save_original_data(adapted_cell, cell_ast)
+
+      adapted_cell['value'] = cell_ast[:value]
+      adapted_cell['line'] = cell_ast[:location][:line]
+
+      adapted_cell
+    end
+
+
+    private
+
+
+    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
+
+      adapted_children
+    end
+
+    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 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 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