gauge-ruby 0.4.3 → 0.5.0

data/lib/processors/datastore_init_processor.rb

@@ -22,15 +22,15 @@ module Gauge
   module Processors
     def process_datastore_init(message)
       case message.messageType
-        when Messages::Message::MessageType::SuiteDataStoreInit
+        when :SuiteDataStoreInit
           DataStoreFactory.suite_datastore.clear
-        when Messages::Message::MessageType::SpecDataStoreInit
+        when :SpecDataStoreInit
           DataStoreFactory.spec_datastore.clear
-        when Messages::Message::MessageType::ScenarioDataStoreInit
+        when :ScenarioDataStoreInit
           DataStoreFactory.scenario_datastore.clear
       end
       execution_status_response = Messages::ExecutionStatusResponse.new(:executionResult => Messages::ProtoExecutionResult.new(:failed => false, :executionTime => 0))
-      Messages::Message.new(:messageType => Messages::Message::MessageType::ExecutionStatusResponse, :messageId => message.messageId, :executionStatusResponse => execution_status_response)
+      Messages::Message.new(:messageType => :ExecutionStatusResponse, :messageId => message.messageId, :executionStatusResponse => execution_status_response)
     end
   end
 end

data/lib/processors/execution_handler.rb

@@ -33,7 +33,7 @@ module Gauge
 
       def handle_pass(message, execution_time)
         execution_status_response = Messages::ExecutionStatusResponse.new(:executionResult => Messages::ProtoExecutionResult.new(:failed => false, :executionTime => execution_time))
-        Messages::Message.new(:messageType => Messages::Message::MessageType::ExecutionStatusResponse, :messageId => message.messageId, :executionStatusResponse => execution_status_response)
+        Messages::Message.new(:messageType => :ExecutionStatusResponse, :messageId => message.messageId, :executionStatusResponse => execution_status_response)
       end
 
       def handle_failure(message, exception, execution_time, recoverable)
@@ -48,9 +48,10 @@ module Gauge
              :recoverableError => recoverable,
              :errorMessage => exception.message,
              :stackTrace => code_snippet + stacktrace,
-             :executionTime => execution_time,
-             :screenShot => screenshot_bytes))
-        Messages::Message.new(:messageType => Messages::Message::MessageType::ExecutionStatusResponse,
+             :executionTime => execution_time))
+        screenshot = screenshot_bytes
+        execution_status_response.executionResult.screenShot = screenshot if !screenshot.nil?
+        Messages::Message.new(:messageType => :ExecutionStatusResponse,
           :messageId => message.messageId, :executionStatusResponse => execution_status_response)
       end
 
@@ -77,7 +78,7 @@ module Gauge
       def create_param_values parameters
         params = []
         parameters.each do |param|
-          if ((param.parameterType == Messages::Parameter::ParameterType::Table) ||(param.parameterType == Messages::Parameter::ParameterType::Special_Table))
+          if ((param.parameterType == :Table) ||(param.parameterType == :Special_Table))
             gtable = Gauge::Table.new(param.table)
             params.push gtable
           else

data/lib/processors/execution_hook_processors.rb

@@ -57,7 +57,7 @@ module Gauge
 
     def process_step_execution_end_request(message)
       response = handle_hooks_execution(MethodCache.get_after_step_hooks, message, message.stepExecutionEndingRequest.currentExecutionInfo)
-      response.executionStatusResponse.executionResult.message = Gauge::GaugeMessages.instance.get
+      response.executionStatusResponse.executionResult.message = Google::Protobuf::RepeatedField.new(:string, Gauge::GaugeMessages.instance.get)
       return response
     end
   end

data/lib/processors/implementation_file_list_processor.rb

@@ -20,10 +20,14 @@ require_relative '../util'
 module Gauge
   module Processors
     def process_implementation_file_list_request(message)
+      r = implementation_files()
+      Messages::Message.new(:messageType => :ImplementationFileListResponse, :messageId => message.messageId, :implementationFileListResponse => r)
+    end
+
+    def implementation_files()
       implPath = Util.get_step_implementation_dir
       fileList = Dir["#{implPath}/**/*.rb"]
