cuke_modeler 3.9.0 → 3.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bac7201e203c0357c8137182d821bd7537968c2db97572dcc27e118ec3ccf489
-  data.tar.gz: c08252bb8906a1648bb3f846bd1a17481316003bacc0526cbcfb2b321c9675c9
+  metadata.gz: b7e797a40be9122031fb1af313da9c05ded38167a525751135a27d711e901768
+  data.tar.gz: 6f793fedb5971b37d0733ca53d997b6f334c2e51716dff9b9c0cc2000ecc9c03
 SHA512:
-  metadata.gz: 12647de1b642dbffff2c4a4567977c603dbbd138ce0ba465f0003ccf7455860e4fbf7abe82988da5878db2de6fbb8e4ac69541bca98005ecb9381fd40cc2d80e
-  data.tar.gz: 6362c9a41314a6b66ac73ab8d11111e08947e0e3d6e4d7d4f43a593270947400242aa29ec82bf514ea93b4f4497f769bbb856117e8e74c1a9271eeb90837639b
+  metadata.gz: d1f6c8cbc8325af57aaae715afbfd12d96b279ae54a96ee0daedcb861f13fd10e662e0d350ef0139ab483c4423160844415fb7d0c7037c1e34e5fd498856a30f
+  data.tar.gz: 41100c94a4eaedc6de3ef4d57c0aa1ba93abd962c149d24d3852184bf34c83470a5ed381111918d3eefeb17eba290d2d08241722cacf54b43c4ed5aeba51f12c

data/CHANGELOG.md

@@ -8,6 +8,38 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 Nothing yet...
 
+## [3.13.0] - 2021-09-25
+
+### Added
+- Support added for more versions of the `cucumber-gherkin` gem
+   - 22.x
+
+## [3.12.0] - 2021-09-09
+
+### Added
+- Support added for more versions of the `cucumber-gherkin` gem
+   - 21.x
+
+## [3.11.0] - 2021-07-31
+
+### Added
+- Support added for more versions of the `cucumber-gherkin` gem
+    - 20.x
+
+### Fixed
+- `Rule` models are now returnable from `Model#get_ancestor()`. Updating that method was missed when `Rule` models 
+  were first added.
+
+## [3.10.0] - 2021-05-28
+
+### Added
+ - Support added for more versions of the `cucumber-gherkin` gem
+   - 19.x
+
+### Fixed
+ - `Rule` models now clear out parsing data for their tags. This data was an unintentional duplication of the 
+   parsing data that the `Tag` models already contained. 
+
 
 ## [3.9.0] - 2021-04-23
 
@@ -376,7 +408,11 @@ Nothing yet...
  - Initial release
 
 
-[Unreleased]: https://github.com/enkessler/cuke_modeler/compare/v3.9.0...HEAD
+[Unreleased]: https://github.com/enkessler/cuke_modeler/compare/v3.13.0...HEAD
+[3.13.0]: https://github.com/enkessler/cuke_modeler/compare/v3.12.0...v3.13.0
+[3.12.0]: https://github.com/enkessler/cuke_modeler/compare/v3.11.0...v3.12.0
+[3.11.0]: https://github.com/enkessler/cuke_modeler/compare/v3.10.0...v3.11.0
+[3.10.0]: https://github.com/enkessler/cuke_modeler/compare/v3.9.0...v3.10.0
 [3.9.0]: https://github.com/enkessler/cuke_modeler/compare/v3.8.0...v3.9.0
 [3.8.0]: https://github.com/enkessler/cuke_modeler/compare/v3.7.0...v3.8.0
 [3.7.0]: https://github.com/enkessler/cuke_modeler/compare/v3.6.0...v3.7.0

data/README.md

