cuke_modeler 1.5.1 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2a3d9a2a79ed92fc6190aa4d8bfd198d319a283af35d7586ba9dd6e11562b108
-  data.tar.gz: d55ac4e9e29b02999ea13919ad24353e896a07608b854959ded2c2c664608711
+  metadata.gz: 4b152c6307169c73e75c9e2b4798d29cab2c7b8ad7ed086c12a854739940d2eb
+  data.tar.gz: a50e43b9e28d514d22c0a756be7197e9a5395cdf38fcde50d34e8b1c0c41df53
 SHA512:
-  metadata.gz: 8a6d159ad8a6d3a5dd556cbeb113f973a85dbc4c5cc130d9fef5f6abacf9b37a4cd1fe4bb7b58e75004bd0483ec3ec2a2b6a5b3991f520e906c0a87e34ad8809
-  data.tar.gz: 8b4e011d5152f35091002dc317da68e3a290cbed5069bba218e3ef41642d3c281554c3e2f4f7ff91ec756c18147864070f270e433cff23c05de430972fba5834
+  metadata.gz: 627d1c76575e4c2ed4b97ac2ee2db83c920997bc1296bdf6ecfc530ba92250d585c011fa9e315b2c52c28cd9c1f219da7cf1e79fe44e23d0ba868db3de48ffda
+  data.tar.gz: 3f1c554b800ed1a194d800d13ce9b39e5e4dd5655780e6e3ef007e7e2480d3139d5d8feec128d9db470cf3b8d0a996a5116af0a0770e80e20ee1899cbf661b3a

data/CHANGELOG.md

@@ -8,6 +8,60 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 Nothing yet...
 
+## [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
+ - Support added for more versions of the `gherkin` gem
+   - 9.x
+   - 8.x
+   - 7.x
+
+### Fixed
+ - Parsing errors are now correctly bubbled up when using Gherkin 6.x
+
+## [2.0.0] - 2020-02-11
+
+### Changed
+
+ - Step models now include doc strings and tables when determining their equality with other steps. Previously, only the base text of the step was included and the doc string/table was explicitly ignored.
+
+
 ## [1.5.1] - 2019-04-14
 
 ### Added
@@ -269,7 +323,12 @@ Nothing yet...
  - Initial release
 
 
-[Unreleased]: https://github.com/enkessler/cuke_modeler/compare/v1.5.1...HEAD
+[Unreleased]: https://github.com/enkessler/cuke_modeler/compare/v3.2.0...HEAD
+[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
 [1.5.0]: https://github.com/enkessler/cuke_modeler/compare/v1.4.0...v1.5.0
 [1.4.0]: https://github.com/enkessler/cuke_modeler/compare/v1.3.0...v1.4.0

data/LICENSE.txt

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

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,7 +82,8 @@ 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
@@ -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

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

data/lib/cuke_modeler.rb

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

data/lib/cuke_modeler/adapters/gherkin_11_adapter.rb

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

data/lib/cuke_modeler/adapters/gherkin_12_adapter.rb

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

data/lib/cuke_modeler/adapters/gherkin_13_adapter.rb

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

data/lib/cuke_modeler/adapters/gherkin_14_adapter.rb

@@ -0,0 +1,12 @@
+require_relative 'gherkin_9_adapter'
+
+
+module CukeModeler
+
+  # NOT A PART OF THE PUBLIC API
+  # An adapter that can convert the output of version 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_6_adapter.rb → gherkin_9_adapter.rb}

@@ -1,8 +1,9 @@
 module CukeModeler
 
-  # An adapter that can convert the output of version 6.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 9.x of the *cucumber-gherkin* gem into input that is consumable by this gem.
 
-  class Gherkin6Adapter
+  class Gherkin9Adapter
 
     # Adapts the given AST into the shape that this gem expects
     def adapt(parsed_ast)
@@ -10,20 +11,21 @@ module CukeModeler
       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
+      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]
 
-      # Comments are stored on the feature file in gherkin 4.x
       parsed_ast['comments'] = []
-      parsed_ast[:comments].each do |comment|
-        adapt_comment!(comment)
+      if parsed_ast[:comments]
+        parsed_ast[:comments].each do |comment|
+          adapt_comment!(comment)
+        end
+        parsed_ast['comments'].concat(parsed_ast.delete(:comments))
       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]
+      parsed_ast
     end
 
     # Adapts the AST sub-tree that is rooted at the given feature node.
@@ -32,23 +34,27 @@ module CukeModeler
       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['cuke_modeler_parsing_data'][:tags] = nil if parsed_feature['cuke_modeler_parsing_data'][:tags]
+      parsed_feature['cuke_modeler_parsing_data'][:children] = nil if parsed_feature['cuke_modeler_parsing_data'][:children]
 
       parsed_feature['keyword'] = parsed_feature.delete(:keyword)
       parsed_feature['name'] = parsed_feature.delete(:name)
