gauge-ruby 0.5.2 → 0.5.3

data/lib/processors/cache_file_processor.rb

@@ -22,12 +22,7 @@ require_relative '../method_cache'
 module Gauge
   # @api private
   module Processors
-    def process_cache_file_request(message)
-      cache_file_response(message.cacheFileRequest)
-      nil
-    end
-
-    def cache_file_response(request)
+    def process_cache_file_request(request)
       f = request.filePath
       status =  Messages::CacheFileRequest::FileStatus.resolve(request.status)
       if (status == Messages::CacheFileRequest::FileStatus::CHANGED) || (status == Messages::CacheFileRequest::FileStatus::OPENED)

data/lib/processors/datastore_init_processor.rb

@@ -15,22 +15,27 @@
 # 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 '../datastore'
+require_relative "../datastore"
 
 module Gauge
-  # @api private
   module Processors
-    def process_datastore_init(message)
-      case message.messageType
-        when :SuiteDataStoreInit
-          DataStoreFactory.suite_datastore.clear
-        when :SpecDataStoreInit
-          DataStoreFactory.spec_datastore.clear
-        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 => :ExecutionStatusResponse, :messageId => message.messageId, :executionStatusResponse => execution_status_response)
+    def process_suite_data_store_init_request(_request)
+      DataStoreFactory.suite_datastore.clear
+      datastore_response
+    end
+
+    def process_spec_data_store_init_request(_request)
+      DataStoreFactory.spec_datastore.clear
+      datastore_response
+    end
+
+    def process_scenario_data_store_init_request(_request)
+      DataStoreFactory.scenario_datastore.clear
+      datastore_response
+    end
+
+    def datastore_response
+      Messages::ExecutionStatusResponse.new(:executionResult => Messages::ProtoExecutionResult.new(:failed => false, :executionTime => 0))
     end
   end
-end
+end

data/lib/processors/execute_step_request_processor.rb

@@ -21,17 +21,17 @@ module Gauge
   module Processors
     include ExecutionHandler
 
-    def process_execute_step_request(message)
-      step_text = message.executeStepRequest.parsedStepText
-      parameters = message.executeStepRequest.parameters
+    def process_execute_step_request(request)
+      step_text = request.parsedStepText
+      parameters = request.parameters
       args = create_param_values parameters
       start_time= Time.now
       begin
         Executor.execute_step step_text, args
       rescue Exception => e
-        return handle_failure message, e, time_elapsed_since(start_time), MethodCache.recoverable?(step_text)
+        return handle_failure e, time_elapsed_since(start_time), MethodCache.recoverable?(step_text)
       end
-      handle_pass message, time_elapsed_since(start_time)
+      handle_pass time_elapsed_since(start_time)
     end
   end
 end

data/lib/processors/execution_handler.rb

@@ -16,34 +16,35 @@
 # along with Gauge-Ruby.  If not, see <http://www.gnu.org/licenses/>.
 
 require 'os'
+require_relative '../table'
 
 module Gauge
   module Processors
     # @api private
     module ExecutionHandler
-      def handle_hooks_execution(hooks, message, currentExecutionInfo, should_filter=true)
+      def handle_hooks_execution(hooks, currentExecutionInfo, should_filter=true)
         start_time= Time.now
         execution_error = Executor.execute_hooks(hooks, currentExecutionInfo, should_filter)
         if execution_error == nil
-          return handle_pass message, time_elapsed_since(start_time)
+          return handle_pass time_elapsed_since(start_time)
         else
-          return handle_failure message, execution_error, time_elapsed_since(start_time), false
+          return handle_failure execution_error, time_elapsed_since(start_time), false
         end
       end
 
-      def handle_pass(message, execution_time)
+      def handle_pass(execution_time)
         execution_status_response = Messages::ExecutionStatusResponse.new(:executionResult => Messages::ProtoExecutionResult.new(:failed => false, :executionTime => execution_time))
-        execution_status_response.executionResult.screenshots += Gauge::GaugeScreenshot.instance.pending_screenshot
+        execution_status_response.executionResult.screenshotFiles += Gauge::GaugeScreenshot.instance.pending_screenshot
         execution_status_response.executionResult.message += Gauge::GaugeMessages.instance.pending_messages
-        Messages::Message.new(:messageType => :ExecutionStatusResponse, :messageId => message.messageId, :executionStatusResponse => execution_status_response)
+        execution_status_response
       end
 
       def get_filepath(stacktrace)
         toptrace = stacktrace.split("\n").first
-        return MethodCache.relative_filepath toptrace
+        MethodCache.relative_filepath toptrace
       end
     