-      r = Messages::ImplementationFileListResponse.new(:implementationFilePaths => fileList)
-      Messages::Message.new(:messageType => Messages::Message::MessageType::ImplementationFileListResponse, :messageId => message.messageId, :implementationFileListResponse => r)
+      Messages::ImplementationFileListResponse.new(:implementationFilePaths => fileList)
     end
   end
 end

data/lib/processors/implementation_glob_pattern_processor.rb

@@ -0,0 +1,36 @@
+# Copyright 2018 ThoughtWorks, Inc.
+
+# This file is part of Gauge-Ruby.
+
+# Gauge-Ruby is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# Gauge-Ruby is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with Gauge-Ruby.  If not, see <http://www.gnu.org/licenses/>.
+
+require_relative '../util'
+
+module Gauge
+  module Processors
+    def process_implementation_glob_pattern_request(message)
+      r = implementation_glob_pattern_response
+      Messages::Message.new(
+        messageType: Messages::Message::MessageType::ImplementationFileGlobPatternResponse,
+        messageId: message.messageId,
+        implementationFileGlobPatternResponse: r
+      )
+    end
+
+    def implementation_glob_pattern_response
+      implPath = Util.get_step_implementation_dir
+      Messages::ImplementationFileGlobPatternResponse.new(globPatterns: ["#{implPath}/**/*.rb"])
+    end
+  end
+end

data/lib/processors/refactor_step_request_processor.rb

@@ -21,19 +21,25 @@ module Gauge
   module Processors
     def refactor_step(message)
       request = message.refactorRequest
-      refactor_response = Messages::RefactorResponse.new(success: true)
+      response = refactor_response(request)
+      Messages::Message.new(messageType: :RefactorResponse, messageId: message.messageId, refactorResponse: response)
+    end
+
+    def refactor_response(request)
+      response = Messages::RefactorResponse.new(success: true)
       begin
         step_info = get_step request.oldStepValue.stepValue
         refactored_code = CodeParser.refactor step_info, request.paramPositions, request.newStepValue
         file = step_info[:locations][0][:file]
         File.write file, refactored_code if request.saveChanges
-        refactor_response.filesChanged = [file]
-        refactor_response.fileChanges = [Messages::FileChanges.new(:fileName => file, :fileContent => refactored_code)]
+        response.filesChanged.push(file)
+        changes = Messages::FileChanges.new(fileName: file, fileContent: refactored_code)
+        response.fileChanges.push(changes)
       rescue Exception => e
-        refactor_response.success = false
-        refactor_response.error = e.message
+        response.success = false
+        response.error = e.message
       end
-      Messages::Message.new(:messageType => Messages::Message::MessageType::RefactorResponse, :messageId => message.messageId, refactorResponse: refactor_response)
+      response
     end
 
     def get_step(step_text)
@@ -42,4 +48,4 @@ module Gauge
       MethodCache.get_step_info(step_text)
     end
   end
-end
+end

data/lib/processors/step_name_request_processor.rb

@@ -18,18 +18,20 @@
 module Gauge
   module Processors
     def process_step_name_request(message)
-      step_value = message.stepNameRequest.stepValue
-      if MethodCache.valid_step?(step_value)
-        step_text = MethodCache.get_step_text(step_value)
-        has_alias = MethodCache.has_alias?(step_text)
-        loc = MethodCache.get_step_info(step_value)[:locations][0]
-        span = Gauge::Messages::Span.new(start: loc[:span].begin.line, end: loc[:span].end.line, startChar: loc[:span].begin.column, endChar: loc[:span].end.column)
-        r = Messages::StepNameResponse.new(isStepPresent: true, stepName: [step_text], hasAlias: has_alias, fileName: loc[:file], span: span)
-        Messages::Message.new(:messageType => Messages::Message::MessageType::StepNameResponse, :messageId => message.messageId, :stepNameResponse => r)
-      else
-        r = Messages::StepNameResponse.new(isStepPresent: false, stepName: [''], hasAlias: false, fileName: '', span: nil)
-        Messages::Message.new(:messageType => Messages::Message::MessageType::StepNameResponse, :messageId => message.messageId, :stepNameResponse => r)
+      r = step_name_response(message.stepNameRequest)
+      Messages::Message.new(messageType: :StepNameResponse, messageId: message.messageId, stepNameResponse: r)
+    end
+
+    def step_name_response(request)
+      step_value = request.stepValue
+      unless MethodCache.valid_step?(step_value)
+        return Messages::StepNameResponse.new(isStepPresent: false, stepName: [''], hasAlias: false, fileName: '', span: nil)
       end
