gauge-ruby 0.4.3 → 0.5.4

data/lib/method_cache.rb

@@ -1,20 +1,8 @@
-# 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/>.
-
+=begin
+ *  Copyright (c) ThoughtWorks, Inc.
+ *  Licensed under the Apache License, Version 2.0
+ *  See LICENSE.txt in the project root for license information.
+=end
 require_relative 'configuration'
 module Gauge
   # @api private
@@ -79,13 +67,28 @@ module Gauge
       @@steps_map[step_value][:recoverable]
     end
 
+    def self.relative_filepath(file)
+      project_root =  Pathname.new(ENV['GAUGE_PROJECT_ROOT'])
+      filename = Pathname.new(file).relative_path_from(project_root)
+      return project_root.join(filename.to_s.split(":").first)
+    end
+
     def self.remove_steps(file)
       @@steps_map.each_pair do |step, info|
-        l = info[:locations].reject { |loc| File.identical? loc[:file], file }
+        l = info[:locations].reject { |loc| relative_filepath(loc[:file]).eql? relative_filepath(file) }
         l.empty? ? @@steps_map.delete(step) : @@steps_map[step][:locations] = l
       end
     end
 
+    def self.is_file_cached(file)
+      @@steps_map.each_pair do |step, info|
+        if info[:locations].any? { |loc| relative_filepath(loc[:file]).eql? relative_filepath(file) }
+          return true
+        end
+      end
+      return false
+    end
+
     def self.multiple_implementation?(step_value)
       @@steps_map[step_value][:locations].length > 1
     end

data/lib/processors/cache_file_processor.rb

@@ -1,43 +1,32 @@
-# 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/>.
-
+# frozen_string_literal: true
+=begin
+ *  Copyright (c) ThoughtWorks, Inc.
+ *  Licensed under the Apache License, Version 2.0
+ *  See LICENSE.txt in the project root for license information.
+=end
 require_relative '../static_loader'
 require_relative '../method_cache'
 module Gauge
   # @api private
   module Processors
-    def process_cache_file_request(message)
-      if !message.cacheFileRequest.isClosed
-        ast = CodeParser.code_to_ast(message.cacheFileRequest.content)
-        StaticLoader.reload_steps(message.cacheFileRequest.filePath, ast)
-      else
-        load_from_disk message.cacheFileRequest.filePath
-      end
-      nil
-    end
-
-    def load_from_disk(f)
-      if File.file? f
+    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)
+        ast = CodeParser.code_to_ast(request.content)
+        StaticLoader.reload_steps(f, ast)
+      elsif status == Messages::CacheFileRequest::FileStatus::CREATED
+        if !Gauge::MethodCache.is_file_cached f
+          ast = CodeParser.code_to_ast File.read(f)
+          StaticLoader.reload_steps(f, ast)
+        end
+      elsif (status == Messages::CacheFileRequest::FileStatus::CLOSED) && File.file?(f)
         ast = CodeParser.code_to_ast File.read(f)
         StaticLoader.reload_steps(f, ast)
       else
         StaticLoader.remove_steps(f)
       end
+      Messages::Empty.new
     end
-
   end
-end
+end

data/lib/processors/datastore_init_processor.rb

@@ -1,36 +1,29 @@
-# Copyright 2015 ThoughtWorks, Inc.
+=begin
+ *  Copyright (c) ThoughtWorks, Inc.
+ *  Licensed under the Apache License, Version 2.0
+ *  See LICENSE.txt in the project root for license information.
+=end
+require_relative "../datastore"
 
-# 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.
+module Gauge
+  module Processors
+    def process_suite_data_store_init_request(_request)
+      DataStoreFactory.suite_datastore.clear
+      datastore_response
+    end
 
-# You should have received a copy of the GNU General Public License
-# along with Gauge-Ruby.  If not, see <http://www.gnu.org/licenses/>.
+    def process_spec_data_store_init_request(_request)
+      DataStoreFactory.spec_datastore.clear
+      datastore_response
+    end
 
-require_relative '../datastore'
+    def process_scenario_data_store_init_request(_request)
+      DataStoreFactory.scenario_datastore.clear
+      datastore_response
+    end
 
-module Gauge
-  # @api private
-  module Processors
-    def process_datastore_init(message)
-      case message.messageType
-        when Messages::Message::MessageType::SuiteDataStoreInit
-          DataStoreFactory.suite_datastore.clear
-        when Messages::Message::MessageType::SpecDataStoreInit
-          DataStoreFactory.spec_datastore.clear
-        when Messages::Message::MessageType::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)
+    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