-      def handle_failure(message, exception, execution_time, recoverable)
+      def handle_failure(exception, execution_time, recoverable)
         project_dir = File.basename(Dir.getwd)
         stacktrace =  exception.backtrace.select {|x| x.match(project_dir) && !x.match(File.join(project_dir, "vendor"))}.join("\n")+"\n"
         filepath = get_filepath(stacktrace)
@@ -56,15 +57,13 @@ module Gauge
              :errorMessage => exception.message,
              :stackTrace => code_snippet + stacktrace,
              :executionTime => execution_time))
-        screenshot = screenshot_bytes
-        if screenshot 
-          execution_status_response.executionResult.screenShot = screenshot
-          execution_status_response.executionResult.failureScreenshot = screenshot
+        screenshot_file = take_screenshot
+        if screenshot_file 
+          execution_status_response.executionResult.failureScreenshotFile = screenshot_file
         end
-        execution_status_response.executionResult.screenshots += Gauge::GaugeScreenshot.instance.pending_screenshot
+        execution_status_response.executionResult.screenshotFiles += Gauge::GaugeScreenshot.instance.pending_screenshot
         execution_status_response.executionResult.message += Gauge::GaugeMessages.instance.pending_messages
-        Messages::Message.new(:messageType => :ExecutionStatusResponse,
-          :messageId => message.messageId, :executionStatusResponse => execution_status_response)
+        execution_status_response
       end
 
       def get_code_snippet(filename, number)
@@ -73,12 +72,12 @@ module Gauge
         number.to_s + " | " + line.strip + "\n\n"
       end
 
-      def screenshot_bytes
-        return nil if (ENV['screenshot_on_failure'] || "").downcase == "false" || (which("gauge_screenshot").nil? && !Configuration.instance.custom_screengrabber)
+      def take_screenshot
+        return nil if (ENV['screenshot_on_failure'] || "").downcase == "false" || (which("gauge_screenshot").nil? && !Configuration.instance.custom_screengrabber?)
         begin
-          Configuration.instance.screengrabber.call
+          GaugeScreenshot.instance.capture_to_file
         rescue Exception => e
-          Gauge::Log.error e
+          GaugeLog.error e
           return nil
         end
       end

data/lib/processors/execution_hook_processors.rb

@@ -25,63 +25,39 @@ module Gauge
   module Processors
     include ExecutionHandler
 
-    def process_execution_start_request(message)
+    def process_execution_start_request(request)
       Gauge::MethodCache.clear
       Executor.load_steps(Util.get_step_implementation_dir)
-      response = handle_hooks_execution(MethodCache.get_before_suite_hooks, message,message.executionStartingRequest.currentExecutionInfo,false)
-      response.executionStatusResponse.executionResult.screenshots += Gauge::GaugeScreenshot.instance.pending_screenshot
-      response.executionStatusResponse.executionResult.message += Gauge::GaugeMessages.instance.pending_messages
-      return response
+      handle_hooks_execution(MethodCache.get_before_suite_hooks,request.currentExecutionInfo,false)
     end
 
-    def process_execution_end_request(message)
-      response = handle_hooks_execution(MethodCache.get_after_suite_hooks, message,message.executionEndingRequest.currentExecutionInfo, false)
-      response.executionStatusResponse.executionResult.screenshots += Gauge::GaugeScreenshot.instance.pending_screenshot
-      response.executionStatusResponse.executionResult.message += Gauge::GaugeMessages.instance.pending_messages
-      return response
+    def process_execution_end_request(request)
+      handle_hooks_execution(MethodCache.get_after_suite_hooks, request.currentExecutionInfo, false)
     end
 
-    def process_spec_execution_start_request(message)
-      response = handle_hooks_execution(MethodCache.get_before_spec_hooks, message,message.specExecutionStartingRequest.currentExecutionInfo)
-      response.executionStatusResponse.executionResult.screenshots += Gauge::GaugeScreenshot.instance.pending_screenshot
-      response.executionStatusResponse.executionResult.message += Gauge::GaugeMessages.instance.pending_messages
-      return response
+    def process_spec_execution_start_request(request)
+      handle_hooks_execution(MethodCache.get_before_spec_hooks,request.currentExecutionInfo)
     end
 
-    def process_spec_execution_end_request(message)
-      response = handle_hooks_execution(MethodCache.get_after_spec_hooks, message,message.specExecutionEndingRequest.currentExecutionInfo)
-      response.executionStatusResponse.executionResult.screenshots += Gauge::GaugeScreenshot.instance.pending_screenshot
-      response.executionStatusResponse.executionResult.message += Gauge::GaugeMessages.instance.pending_messages
-      return response
+    def process_spec_execution_end_request(request)
+      handle_hooks_execution(MethodCache.get_after_spec_hooks,request.currentExecutionInfo)
     end
 