+      step_text = MethodCache.get_step_text(step_value)
+      has_alias = MethodCache.has_alias?(step_text)
+      loc = MethodCache.get_step_info(step_value)[:locations][0]
+      span = Gauge::Messages::Span.new(start: loc[:span].begin.line, end: loc[:span].end.line, startChar: loc[:span].begin.column, endChar: loc[:span].end.column)
+      Messages::StepNameResponse.new(isStepPresent: true, stepName: [step_text], hasAlias: has_alias, fileName: loc[:file], span: span)
     end
   end
-end
+end

data/lib/processors/step_names_request_processor.rb

@@ -18,9 +18,13 @@
 module Gauge
   module Processors
     def process_step_names_request(message)
-      step_names_response = Messages::StepNamesResponse.new(:steps => MethodCache.all_steps)
-      Messages::Message.new(:messageType => Messages::Message::MessageType::StepNamesResponse,
-        :messageId => message.messageId, :stepNamesResponse => step_names_response)
+      r = step_names_response
+      Messages::Message.new(messageType: :StepNamesResponse,
+                            messageId: message.messageId, stepNamesResponse: r)
+    end
+
+    def step_names_response
+      Messages::StepNamesResponse.new(steps: MethodCache.all_steps)
     end
   end
-end
+end

data/lib/processors/step_positions_request_processor.rb

@@ -18,11 +18,15 @@
 module Gauge
   module Processors
     def process_step_positions_request(message)
-      file = message.stepPositionsRequest.filePath
+      r = step_positions(message.stepPositionsRequest)
+      Messages::Message.new(:messageType => :StepPositionsResponse, :messageId => message.messageId, :stepPositionsResponse => r)
+    end
+
+    def step_positions(request)
+      file = request.filePath
       positions = MethodCache.step_positions(file)
       p = create_step_position_messages(positions)
-      r = Messages::StepPositionsResponse.new(:stepPositions => p)
-      Messages::Message.new(:messageType => Messages::Message::MessageType::StepPositionsResponse, :messageId => message.messageId, :stepPositionsResponse => r)
+      Messages::StepPositionsResponse.new(:stepPositions => p)
     end
 
     def create_step_position_messages(positions)

data/lib/processors/step_validation_request_processor.rb

@@ -19,31 +19,36 @@ module Gauge
   module Processors
     def process_step_validation_request(message)
       request = message.stepValidateRequest
-      is_valid = true
-      msg,suggestion = ''
-      err_type = nil
+      Messages::Message.new(messageType: :StepValidateResponse,
+                            messageId: message.messageId,
+                            stepValidateResponse: step_validate_response(request))
+    end
+
+    def step_validate_response(request)
+      response = Messages::StepValidateResponse.new(isValid: true)
       if !MethodCache.valid_step? request.stepText
-        is_valid = false
-        msg = 'Step implementation not found'
-        err_type = Messages::StepValidateResponse::ErrorType::STEP_IMPLEMENTATION_NOT_FOUND
-        suggestion = create_suggestion(request.stepValue) unless request.stepValue.stepValue.empty?
+        suggestion = request.stepValue.stepValue.empty? ? '' : create_suggestion(request.stepValue)
+        response = Messages::StepValidateResponse.new(
+          isValid: false,
+          errorMessage: 'Step implementation not found',
+          errorType: Messages::StepValidateResponse::ErrorType::STEP_IMPLEMENTATION_NOT_FOUND,
+          suggestion: suggestion
+        )
       elsif MethodCache.multiple_implementation?(request.stepText)