@@ -8,8 +8,7 @@ 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=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)
+[![Build Status](https://github.com/enkessler/cuke_modeler/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/enkessler/cuke_modeler/actions/workflows/ci.yml?query=branch%3Amaster)
 [![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?branch=master)](https://inch-ci.org/github/enkessler/cuke_modeler)

data/cuke_modeler.gemspec

@@ -36,11 +36,10 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '>= 2.3', '< 4.0'
 
-  spec.add_runtime_dependency 'cucumber-gherkin', '< 19.0'
+  spec.add_runtime_dependency 'cucumber-gherkin', '< 23.0'
 
   spec.add_development_dependency 'bundler', '< 3.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', '< 7.0.0'
@@ -50,8 +49,8 @@ Gem::Specification.new do |spec|
   # 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 'simplecov', '< 1.0'
+  spec.add_development_dependency 'simplecov-lcov', '< 1.0'
   spec.add_development_dependency 'test-unit', '< 4.0.0'
   spec.add_development_dependency 'yard', '< 1.0'
 end

data/lib/cuke_modeler/adapters/gherkin_18_adapter.rb

@@ -12,6 +12,8 @@ module CukeModeler
     def adapt_rule(rule_ast)
       adapted_rule = super(rule_ast)
 
+      clear_child_elements(adapted_rule, [[:rule, :tags]])
+
       # Tagging of Rules was added in Gherkin 18
       adapted_rule['tags'] = adapt_tags(rule_ast[:rule])
 

data/lib/cuke_modeler/adapters/gherkin_19_adapter.rb

@@ -0,0 +1,61 @@
+require_relative 'gherkin_18_adapter'
+
+
+module CukeModeler
+
+  # NOT A PART OF THE PUBLIC API
+  # An adapter that can convert the output of version 19.x of the *cucumber-gherkin* gem into input that is consumable
+  # by this gem.
+  class Gherkin19Adapter < Gherkin18Adapter
+
+    # Adapts the AST sub-tree that is rooted at the given step node.
+    def adapt_step(step_ast)
+      adapted_step = super(step_ast)
+
+      clear_child_elements(adapted_step, [[:dataTable],
+                                          [:docString]])
+
+      if step_ast[:docString]
+        adapted_step['doc_string'] = adapt_doc_string(step_ast[:docString])
+      elsif step_ast[:dataTable]
+        adapted_step['table'] = adapt_step_table(step_ast[:dataTable])
+      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 = super(doc_string_ast)
+
+      adapted_doc_string['content_type'] = doc_string_ast[:mediaType]
+
+      adapted_doc_string
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given example node.
+    def adapt_example(example_ast)
+      adapted_example = super(example_ast)
+
+      clear_child_elements(adapted_example, [[:tableHeader],
+                                             [:tableBody]])
+
+      adapted_example['rows'] << adapt_table_row(example_ast[:tableHeader]) if example_ast[:tableHeader]
+
+      example_ast[:tableBody].each do |row|
+        adapted_example['rows'] << adapt_table_row(row)
+      end
+
+      adapted_example
+    end
+
+
+    private
+
+
+    def test_has_examples?(ast_node)
+      ast_node[:scenario][:examples].any?
+    end
+
+  end
+end

data/lib/cuke_modeler/adapters/gherkin_20_adapter.rb

@@ -0,0 +1,337 @@
+require_relative 'gherkin_base_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 20.x of the *cucumber-gherkin* gem into input that is consumable
+  # by this gem.
+  class Gherkin20Adapter < GherkinBaseAdapter
+
+    # 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, :tags],
+                                          [: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['tags'] = adapt_tags(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)
+      file_ast.comments.map { |comment| adapt_comment(comment) }
+    end
+
+    def adapt_tags(element_ast)
+      element_ast.tags.map { |tag| adapt_tag(tag) }
+    end
+
+    def adapt_steps(element_ast)
+      element_ast.steps.map { |step| adapt_step(step) }
+    end
+
+    def adapt_examples(element_ast)
+      element_ast.examples.map { |example| adapt_example(example) }
+    end
+
+    def adapt_child_elements(element_ast)
+      adapted_children = []
+
+      element_ast.children.each do |child_element|
+        adapted_children << if child_element.background
+                              adapt_background(child_element)
+                            elsif child_element.respond_to?(:rule) && child_element.rule
+                              adapt_rule(child_element)
+                            else
+                              adapt_test(child_element)
+                            end
+      end
+
+      adapted_children
+    end
+
+    def adapt_test(test_ast)
+      if test_has_examples?(test_ast) || test_uses_outline_keyword?(test_ast)
+        adapt_outline(test_ast)
+      else
+        adapt_scenario(test_ast)
+      end
+    end
+
+    def clear_child_elements(ast, child_paths)
+      # rubocop:disable Security/Eval - This is not blind data
+      child_paths.each do |traversal_path|
+        # Wipe the value if it's there but don't add any attributes to the object if it didn't already have them
+        if eval("ast['cuke_modeler_parsing_data'].#{traversal_path.join('.')}", binding, __FILE__, __LINE__)
+          property_path = traversal_path[0..-2].join('.')
+          eval("ast['cuke_modeler_parsing_data']#{property_path.empty? ? '' : '.' + property_path}.instance_variable_set(\"@#{traversal_path.last}\", nil)", binding, __FILE__, __LINE__) # rubocop:disable Layout/LineLength
+        end
+      end
+      # rubocop:enable Security/Eval
+    end
+
+    def test_has_examples?(ast_node)
+      ast_node.scenario.examples.any?
+    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

data/lib/cuke_modeler/adapters/gherkin_21_adapter.rb

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

data/lib/cuke_modeler/adapters/gherkin_22_adapter.rb

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

data/lib/cuke_modeler/adapters/gherkin_9_adapter.rb

@@ -1,3 +1,5 @@
+require_relative 'gherkin_base_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
 
@@ -6,7 +8,7 @@ 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.
-  class Gherkin9Adapter
+  class Gherkin9Adapter < GherkinBaseAdapter
 
     # Adapts the given AST into the shape that this gem expects
     def adapt(ast)
@@ -322,12 +324,9 @@ module CukeModeler
       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|
+        # Wipe the value if it's there but don't add any keys to the hash if it didn't already have them
         if ast['cuke_modeler_parsing_data'].dig(*traversal_path)
           bury(ast['cuke_modeler_parsing_data'], traversal_path, nil)
         end
@@ -346,11 +345,11 @@ module CukeModeler
     end
 
     def test_node?(ast_node)
-      ast_node[:scenario]
+      !ast_node[:scenario].nil?
     end
 
     def test_has_examples?(ast_node)
-      ast_node[:scenario][:examples]
+      !ast_node[:scenario][:examples].nil?
     end
 
     def test_uses_outline_keyword?(test_ast)

data/lib/cuke_modeler/adapters/gherkin_base_adapter.rb

@@ -0,0 +1,14 @@
+module CukeModeler
+
+  # NOT A PART OF THE PUBLIC API
+  # A class providing some basic and common adapter functionality.
+  class GherkinBaseAdapter
+
+    private
+
+    def save_original_data(adapted_ast, raw_ast)
+      adapted_ast['cuke_modeler_parsing_data'] = Marshal.load(Marshal.dump(raw_ast))
+    end
+
+  end
+end

data/lib/cuke_modeler/nested.rb

@@ -30,6 +30,7 @@ module CukeModeler
         directory: [Directory],
         feature_file: [FeatureFile],
         feature: [Feature],
+        rule: [Rule],
         test: [Scenario, Outline, Background],
         background: [Background],
         scenario: [Scenario],

data/lib/cuke_modeler/parsing.rb

@@ -1,3 +1,5 @@
+# rubocop:disable Metrics/ModuleLength - Just not going to worry about this
+
 # Have to at least load some version of the gem before which version of the gem has been loaded can
 # be determined and the rest of the needed files can be loaded.
 require 'gherkin'
@@ -7,7 +9,7 @@ require 'gherkin'
 # an 'adapter' appropriate to the version of the *cucumber-gherkin* gem that has been activated.
 gherkin_version = Gem.loaded_specs['cucumber-gherkin'].version.version
 gherkin_major_version = gherkin_version.match(/^(\d+)\./)[1].to_i
-supported_gherkin_versions = [9, 10, 11, 12, 13, 14, 15, 16, 17, 18]
+supported_gherkin_versions = (9..22)
 
 raise("Unknown Gherkin version: '#{gherkin_version}'") unless supported_gherkin_versions.include?(gherkin_major_version)
 
@@ -32,7 +34,7 @@ module CukeModeler
 
       # The dialects currently known by the gherkin gem
       def dialects
-        @dialects ||= Gherkin::DIALECTS
+        Gherkin::DIALECTS
       end
 
       # Parses the Cucumber feature given in *source_text* and returns a hash representation of
@@ -61,6 +63,40 @@ module CukeModeler
       # inside of it, so I'm leaving this here in case it changes again
       # rubocop:disable Lint/DuplicateMethods
       case gherkin_major_version
+        when 20, 21, 22
+          # TODO: make these methods private?
+          # NOT A PART OF THE PUBLIC API
+          # The method to use for parsing Gherkin text
+          def parsing_method(source_text, filename)
+            messages = Gherkin.from_source(filename,
+                                           source_text,
+                                           { include_gherkin_document: true })
+                              .to_a
+
+            error_message = messages.find(&:parse_error)
+            gherkin_ast_message = messages.find(&:gherkin_document)
+
+            raise error_message.parse_error.message if error_message
+
+            gherkin_ast_message.gherkin_document
+          end
+        when 19
+          # TODO: make these methods private?
+          # NOT A PART OF THE PUBLIC API
+          # The method to use for parsing Gherkin text
+          def parsing_method(source_text, filename)
+            messages = Gherkin.from_source(filename,
+                                           source_text,
+                                           { include_gherkin_document: true })
+                              .to_a.map(&:to_hash)
+
+            error_message = messages.find { |message| message[:parseError] }
+            gherkin_ast_message = messages.find { |message| message[:gherkinDocument] }
+
+            raise error_message[:parseError][:message] if error_message
+
+            gherkin_ast_message[:gherkinDocument]
+          end
         when 13, 14, 15, 16, 17, 18
           # TODO: make these methods private?
           # NOT A PART OF THE PUBLIC API
@@ -158,3 +194,5 @@ module CukeModeler
 
   end
 end
+
+# rubocop:enable Metrics/ModuleLength

data/lib/cuke_modeler/version.rb

@@ -1,4 +1,4 @@
 module CukeModeler
   # The gem version
-  VERSION = '3.9.0'.freeze
+  VERSION = '3.13.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cuke_modeler
 version: !ruby/object:Gem::Version
-  version: 3.9.0
+  version: 3.13.0
 platform: ruby
 authors:
 - Eric Kessler
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-23 00:00:00.000000000 Z
+date: 2021-09-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cucumber-gherkin
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "<"
       - !ruby/object:Gem::Version
-        version: '19.0'
+        version: '23.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "<"
       - !ruby/object:Gem::Version
-        version: '19.0'
+        version: '23.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -52,20 +52,6 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '5.0'
-- !ruby/object:Gem::Dependency
-  name: coveralls
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: 1.0.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: ffi
   requirement: !ruby/object:Gem::Requirement
@@ -160,16 +146,30 @@ dependencies:
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "<="
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov-lcov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 0.16.1
+        version: '1.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "<="
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 0.16.1
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: test-unit
   requirement: !ruby/object:Gem::Requirement
@@ -225,7 +225,12 @@ files:
 - lib/cuke_modeler/adapters/gherkin_16_adapter.rb
 - lib/cuke_modeler/adapters/gherkin_17_adapter.rb
 - lib/cuke_modeler/adapters/gherkin_18_adapter.rb
+- lib/cuke_modeler/adapters/gherkin_19_adapter.rb
+- lib/cuke_modeler/adapters/gherkin_20_adapter.rb
+- lib/cuke_modeler/adapters/gherkin_21_adapter.rb
+- lib/cuke_modeler/adapters/gherkin_22_adapter.rb
 - lib/cuke_modeler/adapters/gherkin_9_adapter.rb
+- lib/cuke_modeler/adapters/gherkin_base_adapter.rb
 - lib/cuke_modeler/containing.rb
 - lib/cuke_modeler/described.rb
 - lib/cuke_modeler/models/background.rb