cuke_modeler 1.3.0 → 2.1.0

data/lib/cuke_modeler/adapters/gherkin_7_adapter.rb

@@ -0,0 +1,307 @@
+module CukeModeler
+
+  # NOT A PART OF THE PUBLIC API
+  # An adapter that can convert the output of version 7.x of the *gherkin* gem into input that is consumable by this gem.
+
+  class Gherkin7Adapter
+
+    # Adapts the given AST into the shape that this gem expects
+    def adapt(parsed_ast)
+      # Saving off the original data
+      parsed_ast['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_ast))
+
+      # Removing parsed data for child elements in order to avoid duplicating data
+      parsed_ast['cuke_modeler_parsing_data'][:feature] = nil
+      parsed_ast['cuke_modeler_parsing_data'][:comments] = nil
+
+      parsed_ast['comments'] = []
+      parsed_ast[:comments].each do |comment|
+        adapt_comment!(comment)
+      end
+      parsed_ast['comments'].concat(parsed_ast.delete(:comments))
+
+      adapt_feature!(parsed_ast[:feature]) if parsed_ast[:feature]
+      parsed_ast['feature'] = parsed_ast.delete(:feature)
+
+      [parsed_ast]
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given feature node.
+    def adapt_feature!(parsed_feature)
+      # Saving off the original data
+      parsed_feature['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_feature))
+
+      # Removing parsed data for child elements in order to avoid duplicating data
+      parsed_feature['cuke_modeler_parsing_data'][:tags] = nil
+      parsed_feature['cuke_modeler_parsing_data'][:children] = nil
+
+      parsed_feature['keyword'] = parsed_feature.delete(:keyword)
+      parsed_feature['name'] = parsed_feature.delete(:name)
+      parsed_feature['description'] = parsed_feature.delete(:description)
+      parsed_feature['line'] = parsed_feature.delete(:location)[:line]
+
+      parsed_feature['elements'] = []
+      adapt_child_elements!(parsed_feature[:children])
+      parsed_feature['elements'].concat(parsed_feature.delete(:children))
+
+      parsed_feature['tags'] = []
+      parsed_feature[:tags].each do |tag|
+        adapt_tag!(tag)
+      end
+      parsed_feature['tags'].concat(parsed_feature.delete(:tags))
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given background node.
+    def adapt_background!(parsed_background)
+      # Saving off the original data
+      parsed_background['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_background))
+
+      # Removing parsed data for child elements in order to avoid duplicating data
+      parsed_background['cuke_modeler_parsing_data'][:background][:steps] = nil
+
+      parsed_background['type'] = 'Background'
+      parsed_background['keyword'] = parsed_background[:background].delete(:keyword)
+      parsed_background['name'] = parsed_background[:background].delete(:name)
+      parsed_background['description'] = parsed_background[:background].delete(:description)
+      parsed_background['line'] = parsed_background[:background].delete(:location)[:line]
+
+      parsed_background['steps'] = []
+      parsed_background[:background][:steps].each do |step|
+        adapt_step!(step)
+      end
+      parsed_background['steps'].concat(parsed_background[:background].delete(:steps))
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given scenario node.
+    def adapt_scenario!(parsed_test)
+      # Removing parsed data for child elements in order to avoid duplicating data
+      parsed_test['cuke_modeler_parsing_data'][:scenario][:tags] = nil
+      parsed_test['cuke_modeler_parsing_data'][:scenario][:steps] = nil
+
+      parsed_test['type'] = 'Scenario'
+      parsed_test['keyword'] = parsed_test[:scenario].delete(:keyword)
+      parsed_test['name'] = parsed_test[:scenario].delete(:name)
+      parsed_test['description'] = parsed_test[:scenario].delete(:description)
+      parsed_test['line'] = parsed_test[:scenario].delete(:location)[:line]
+
+      parsed_test['tags'] = []
+      parsed_test[:scenario][:tags].each do |tag|
+        adapt_tag!(tag)
+      end
+      parsed_test['tags'].concat(parsed_test[:scenario].delete(:tags))
+
+      parsed_test['steps'] = []
+      parsed_test[:scenario][:steps].each do |step|
+        adapt_step!(step)
+      end
+      parsed_test['steps'].concat(parsed_test[:scenario].delete(:steps))
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given outline node.
+    def adapt_outline!(parsed_test)
+      # Removing parsed data for child elements in order to avoid duplicating data
+      parsed_test['cuke_modeler_parsing_data'][:scenario][:tags] = nil
+      parsed_test['cuke_modeler_parsing_data'][:scenario][:steps] = nil
+      parsed_test['cuke_modeler_parsing_data'][:scenario][:examples] = nil
+
+      parsed_test['type'] = 'ScenarioOutline'
+      parsed_test['keyword'] = parsed_test[:scenario].delete(:keyword)
+      parsed_test['name'] = parsed_test[:scenario].delete(:name)
+      parsed_test['description'] = parsed_test[:scenario].delete(:description)
+      parsed_test['line'] = parsed_test[:scenario].delete(:location)[:line]
+
+      parsed_test['tags'] = []
+      parsed_test[:scenario][:tags].each do |tag|
+        adapt_tag!(tag)
+      end
+      parsed_test['tags'].concat(parsed_test[:scenario].delete(:tags))
+
+      parsed_test['steps'] = []
+      parsed_test[:scenario][:steps].each do |step|
+        adapt_step!(step)
+      end
+      parsed_test['steps'].concat(parsed_test[:scenario].delete(:steps))
+
+      parsed_test['examples'] = []
+      parsed_test[:scenario][:examples].each do |step|
+        adapt_example!(step)
+      end
+      parsed_test['examples'].concat(parsed_test[:scenario].delete(:examples))
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given example node.
+    def adapt_example!(parsed_example)
+      # Saving off the original data
+      parsed_example['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_example))
+
+      # Removing parsed data for child elements in order to avoid duplicating data
+      parsed_example['cuke_modeler_parsing_data'][:tags] = nil
+      parsed_example['cuke_modeler_parsing_data'][:table_header] = nil
+      parsed_example['cuke_modeler_parsing_data'][:table_body] = nil
+
+      parsed_example['keyword'] = parsed_example.delete(:keyword)
+      parsed_example['name'] = parsed_example.delete(:name)
+      parsed_example['line'] = parsed_example.delete(:location)[:line]
+      parsed_example['description'] = parsed_example.delete(:description)
+
+      parsed_example['rows'] = []
+
+      if parsed_example[:table_header]
+        adapt_table_row!(parsed_example[:table_header])
+        parsed_example['rows'] << parsed_example.delete(:table_header)
+      end
+
+      if parsed_example[:table_body]
+        parsed_example[:table_body].each do |row|
+          adapt_table_row!(row)
+        end
+        parsed_example['rows'].concat(parsed_example.delete(:table_body))
+      end
+
+      parsed_example['tags'] = []
+      parsed_example[:tags].each do |tag|
+        adapt_tag!(tag)
+      end
+      parsed_example['tags'].concat(parsed_example.delete(:tags))
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given tag node.
+    def adapt_tag!(parsed_tag)
+      # Saving off the original data
+      parsed_tag['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_tag))
+
+      parsed_tag['name'] = parsed_tag.delete(:name)
+      parsed_tag['line'] = parsed_tag.delete(:location)[:line]
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given comment node.
+    def adapt_comment!(parsed_comment)
+      # Saving off the original data
+      parsed_comment['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_comment))
+
+      parsed_comment['text'] = parsed_comment.delete(:text)
+      parsed_comment['line'] = parsed_comment.delete(:location)[:line]
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given step node.
+    def adapt_step!(parsed_step)
+      # Saving off the original data
+      parsed_step['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_step))
+
+      # Removing parsed data for child elements in order to avoid duplicating data
+      parsed_step['cuke_modeler_parsing_data'][:data_table] = nil
+      parsed_step['cuke_modeler_parsing_data'][:doc_string] = nil
+
+      parsed_step['keyword'] = parsed_step.delete(:keyword)
+      parsed_step['name'] = parsed_step.delete(:text)
+      parsed_step['line'] = parsed_step.delete(:location)[:line]
+
+
+      case
+        when parsed_step[:doc_string]
+          adapt_doc_string!(parsed_step[:doc_string])
+          parsed_step['doc_string'] = parsed_step.delete(:doc_string)
+        when parsed_step[:data_table]
+          adapt_step_table!(parsed_step[:data_table])
+          parsed_step['table'] = parsed_step.delete(:data_table)
+        else
+          # Step has no extra argument
+      end
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given doc string node.
+    def adapt_doc_string!(parsed_doc_string)
+      # Saving off the original data
+      parsed_doc_string['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_doc_string))
+
+      parsed_doc_string['value'] = parsed_doc_string.delete(:content)
+      parsed_doc_string['content_type'] = parsed_doc_string.delete(:content_type).strip # TODO: fix bug in Gherkin so that this whitespace is already trimmed off
+      parsed_doc_string['line'] = parsed_doc_string.delete(:location)[:line]
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given table node.
+    def adapt_step_table!(parsed_step_table)
+      # Saving off the original data
+      parsed_step_table['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_step_table))
+
+      # Removing parsed data for child elements in order to avoid duplicating data
+      parsed_step_table['cuke_modeler_parsing_data'][:rows] = nil
+
+      parsed_step_table['rows'] = []
+      parsed_step_table[:rows].each do |row|
+        adapt_table_row!(row)
+      end
+      parsed_step_table['rows'].concat(parsed_step_table.delete(:rows))
+      parsed_step_table['line'] = parsed_step_table.delete(:location)[:line]
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given row node.
+    def adapt_table_row!(parsed_table_row)
+      # Saving off the original data
+      parsed_table_row['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_table_row))
+
+      # Removing parsed data for child elements in order to avoid duplicating data which the child elements will themselves include
+      parsed_table_row['cuke_modeler_parsing_data'][:cells] = nil
+
+
+      parsed_table_row['line'] = parsed_table_row.delete(:location)[:line]
+
+      parsed_table_row['cells'] = []
+      parsed_table_row[:cells].each do |row|
+        adapt_table_cell!(row)
+      end
+      parsed_table_row['cells'].concat(parsed_table_row.delete(:cells))
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given cell node.
+    def adapt_table_cell!(parsed_cell)
+      # Saving off the original data
+      parsed_cell['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_cell))
+
+      parsed_cell['value'] = parsed_cell.delete(:value)
+      parsed_cell['line'] = parsed_cell.delete(:location)[:line]
+    end
+
+
+    private
+
+
+    def adapt_child_elements!(parsed_children)
+      return if parsed_children.empty?
+
+      background_child = parsed_children.find { |child| child[:background] }
+
+      if background_child
+        adapt_background!(background_child)
+
+        remaining_children = parsed_children.reject { |child| child[:background] }
+      end
+
+      adapt_tests!(remaining_children || parsed_children)
+    end
+
+    def adapt_tests!(parsed_tests)
+      return unless parsed_tests
+
+      parsed_tests.each do |test|
+        adapt_test!(test)
+      end
+    end
+
+    def adapt_test!(parsed_test)
+      # Saving off the original data
+      parsed_test['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_test))
+
+
+      case
+        when parsed_test[:scenario] && parsed_test[:scenario][:examples].any?
+          adapt_outline!(parsed_test)
+        when parsed_test[:scenario]
+          adapt_scenario!(parsed_test)
+        else
+          raise(ArgumentError, "Unknown test type with keys: #{parsed_test.keys}")
+      end
+    end
+
+  end
+end

data/lib/cuke_modeler/adapters/gherkin_8_adapter.rb

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

data/lib/cuke_modeler/adapters/gherkin_9_adapter.rb

@@ -0,0 +1,12 @@
+require_relative 'gherkin_7_adapter'
+
+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.
+
+  class Gherkin9Adapter < Gherkin7Adapter
+
+  end
+
+end

data/lib/cuke_modeler/containing.rb

@@ -1,9 +1,25 @@
 module CukeModeler
 
+  # NOT A PART OF THE PUBLIC API
   # A mix-in module containing methods used by models that contain other models.
 
   module Containing
 
+    # Executes the given code block with every model that is a child of this model.
+    def each_descendant(&block)
+      children.each do |child_model|
+        block.call(child_model)
+        child_model.each_descendant(&block) if child_model.respond_to?(:each_descendant)
+      end
+    end
+
+    # Executes the given code block with this model and every model that is a child of this model.
+    def each_model(&block)
+      block.call(self)
+
+      each_descendant(&block)
+    end
+
 
     private
 

data/lib/cuke_modeler/described.rb

@@ -1,5 +1,6 @@
 module CukeModeler
 
+  # NOT A PART OF THE PUBLIC API
   # A mix-in module containing methods used by models that represent an element that has a description.
 
   module Described

data/lib/cuke_modeler/models/step.rb

@@ -33,9 +33,11 @@ module CukeModeler
     # Returns *true* if the two steps have the same base text (i.e. minus any keyword,
     # table, or doc string and *false* otherwise.
     def ==(other_step)
-      return false unless other_step.respond_to?(:text)
+      return false unless other_step.is_a?(CukeModeler::Step)
 
-      text == other_step.text
+      text_matches?(other_step) &&
+          table_matches?(other_step) &&
+          doc_string_matches?(other_step)
     end
 
     # Returns the model objects that belong to this model.
@@ -65,5 +67,32 @@ module CukeModeler
       parsed_file.first['feature']['elements'].first['steps'].first
     end
 
+    def text_matches?(other_step)
+      text == other_step.text
+    end
+
+    def table_matches?(other_step)
+      return false if (!block.is_a?(CukeModeler::Table) || !other_step.block.is_a?(CukeModeler::Table)) && (block.is_a?(CukeModeler::Table) || other_step.block.is_a?(CukeModeler::Table))
+      return true unless block.is_a?(CukeModeler::Table) && other_step.block.is_a?(CukeModeler::Table)
+
+      first_step_values  = block.rows.collect { |table_row| table_row.cells.map(&:value) }
+      second_step_values = other_step.block.rows.collect { |table_row| table_row.cells.map(&:value) }
+
+      first_step_values == second_step_values
+    end
+
+    def doc_string_matches?(other_step)
+      return false if (!block.is_a?(CukeModeler::DocString) || !other_step.block.is_a?(CukeModeler::DocString)) && (block.is_a?(CukeModeler::DocString) || other_step.block.is_a?(CukeModeler::DocString))
+      return true unless block.is_a?(CukeModeler::DocString) && other_step.block.is_a?(CukeModeler::DocString)
+
+      first_content       = block.content
+      first_content_type  = block.content_type
+      second_content      = other_step.block.content
+      second_content_type = other_step.block.content_type
+
+      (first_content == second_content) &&
+          (first_content_type == second_content_type)
+    end
+
   end
 end

data/lib/cuke_modeler/named.rb

@@ -1,5 +1,6 @@
 module CukeModeler
 
+  # NOT A PART OF THE PUBLIC API
   # A mix-in module containing methods used by models that represent an element that has a name.
 
   module Named

data/lib/cuke_modeler/nested.rb

@@ -1,5 +1,6 @@
 module CukeModeler
 
+  # NOT A PART OF THE PUBLIC API
   # A mix-in module containing methods used by models that are nested inside
   # of other models.
 

data/lib/cuke_modeler/parsed.rb

@@ -1,5 +1,6 @@
 module CukeModeler
 
+  # NOT A PART OF THE PUBLIC API
   # A mix-in module containing methods used by models that are parsed from source text.
 
   module Parsed

data/lib/cuke_modeler/parsing.rb

@@ -1,75 +1,48 @@
-module CukeModeler
-
-  # A module providing source text parsing functionality.
-
-  module Parsing
-
-
-    # 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. Try the old one first and then the
-    # new one.
-    begin
-      require 'gherkin'
-    rescue LoadError
-      require 'gherkin/parser'
-    end
-
-
-    # The *gherkin* gem loads differently and has different grammar rules across major versions. Parsing
-    # will be done with an 'adapter' appropriate to the version of the *gherkin* gem that has been activated.
-
-    case Gem.loaded_specs['gherkin'].version.version
-      when /^[54]\./
-        require 'gherkin/parser'
-        require 'cuke_modeler/adapters/gherkin_4_adapter'
-
-
-        # todo - make these methods private?
-        def self.parsing_method(source_text, _filename)
-          Gherkin::Parser.new.parse(source_text)
-        end
-
-        def self.adapter_class
-          CukeModeler::Gherkin4Adapter
-        end
-
-      when /^3\./
-        require 'gherkin/parser'
-        require 'cuke_modeler/adapters/gherkin_3_adapter'
+# 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. The entry points vary across versions,
+# so try them all until one of them works.
+begin
+  # Gherkin 2.x, 8.x, 9.x
+  require 'gherkin'
+rescue LoadError
+  begin
+    require 'gherkin/parser'
+  rescue LoadError
+    # Gherkin 6.x, 7.x
+    require 'gherkin/gherkin'
+  end
+end
 
 
-        def self.parsing_method(source_text, _filename)
-          Gherkin::Parser.new.parse(source_text)
-        end
+# The *gherkin* gem loads differently and has different grammar rules across major versions. Parsing
+# will be done with an 'adapter' appropriate to the version of the *gherkin* gem that has been activated.
+
+gherkin_version = Gem.loaded_specs['gherkin'].version.version
+gherkin_major_version = gherkin_version.match(/^(\d+)\./)[1].to_i
+
+case gherkin_major_version
+  when 6, 7, 8, 9
+    require 'gherkin/dialect'
+  when 3, 4, 5
+    require 'gherkin/parser'
+  when 2
+    require 'stringio'
+    require 'gherkin/formatter/json_formatter'
+    require 'gherkin'
+    require 'json'
+    require 'multi_json'
+  else
+    raise("Unknown Gherkin version: '#{gherkin_version}'")
+end
 
-        def self.adapter_class
-          CukeModeler::Gherkin3Adapter
-        end
+require "cuke_modeler/adapters/gherkin_#{gherkin_major_version}_adapter"
 
-      else # Assume version 2.x
-        require 'stringio'
-        require 'gherkin/formatter/json_formatter'
-        require 'gherkin'
-        require 'json'
-        require 'multi_json'
-        require 'cuke_modeler/adapters/gherkin_2_adapter'
-
-
-        def self.parsing_method(source_text, filename)
-          io = StringIO.new
-          formatter = Gherkin::Formatter::JSONFormatter.new(io)
-          parser = Gherkin::Parser::Parser.new(formatter)
-          parser.parse(source_text, filename, 0)
-          formatter.done
-          MultiJson.load(io.string)
-        end
 
-        def self.adapter_class
-          CukeModeler::Gherkin2Adapter
-        end
+module CukeModeler
 
-    end
+  # A module providing source text parsing functionality.
 
+  module Parsing
 
     class << self
 
@@ -96,17 +69,92 @@ module CukeModeler
       def parse_text(source_text, filename = 'cuke_modeler_fake_file.feature')
         raise(ArgumentError, "Text to parse must be a String but got #{source_text.class}") unless source_text.is_a?(String)
 
-
         begin
           parsed_result = parsing_method(source_text, filename)
         rescue => e
           raise(ArgumentError, "Error encountered while parsing '#{filename}'\n#{e.class} - #{e.message}")
         end
 
-        adapted_result = adapter_class.new.adapt(parsed_result)
+        adapter_class.new.adapt(parsed_result)
+      end
+
 
+      gherkin_version = Gem.loaded_specs['gherkin'].version.version
+      gherkin_major_version = gherkin_version.match(/^(\d+)\./)[1].to_i
+
+      case gherkin_major_version
+        when 9
+          # 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)
+
+            potential_error_message = messages.find { |message| message[:attachment] }
+            gherkin_ast_message = messages.find { |message| message[:gherkin_document] }
+
+            if potential_error_message
+              raise potential_error_message[:attachment][:data] if potential_error_message[:attachment][:data] =~ /expected.*got/
+            end
+
+            gherkin_ast_message[:gherkin_document]
+          end
+        when 8
+          # 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)
+
+            potential_error_message = messages.find { |message| message[:attachment] }
+            gherkin_ast_message = messages.find { |message| message[:gherkinDocument] }
+
+            if potential_error_message
+              raise potential_error_message[:attachment][:data] if potential_error_message[:attachment][:data] =~ /expected.*got/
+            end
+
+            gherkin_ast_message[:gherkinDocument]
+          end
+        when 6, 7
+          # NOT A PART OF THE PUBLIC API
+          # The method to use for parsing Gherkin text
+          def parsing_method(source_text, filename)
+            messages = Gherkin::Gherkin.from_source(filename, source_text).to_a.map(&:to_hash)
+
+            potential_error_message = messages.find { |message| message[:attachment] }
+            gherkin_ast_message = messages.find { |message| message[:gherkinDocument] }
+
+            if potential_error_message
+              raise potential_error_message[:attachment][:data] if potential_error_message[:attachment][:data] =~ /expected.*got/
+            end
+
+            gherkin_ast_message[:gherkinDocument]
+          end
+        when 3, 4, 5
+          # todo - make these methods private?
+          # NOT A PART OF THE PUBLIC API
+          # The method to use for parsing Gherkin text
+          # Filename isn't used by this version of Gherkin but keeping the parameter so that the calling method only has to know one method signature
+          def parsing_method(source_text, _filename)
+            Gherkin::Parser.new.parse(source_text)
+          end
+        when 2
+          # NOT A PART OF THE PUBLIC API
+          # The method to use for parsing Gherkin text
+          def parsing_method(source_text, filename)
+            io = StringIO.new
+            formatter = Gherkin::Formatter::JSONFormatter.new(io)
+            parser = Gherkin::Parser::Parser.new(formatter)
+            parser.parse(source_text, filename, 0)
+            formatter.done
+            MultiJson.load(io.string)
+          end
+        else
+          raise("Unknown Gherkin version: '#{gherkin_version}'")
+      end
 
-        adapted_result
+      # NOT A PART OF THE PUBLIC API
+      # The adapter to use when converting an AST to a standard internal shape
+      define_method('adapter_class') do
+        CukeModeler.const_get("Gherkin#{gherkin_major_version}Adapter")
       end
 
     end