-    def process_scenario_execution_start_request(message)
-      response = handle_hooks_execution(MethodCache.get_before_scenario_hooks, message,message.scenarioExecutionStartingRequest.currentExecutionInfo)
-      response.executionStatusResponse.executionResult.screenshots += Gauge::GaugeScreenshot.instance.pending_screenshot
-      response.executionStatusResponse.executionResult.message += Gauge::GaugeMessages.instance.pending_messages
-      return response
+    def process_scenario_execution_start_request(request)
+      handle_hooks_execution(MethodCache.get_before_scenario_hooks,request.currentExecutionInfo)
     end
 
 
-    def process_scenario_execution_end_request(message)
-      response = handle_hooks_execution(MethodCache.get_after_scenario_hooks, message,message.scenarioExecutionEndingRequest.currentExecutionInfo)
-      response.executionStatusResponse.executionResult.screenshots += Gauge::GaugeScreenshot.instance.pending_screenshot
-      response.executionStatusResponse.executionResult.message += Gauge::GaugeMessages.instance.pending_messages
-      return response
+    def process_scenario_execution_end_request(request)
+      handle_hooks_execution(MethodCache.get_after_scenario_hooks,request.currentExecutionInfo)
     end
 
-    def process_step_execution_start_request(message)
-      response = handle_hooks_execution(MethodCache.get_before_step_hooks, message,message.stepExecutionStartingRequest.currentExecutionInfo)
-      response.executionStatusResponse.executionResult.screenshots += Gauge::GaugeScreenshot.instance.pending_screenshot
-      response.executionStatusResponse.executionResult.message += Gauge::GaugeMessages.instance.pending_messages
-      return response
+    def process_step_execution_start_request(request)
+      handle_hooks_execution(MethodCache.get_before_step_hooks,request.currentExecutionInfo)
     end
 
-    def process_step_execution_end_request(message)
-      response = handle_hooks_execution(MethodCache.get_after_step_hooks, message,message.stepExecutionEndingRequest.currentExecutionInfo)
-      response.executionStatusResponse.executionResult.screenshots += Gauge::GaugeScreenshot.instance.pending_screenshot
-      response.executionStatusResponse.executionResult.message += Gauge::GaugeMessages.instance.pending_messages
-      return response
+    def process_step_execution_end_request(request)
+      handle_hooks_execution(MethodCache.get_after_step_hooks,request.currentExecutionInfo)
     end
   end
 end

data/lib/processors/implementation_file_list_processor.rb

@@ -19,12 +19,7 @@ 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()
+    def process_implementation_file_list_request(_request)
       implPath = Util.get_step_implementation_dir
       fileList = Dir["#{implPath}/**/*.rb"]
       Messages::ImplementationFileListResponse.new(:implementationFilePaths => fileList)

data/lib/processors/implementation_glob_pattern_processor.rb

@@ -19,16 +19,7 @@ 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
+    def process_implementation_glob_pattern_request(_request)
       implPath = Util.get_step_implementation_dir
       Messages::ImplementationFileGlobPatternResponse.new(globPatterns: ["#{implPath}/**/*.rb"])
     end

data/lib/processors/refactor_step_request_processor.rb

@@ -19,13 +19,7 @@ require_relative '../code_parser'
 
 module Gauge
   module Processors
-    def refactor_step(message)
-      request = message.refactorRequest
-      response = refactor_response(request)
-      Messages::Message.new(messageType: :RefactorResponse, messageId: message.messageId, refactorResponse: response)
-    end
-
-    def refactor_response(request)
+    def process_refactor_request(request)
       response = Messages::RefactorResponse.new(success: true)
       begin
         step_info = get_step request.oldStepValue.stepValue

data/lib/processors/step_name_request_processor.rb

@@ -17,15 +17,10 @@
 
 module Gauge
   module Processors
-    def process_step_name_request(message)
-      r = step_name_response(message.stepNameRequest)
-      Messages::Message.new(messageType: :StepNameResponse, messageId: message.messageId, stepNameResponse: r)
-    end
-
-    def step_name_response(request)
+    def process_step_name_request(request)
       step_value = request.stepValue
       unless MethodCache.valid_step?(step_value)
-        return Messages::StepNameResponse.new(isStepPresent: false, stepName: [''], hasAlias: false, fileName: '', span: nil)
+        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)