-        is_valid = false
-        msg = "Multiple step implementations found for => '#{request.stepText}'"
-        err_type = Messages::StepValidateResponse::ErrorType::DUPLICATE_STEP_IMPLEMENTATION
-        suggestion = ''
+        response = Messages::StepValidateResponse.new(
+          isValid: false,
+          errorMessage: "Multiple step implementations found for => '#{request.stepText}'",
+          errorType: Messages::StepValidateResponse::ErrorType::DUPLICATE_STEP_IMPLEMENTATION
+        )
       end
-      step_validate_response = Messages::StepValidateResponse.new(:isValid => is_valid, :errorMessage => msg, :errorType => err_type, :suggestion => suggestion)
-      Messages::Message.new(:messageType => Messages::Message::MessageType::StepValidateResponse,
-                            :messageId => message.messageId,
-                            :stepValidateResponse => step_validate_response)
+      response
     end
 
     def create_suggestion(step_value)
       count = -1
-      step_text = step_value.stepValue.gsub(/{}/) {"<arg#{count += 1}>"}
-      params = step_value.parameters.map.with_index {|v,i| "arg#{i}"}.join ", "
+      step_text = step_value.stepValue.gsub(/{}/) { "<arg#{count += 1}>" }
+      params = step_value.parameters.map.with_index { |_v, i| "arg#{i}" }.join ', '
       "step '#{step_text}' do |#{params}|\n\traise 'Unimplemented Step'\nend"
     end
   end
-end
+end

data/lib/processors/stub_implementation_processor.rb

@@ -20,8 +20,13 @@ require_relative '../../lib/util'
 module Gauge
   module Processors
     def process_stub_implementation_code_request(message)
-      codes = message.stubImplementationCodeRequest.codes
-      file_path = message.stubImplementationCodeRequest.implementationFilePath
+      file_diff = implement_stub_response(message.stubImplementationCodeRequest)
+      Messages::Message.new(messageType: :FileDiff, messageId: message.messageId, fileDiff: file_diff)
+    end
+
+    def implement_stub_response(request)
+      codes = request.codes
+      file_path = request.implementationFilePath
       content = ''
       if File.file? file_path
         content = File.read(file_path)
@@ -29,10 +34,10 @@ module Gauge
         file_path = Util.get_file_name
       end
       text_diffs = [Messages::TextDiff.new(span: create_span(content, codes), content: codes.join("\n"))]
-      file_diff = Messages::FileDiff.new(filePath: file_path, textDiffs: text_diffs)
-      Messages::Message.new(messageType: Messages::Message::MessageType::FileDiff, messageId: message.messageId, fileDiff: file_diff)
+      Messages::FileDiff.new(filePath: file_path, textDiffs: text_diffs)
     end
 
+    private
     def create_span(content, codes)
       unless content.empty?
         eof_char = content.strip.length == content.length ? "\n" : ''

data/lib/spec_pb.rb