@@ -1,37 +1,25 @@
-# Copyright 2015 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/>.
-
+=begin
+ *  Copyright (c) ThoughtWorks, Inc.
+ *  Licensed under the Apache License, Version 2.0
+ *  See LICENSE.txt in the project root for license information.
+=end
 require_relative "execution_handler"
 
 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
+end

data/lib/processors/execution_handler.rb

@@ -1,45 +1,41 @@
-# Copyright 2015 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/>.
-
+=begin
+ *  Copyright (c) ThoughtWorks, Inc.
+ *  Licensed under the Apache License, Version 2.0
+ *  See LICENSE.txt in the project root for license information.
+=end
 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))
-        Messages::Message.new(:messageType => Messages::Message::MessageType::ExecutionStatusResponse, :messageId => message.messageId, :executionStatusResponse => execution_status_response)
+        execution_status_response.executionResult.screenshotFiles += Gauge::GaugeScreenshot.instance.pending_screenshot
+        execution_status_response.executionResult.message += Gauge::GaugeMessages.instance.pending_messages
+        execution_status_response
       end
 
-      def handle_failure(message, exception, execution_time, recoverable)
+      def get_filepath(stacktrace)
+        toptrace = stacktrace.split("\n").first
+        MethodCache.relative_filepath toptrace
+      end
+    
+      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 =  stacktrace.split("\n").first.split(":").first
+        filepath = get_filepath(stacktrace)
         line_number =  stacktrace.split("\n").first.split("/").last.split(":")[1]
         code_snippet = "\n" + '> ' + get_code_snippet(filepath, line_number.to_i)
         execution_status_response =
@@ -48,10 +44,14 @@ 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,
-          :messageId => message.messageId, :executionStatusResponse => execution_status_response)
+             :executionTime => execution_time))
+        screenshot_file = take_screenshot
+        if screenshot_file 
+          execution_status_response.executionResult.failureScreenshotFile = screenshot_file
+        end
+        execution_status_response.executionResult.screenshotFiles += Gauge::GaugeScreenshot.instance.pending_screenshot
+        execution_status_response.executionResult.message += Gauge::GaugeMessages.instance.pending_messages
+        execution_status_response
       end
 
       def get_code_snippet(filename, number)
@@ -60,12 +60,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?
+      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
@@ -77,7 +77,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

@@ -1,22 +1,11 @@
-# Copyright 2015 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/>.
-
+=begin
+ *  Copyright (c) ThoughtWorks, Inc.
+ *  Licensed under the Apache License, Version 2.0
+ *  See LICENSE.txt in the project root for license information.
+=end
 require_relative "execution_handler"
 require_relative "../gauge_messages"
+require_relative "../gauge_screenshot"
 require_relative "../executor"
 require_relative "../method_cache"
 require_relative "../util"
@@ -24,41 +13,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)
-      handle_hooks_execution(MethodCache.get_before_suite_hooks, message, message.executionStartingRequest.currentExecutionInfo,false)
+      handle_hooks_execution(MethodCache.get_before_suite_hooks,request.currentExecutionInfo,false)
     end
 
-    def process_execution_end_request(message)
-      handle_hooks_execution(MethodCache.get_after_suite_hooks, message, message.executionEndingRequest.currentExecutionInfo, false)
+    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)
-      handle_hooks_execution(MethodCache.get_before_spec_hooks, message, message.specExecutionStartingRequest.currentExecutionInfo)
+    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)
-      handle_hooks_execution(MethodCache.get_after_spec_hooks, message, message.specExecutionEndingRequest.currentExecutionInfo)
+    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)
-      handle_hooks_execution(MethodCache.get_before_scenario_hooks, message, message.scenarioExecutionStartingRequest.currentExecutionInfo)
+    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)
-      handle_hooks_execution(MethodCache.get_after_scenario_hooks, message, message.scenarioExecutionEndingRequest.currentExecutionInfo)
+
+    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)
-      Gauge::GaugeMessages.instance.clear
-      handle_hooks_execution(MethodCache.get_before_step_hooks, message, message.stepExecutionStartingRequest.currentExecutionInfo)
+    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.message = Gauge::GaugeMessages.instance.get
-      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

@@ -1,29 +1,16 @@
-# 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/>.
-
+=begin
+ *  Copyright (c) ThoughtWorks, Inc.
+ *  Licensed under the Apache License, Version 2.0
+ *  See LICENSE.txt in the project root for license information.
+=end
 require_relative '../util'
 
 module Gauge
   module Processors
-    def process_implementation_file_list_request(message)
+    def process_implementation_file_list_request(_request)
       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
+end