data/lib/processors/step_names_request_processor.rb

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

data/lib/processors/step_positions_request_processor.rb

@@ -17,12 +17,7 @@
 
 module Gauge
   module Processors
-    def process_step_positions_request(message)
-      r = step_positions(message.stepPositionsRequest)
-      Messages::Message.new(:messageType => :StepPositionsResponse, :messageId => message.messageId, :stepPositionsResponse => r)
-    end
-
-    def step_positions(request)
+    def process_step_positions_request(request)
       file = request.filePath
       positions = MethodCache.step_positions(file)
       p = create_step_position_messages(positions)
@@ -36,4 +31,4 @@ module Gauge
       end
     end
   end
-end
+end

data/lib/processors/step_validation_request_processor.rb

@@ -17,14 +17,7 @@
 
 module Gauge
   module Processors
-    def process_step_validation_request(message)
-      request = message.stepValidateRequest
-      Messages::Message.new(messageType: :StepValidateResponse,
-                            messageId: message.messageId,
-                            stepValidateResponse: step_validate_response(request))
-    end
-
-    def step_validate_response(request)
+    def process_step_validation_request(request)
       response = Messages::StepValidateResponse.new(isValid: true)
       if !MethodCache.valid_step? request.stepText
         suggestion = request.stepValue.stepValue.empty? ? '' : create_suggestion(request.stepValue)

data/lib/processors/stub_implementation_processor.rb

@@ -19,12 +19,7 @@ require_relative '../../lib/util'
 
 module Gauge
   module Processors
-    def process_stub_implementation_code_request(message)
-      file_diff = implement_stub_response(message.stubImplementationCodeRequest)
-      Messages::Message.new(messageType: :FileDiff, messageId: message.messageId, fileDiff: file_diff)
-    end
-
-    def implement_stub_response(request)
+    def process_stub_implementation_code_request(request)
       codes = request.codes
       file_path = request.implementationFilePath
       content = ''

data/lib/service_handlers.rb

@@ -0,0 +1,122 @@
+# 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 "services_services_pb"
+Dir[File.join(File.dirname(__FILE__), "processors/*.rb")].each { |file| require file }
+
+module Gauge
+  class ExecutionHandler < Messages::Runner::Service
+    include Processors
+
+    def initialize(server)
+      @server = server
+    end
+
+    def initialize_suite_data_store(request, _call)
+      process_suite_data_store_init_request(request)
+    end
+
+    def initialize_spec_data_store(request, _call)
+      process_spec_data_store_init_request(request)
+    end
+
+    def initialize_scenario_data_store(request, _call)
+      process_scenario_data_store_init_request(request)
+    end
+
+    def start_execution(request, _call)
+      process_execution_start_request(request)
+    end
+
+    def finish_execution(request, _call)
+      process_execution_end_request(request)
+    end
+
+    def start_spec_execution(request, _call)
+      process_spec_execution_start_request(request)
+    end
+
+    def finish_spec_execution(request, _call)
+      process_spec_execution_end_request(request)
+    end
+
+    def start_scenario_execution(request, _call)
+      process_scenario_execution_start_request(request)
+    end
+
+    def finish_scenario_execution(request, _call)
+      process_scenario_execution_end_request(request)
+    end
+
+    def start_step_execution(request, _call)
+      process_step_execution_start_request(request)
+    end
+
+    def finish_step_execution(request, _call)
+      process_step_execution_end_request(request)
+    end
+
+    def execute_step(request, _call)
+      process_execute_step_request(request)
+    end
+
+    def get_step_names(request, _call)
+      process_step_names_request(request)
+    end
+
+    def cache_file(request, _call)
+      process_cache_file_request(request)
+    end
+
+    def get_step_positions(request, _call)
+      process_step_positions_request(request)
+    end
+
+    def get_implementation_files(request, _call)
+      process_implementation_file_list_request(request)
+    end
+
+    def implement_stub(request, _call)
+      process_stub_implementation_code_request(request)
+    end
+
+    def refactor(request, _call)
+      process_refactor_request(request)
+    end
+
+    def get_step_name(request, _call)
+      process_step_name_request(request)
+    end
+
+    def get_glob_patterns(request, _call)
+      process_implementation_glob_pattern_request(request)
+    end
+
+    def validate_step(request, _call)
+      process_step_validation_request(request)
+    end
+
+    def kill(_request, _call)
+      Thread.new do
+        sleep 0.1
+        @server.stop
+        exit(0)
+      end.run
+      Messages::Empty.new
+    end
+  end
+end