@@ -0,0 +1,226 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: spec.proto
+
+require 'google/protobuf'
+
+Google::Protobuf::DescriptorPool.generated_pool.build do
+  add_message "gauge.messages.ProtoSpec" do
+    optional :specHeading, :string, 1
+    repeated :items, :message, 2, "gauge.messages.ProtoItem"
+    optional :isTableDriven, :bool, 3
+    repeated :preHookFailures, :message, 4, "gauge.messages.ProtoHookFailure"
+    repeated :postHookFailures, :message, 5, "gauge.messages.ProtoHookFailure"
+    optional :fileName, :string, 6
+    repeated :tags, :string, 7
+    repeated :preHookMessages, :string, 8
+    repeated :postHookMessages, :string, 9
+    repeated :preHookMessage, :string, 10
+    repeated :postHookMessage, :string, 11
+  end
+  add_message "gauge.messages.ProtoItem" do
+    optional :itemType, :enum, 1, "gauge.messages.ProtoItem.ItemType"
+    optional :step, :message, 2, "gauge.messages.ProtoStep"
+    optional :concept, :message, 3, "gauge.messages.ProtoConcept"
+    optional :scenario, :message, 4, "gauge.messages.ProtoScenario"
+    optional :tableDrivenScenario, :message, 5, "gauge.messages.ProtoTableDrivenScenario"
+    optional :comment, :message, 6, "gauge.messages.ProtoComment"
+    optional :table, :message, 7, "gauge.messages.ProtoTable"
+    optional :tags, :message, 8, "gauge.messages.ProtoTags"
+  end
+  add_enum "gauge.messages.ProtoItem.ItemType" do
+    value :Step, 0
+    value :Comment, 1
+    value :Concept, 2
+    value :Scenario, 3
+    value :TableDrivenScenario, 4
+    value :Table, 5
+    value :Tags, 6
+  end
+  add_message "gauge.messages.ProtoScenario" do
+    optional :scenarioHeading, :string, 1
+    optional :failed, :bool, 2
+    repeated :contexts, :message, 3, "gauge.messages.ProtoItem"
+    repeated :scenarioItems, :message, 4, "gauge.messages.ProtoItem"
+    optional :preHookFailure, :message, 5, "gauge.messages.ProtoHookFailure"
+    optional :postHookFailure, :message, 6, "gauge.messages.ProtoHookFailure"
+    repeated :tags, :string, 7
+    optional :executionTime, :int64, 8
+    optional :skipped, :bool, 9
+    repeated :skipErrors, :string, 10
+    optional :ID, :string, 11
+    repeated :tearDownSteps, :message, 12, "gauge.messages.ProtoItem"
+    optional :span, :message, 13, "gauge.messages.Span"
+    optional :executionStatus, :enum, 14, "gauge.messages.ExecutionStatus"
+    repeated :preHookMessages, :string, 15
+    repeated :postHookMessages, :string, 16
+    repeated :preHookMessage, :string, 17
+    repeated :postHookMessage, :string, 18
+  end
+  add_message "gauge.messages.Span" do
+    optional :start, :int64, 1
+    optional :end, :int64, 2
+    optional :startChar, :int64, 3
+    optional :endChar, :int64, 4
+  end
+  add_message "gauge.messages.ProtoTableDrivenScenario" do
+    optional :scenario, :message, 1, "gauge.messages.ProtoScenario"
+    optional :tableRowIndex, :int32, 2
+  end
+  add_message "gauge.messages.ProtoStep" do
+    optional :actualText, :string, 1
+    optional :parsedText, :string, 2
+    repeated :fragments, :message, 3, "gauge.messages.Fragment"
+    optional :stepExecutionResult, :message, 4, "gauge.messages.ProtoStepExecutionResult"
+    repeated :preHookMessages, :string, 5
+    repeated :postHookMessages, :string, 6
+  end
+  add_message "gauge.messages.ProtoConcept" do
+    optional :conceptStep, :message, 1, "gauge.messages.ProtoStep"
+    repeated :steps, :message, 2, "gauge.messages.ProtoItem"
+    optional :conceptExecutionResult, :message, 3, "gauge.messages.ProtoStepExecutionResult"
+  end
+  add_message "gauge.messages.ProtoTags" do
+    repeated :tags, :string, 1
+  end
+  add_message "gauge.messages.Fragment" do
+    optional :fragmentType, :enum, 1, "gauge.messages.Fragment.FragmentType"
+    optional :text, :string, 2
+    optional :parameter, :message, 3, "gauge.messages.Parameter"
+  end
+  add_enum "gauge.messages.Fragment.FragmentType" do
+    value :Text, 0
+    value :Parameter, 1
+  end
+  add_message "gauge.messages.Parameter" do
+    optional :parameterType, :enum, 1, "gauge.messages.Parameter.ParameterType"
+    optional :value, :string, 2
+    optional :name, :string, 3
+    optional :table, :message, 4, "gauge.messages.ProtoTable"
+  end
+  add_enum "gauge.messages.Parameter.ParameterType" do
+    value :Static, 0
+    value :Dynamic, 1
+    value :Special_String, 2
+    value :Special_Table, 3
+    value :Table, 4
+  end
+  add_message "gauge.messages.ProtoComment" do
+    optional :text, :string, 1
+  end
+  add_message "gauge.messages.ProtoTable" do
+    optional :headers, :message, 1, "gauge.messages.ProtoTableRow"
+    repeated :rows, :message, 2, "gauge.messages.ProtoTableRow"
+  end
+  add_message "gauge.messages.ProtoTableRow" do
+    repeated :cells, :string, 1
+  end
+  add_message "gauge.messages.ProtoStepExecutionResult" do
+    optional :executionResult, :message, 1, "gauge.messages.ProtoExecutionResult"
+    optional :preHookFailure, :message, 2, "gauge.messages.ProtoHookFailure"
+    optional :postHookFailure, :message, 3, "gauge.messages.ProtoHookFailure"
+    optional :skipped, :bool, 4
+    optional :skippedReason, :string, 5
+  end
+  add_message "gauge.messages.ProtoExecutionResult" do
+    optional :failed, :bool, 1
+    optional :recoverableError, :bool, 2
+    optional :errorMessage, :string, 3
+    optional :stackTrace, :string, 4
+    optional :screenShot, :bytes, 5
+    optional :executionTime, :int64, 6
+    repeated :message, :string, 7
+    optional :errorType, :enum, 8, "gauge.messages.ProtoExecutionResult.ErrorType"
+  end
+  add_enum "gauge.messages.ProtoExecutionResult.ErrorType" do
+    value :ASSERTION, 0
+    value :VERIFICATION, 1
+  end
+  add_message "gauge.messages.ProtoHookFailure" do
+    optional :stackTrace, :string, 1
+    optional :errorMessage, :string, 2
+    optional :screenShot, :bytes, 3
+    optional :tableRowIndex, :int32, 4
+  end
+  add_message "gauge.messages.ProtoSuiteResult" do
+    repeated :specResults, :message, 1, "gauge.messages.ProtoSpecResult"
+    optional :preHookFailure, :message, 2, "gauge.messages.ProtoHookFailure"
+    optional :postHookFailure, :message, 3, "gauge.messages.ProtoHookFailure"
+    optional :failed, :bool, 4
+    optional :specsFailedCount, :int32, 5
+    optional :executionTime, :int64, 6
+    optional :successRate, :float, 7
+    optional :environment, :string, 8
+    optional :tags, :string, 9
+    optional :projectName, :string, 10
+    optional :timestamp, :string, 11
+    optional :specsSkippedCount, :int32, 12
+    repeated :preHookMessages, :string, 13
+    repeated :postHookMessages, :string, 14
+    repeated :preHookMessage, :string, 15
+    repeated :postHookMessage, :string, 16
+  end
+  add_message "gauge.messages.ProtoSpecResult" do
+    optional :protoSpec, :message, 1, "gauge.messages.ProtoSpec"
+    optional :scenarioCount, :int32, 2
+    optional :scenarioFailedCount, :int32, 3
+    optional :failed, :bool, 4
+    repeated :failedDataTableRows, :int32, 5
+    optional :executionTime, :int64, 6
+    optional :skipped, :bool, 7
+    optional :scenarioSkippedCount, :int32, 8
+    repeated :skippedDataTableRows, :int32, 9
+    repeated :errors, :message, 10, "gauge.messages.Error"
+  end
+  add_message "gauge.messages.Error" do
+    optional :type, :enum, 1, "gauge.messages.Error.ErrorType"
+    optional :filename, :string, 2
+    optional :lineNumber, :int32, 3
+    optional :message, :string, 4
+  end
+  add_enum "gauge.messages.Error.ErrorType" do
+    value :PARSE_ERROR, 0
+    value :VALIDATION_ERROR, 1
+  end
+  add_message "gauge.messages.ProtoStepValue" do
+    optional :stepValue, :string, 1
+    optional :parameterizedStepValue, :string, 2
+    repeated :parameters, :string, 3
+  end
+  add_enum "gauge.messages.ExecutionStatus" do
+    value :NOTEXECUTED, 0
+    value :PASSED, 1
+    value :FAILED, 2
+    value :SKIPPED, 3
+  end
+end
+
+module Gauge
+  module Messages
+    ProtoSpec = Google::Protobuf::DescriptorPool.generated_pool.lookup("gauge.messages.ProtoSpec").msgclass
+    ProtoItem = Google::Protobuf::DescriptorPool.generated_pool.lookup("gauge.messages.ProtoItem").msgclass
+    ProtoItem::ItemType = Google::Protobuf::DescriptorPool.generated_pool.lookup("gauge.messages.ProtoItem.ItemType").enummodule
+    ProtoScenario = Google::Protobuf::DescriptorPool.generated_pool.lookup("gauge.messages.ProtoScenario").msgclass
+    Span = Google::Protobuf::DescriptorPool.generated_pool.lookup("gauge.messages.Span").msgclass
+    ProtoTableDrivenScenario = Google::Protobuf::DescriptorPool.generated_pool.lookup("gauge.messages.ProtoTableDrivenScenario").msgclass
+    ProtoStep = Google::Protobuf::DescriptorPool.generated_pool.lookup("gauge.messages.ProtoStep").msgclass
+    ProtoConcept = Google::Protobuf::DescriptorPool.generated_pool.lookup("gauge.messages.ProtoConcept").msgclass
+    ProtoTags = Google::Protobuf::DescriptorPool.generated_pool.lookup("gauge.messages.ProtoTags").msgclass
+    Fragment = Google::Protobuf::DescriptorPool.generated_pool.lookup("gauge.messages.Fragment").msgclass
+    Fragment::FragmentType = Google::Protobuf::DescriptorPool.generated_pool.lookup("gauge.messages.Fragment.FragmentType").enummodule
+    Parameter = Google::Protobuf::DescriptorPool.generated_pool.lookup("gauge.messages.Parameter").msgclass
+    Parameter::ParameterType = Google::Protobuf::DescriptorPool.generated_pool.lookup("gauge.messages.Parameter.ParameterType").enummodule
+    ProtoComment = Google::Protobuf::DescriptorPool.generated_pool.lookup("gauge.messages.ProtoComment").msgclass
+    ProtoTable = Google::Protobuf::DescriptorPool.generated_pool.lookup("gauge.messages.ProtoTable").msgclass
+    ProtoTableRow = Google::Protobuf::DescriptorPool.generated_pool.lookup("gauge.messages.ProtoTableRow").msgclass
+    ProtoStepExecutionResult = Google::Protobuf::DescriptorPool.generated_pool.lookup("gauge.messages.ProtoStepExecutionResult").msgclass
+    ProtoExecutionResult = Google::Protobuf::DescriptorPool.generated_pool.lookup("gauge.messages.ProtoExecutionResult").msgclass
+    ProtoExecutionResult::ErrorType = Google::Protobuf::DescriptorPool.generated_pool.lookup("gauge.messages.ProtoExecutionResult.ErrorType").enummodule
+    ProtoHookFailure = Google::Protobuf::DescriptorPool.generated_pool.lookup("gauge.messages.ProtoHookFailure").msgclass
+    ProtoSuiteResult = Google::Protobuf::DescriptorPool.generated_pool.lookup("gauge.messages.ProtoSuiteResult").msgclass
+    ProtoSpecResult = Google::Protobuf::DescriptorPool.generated_pool.lookup("gauge.messages.ProtoSpecResult").msgclass
+    Error = Google::Protobuf::DescriptorPool.generated_pool.lookup("gauge.messages.Error").msgclass
+    Error::ErrorType = Google::Protobuf::DescriptorPool.generated_pool.lookup("gauge.messages.Error.ErrorType").enummodule
+    ProtoStepValue = Google::Protobuf::DescriptorPool.generated_pool.lookup("gauge.messages.ProtoStepValue").msgclass
+    ExecutionStatus = Google::Protobuf::DescriptorPool.generated_pool.lookup("gauge.messages.ExecutionStatus").enummodule
+  end
+end