-      parsed_feature['description'] = parsed_feature.delete(:description)
+      parsed_feature['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))
+      if parsed_feature[:children]
+        adapt_child_elements!(parsed_feature[:children])
+        parsed_feature['elements'].concat(parsed_feature.delete(:children))
+      end
 
       parsed_feature['tags'] = []
-      parsed_feature[:tags].each do |tag|
-        adapt_tag!(tag)
+      if parsed_feature[:tags]
+        parsed_feature[:tags].each do |tag|
+          adapt_tag!(tag)
+        end
+        parsed_feature['tags'].concat(parsed_feature.delete(:tags))
       end
-      parsed_feature['tags'].concat(parsed_feature.delete(:tags))
     end
 
     # Adapts the AST sub-tree that is rooted at the given background node.
@@ -57,76 +63,109 @@ module CukeModeler
       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['cuke_modeler_parsing_data'][:background][:steps] = nil if parsed_background['cuke_modeler_parsing_data'][:background][:steps]
 
       parsed_background['type'] = 'Background'
       parsed_background['keyword'] = parsed_background[:background].delete(:keyword)
       parsed_background['name'] = parsed_background[:background].delete(:name)
-      parsed_background['description'] = parsed_background[:background].delete(:description)
+      parsed_background['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)
+      if parsed_background[:background][:steps]
+        parsed_background[:background][:steps].each do |step|
+          adapt_step!(step)
+        end
+        parsed_background['steps'].concat(parsed_background[:background].delete(:steps))
+      end
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given rule node.
+    def adapt_rule!(parsed_rule)
+      # Saving off the original data
+      parsed_rule['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_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]
+
+      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]
+
+      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
-      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['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['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)
+      if parsed_test[:scenario][:tags]
+        parsed_test[:scenario][:tags].each do |tag|
+          adapt_tag!(tag)
+        end
+        parsed_test['tags'].concat(parsed_test[:scenario].delete(:tags))
       end
-      parsed_test['tags'].concat(parsed_test[:scenario].delete(:tags))
 
       parsed_test['steps'] = []
-      parsed_test[:scenario][:steps].each do |step|
-        adapt_step!(step)
+      if parsed_test[:scenario][:steps]
+        parsed_test[:scenario][:steps].each do |step|
+          adapt_step!(step)
+        end
+        parsed_test['steps'].concat(parsed_test[:scenario].delete(:steps))
       end
-      parsed_test['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['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['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)
+      if parsed_test[:scenario][:tags]
+        parsed_test[:scenario][:tags].each do |tag|
+          adapt_tag!(tag)
+        end
+        parsed_test['tags'].concat(parsed_test[:scenario].delete(:tags))
       end
-      parsed_test['tags'].concat(parsed_test[:scenario].delete(:tags))
 
       parsed_test['steps'] = []
-      parsed_test[:scenario][:steps].each do |step|
-        adapt_step!(step)
+      if parsed_test[:scenario][:steps]
+        parsed_test[:scenario][:steps].each do |step|
+          adapt_step!(step)
+        end
+        parsed_test['steps'].concat(parsed_test[:scenario].delete(:steps))
       end
-      parsed_test['steps'].concat(parsed_test[:scenario].delete(:steps))
 
       parsed_test['examples'] = []
-      parsed_test[:scenario][:examples].each do |step|
-        adapt_example!(step)
+      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
-      parsed_test['examples'].concat(parsed_test[:scenario].delete(:examples))
     end
 
     # Adapts the AST sub-tree that is rooted at the given example node.
@@ -135,14 +174,14 @@ module CukeModeler
       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['cuke_modeler_parsing_data'][:tags] = nil if parsed_example['cuke_modeler_parsing_data'][:tags]
+      parsed_example['cuke_modeler_parsing_data'][:table_header] = nil if parsed_example['cuke_modeler_parsing_data'][:table_header]
+      parsed_example['cuke_modeler_parsing_data'][:table_body] = nil if parsed_example['cuke_modeler_parsing_data'][:table_body]
 
       parsed_example['keyword'] = parsed_example.delete(:keyword)
       parsed_example['name'] = parsed_example.delete(:name)
       parsed_example['line'] = parsed_example.delete(:location)[:line]
-      parsed_example['description'] = parsed_example.delete(:description)
+      parsed_example['description'] = parsed_example.delete(:description) || ''
 
       parsed_example['rows'] = []
 
@@ -152,19 +191,19 @@ module CukeModeler
       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)
+      if parsed_example[:tags]
+        parsed_example[:tags].each do |tag|
+          adapt_tag!(tag)
+        end
+        parsed_example['tags'].concat(parsed_example.delete(:tags))
       end
-      parsed_example['tags'].concat(parsed_example.delete(:tags))
     end
 
     # Adapts the AST sub-tree that is rooted at the given tag node.
@@ -191,14 +230,13 @@ module CukeModeler
       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['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])
@@ -217,7 +255,7 @@ module CukeModeler
       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['content_type'] = parsed_doc_string.delete(:media_type)
       parsed_doc_string['line'] = parsed_doc_string.delete(:location)[:line]
     end
 
@@ -245,7 +283,6 @@ module CukeModeler
       # 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'] = []
@@ -269,22 +306,22 @@ module CukeModeler
 
 
     def adapt_child_elements!(parsed_children)
-      return if parsed_children.empty?
-
       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] }
 
-      if background_child
-        adapt_background!(background_child)
+      adapt_background!(background_child) if background_child
+      adapt_rules!(rule_children)
+      adapt_tests!(remaining_children)
+    end
 
-        remaining_children = parsed_children.reject { |child| child[:background] }
+    def adapt_rules!(parsed_rules)
+      parsed_rules.each do |rule|
+        adapt_rule!(rule)
       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
@@ -294,9 +331,8 @@ module CukeModeler
       # 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?
+        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)