gauge-ruby 0.4.2 → 0.4.3

data/lib/message_processor.rb

@@ -18,7 +18,7 @@
 require_relative 'messages.pb'
 require_relative 'executor'
 require_relative 'table'
-Dir[File.join(File.dirname(__FILE__), 'processors/*.rb')].each {|file| require file }
+Dir[File.join(File.dirname(__FILE__), 'processors/*.rb')].each {|file| require file}
 
 module Gauge
   # @api private
@@ -43,6 +43,10 @@ module Gauge
     @processors[Messages::Message::MessageType::ScenarioDataStoreInit] = method(:process_datastore_init)
     @processors[Messages::Message::MessageType::StepNameRequest] = method(:process_step_name_request)
     @processors[Messages::Message::MessageType::RefactorRequest] = method(:refactor_step)
+    @processors[Messages::Message::MessageType::CacheFileRequest] = method(:process_cache_file_request)
+    @processors[Messages::Message::MessageType::StepPositionsRequest] = method(:process_step_positions_request)
+    @processors[Messages::Message::MessageType::ImplementationFileListRequest] = method(:process_implementation_file_list_request)
+    @processors[Messages::Message::MessageType::StubImplementationCodeRequest] = method(:process_stub_implementation_code_request)
 
     def self.is_valid_message(message)
       return @processors.has_key? message.messageType

data/lib/messages.pb.rb

@@ -33,10 +33,19 @@ module Gauge
     class SuiteDataStoreInitRequest < ::ProtocolBuffers::Message; end
     class ParameterPosition < ::ProtocolBuffers::Message; end
     class RefactorRequest < ::ProtocolBuffers::Message; end
+    class FileChanges < ::ProtocolBuffers::Message; end
     class RefactorResponse < ::ProtocolBuffers::Message; end
     class StepNameRequest < ::ProtocolBuffers::Message; end
     class StepNameResponse < ::ProtocolBuffers::Message; end
     class UnsupportedMessageResponse < ::ProtocolBuffers::Message; end
+    class CacheFileRequest < ::ProtocolBuffers::Message; end
+    class StepPositionsRequest < ::ProtocolBuffers::Message; end
+    class StepPositionsResponse < ::ProtocolBuffers::Message; end
+    class ImplementationFileListRequest < ::ProtocolBuffers::Message; end
+    class ImplementationFileListResponse < ::ProtocolBuffers::Message; end
+    class StubImplementationCodeRequest < ::ProtocolBuffers::Message; end
+    class TextDiff < ::ProtocolBuffers::Message; end
+    class FileDiff < ::ProtocolBuffers::Message; end
     class Message < ::ProtocolBuffers::Message; end
 
     class KillProcessRequest < ::ProtocolBuffers::Message
@@ -129,6 +138,8 @@ module Gauge
 
       optional ::Gauge::Messages::ExecuteStepRequest, :step, 1
       optional :bool, :isFailed, 2
+      optional :string, :stackTrace, 3
+      optional :string, :errorMessage, 4
     end
 
     class ExecuteStepRequest < ::ProtocolBuffers::Message
@@ -145,6 +156,7 @@ module Gauge
 
       optional :string, :stepText, 1
       optional :int32, :numberOfParameters, 2
+      optional ::Gauge::Messages::ProtoStepValue, :stepValue, 3
     end
 
     class StepValidateResponse < ::ProtocolBuffers::Message
@@ -165,6 +177,7 @@ module Gauge
       optional :bool, :isValid, 1
       optional :string, :errorMessage, 2
       optional ::Gauge::Messages::StepValidateResponse::ErrorType, :errorType, 3
+      optional :string, :suggestion, 4
     end
 
     class SuiteExecutionResult < ::ProtocolBuffers::Message
@@ -212,6 +225,14 @@ module Gauge
       optional ::Gauge::Messages::ProtoStepValue, :oldStepValue, 1
       optional ::Gauge::Messages::ProtoStepValue, :newStepValue, 2
       repeated ::Gauge::Messages::ParameterPosition, :paramPositions, 3
+      optional :bool, :saveChanges, 4
+    end
+
+    class FileChanges < ::ProtocolBuffers::Message
+      set_fully_qualified_name "gauge.messages.FileChanges"
+
+      optional :string, :fileName, 1
+      optional :string, :fileContent, 2
     end
 
     class RefactorResponse < ::ProtocolBuffers::Message
@@ -220,6 +241,7 @@ module Gauge
       optional :bool, :success, 1
       optional :string, :error, 2
       repeated :string, :filesChanged, 3
+      repeated ::Gauge::Messages::FileChanges, :fileChanges, 4
     end
 
     class StepNameRequest < ::ProtocolBuffers::Message
@@ -234,6 +256,8 @@ module Gauge
       optional :bool, :isStepPresent, 1
       repeated :string, :stepName, 2
       optional :bool, :hasAlias, 3
+      optional :string, :fileName, 4
+      optional ::Gauge::Messages::Span, :span, 5
     end
 
     class UnsupportedMessageResponse < ::ProtocolBuffers::Message
@@ -242,6 +266,70 @@ module Gauge
       optional :string, :message, 1
     end
 
+    class CacheFileRequest < ::ProtocolBuffers::Message
+      set_fully_qualified_name "gauge.messages.CacheFileRequest"
+
+      optional :string, :content, 1
+      optional :string, :filePath, 2
+      optional :bool, :isClosed, 3
+    end
+
+    class StepPositionsRequest < ::ProtocolBuffers::Message
+      set_fully_qualified_name "gauge.messages.StepPositionsRequest"
+
+      optional :string, :filePath, 1
+    end
+
+    class StepPositionsResponse < ::ProtocolBuffers::Message
+      # forward declarations
+      class StepPosition < ::ProtocolBuffers::Message; end
+
+      set_fully_qualified_name "gauge.messages.StepPositionsResponse"
+
+      # nested messages
+      class StepPosition < ::ProtocolBuffers::Message
+        set_fully_qualified_name "gauge.messages.StepPositionsResponse.StepPosition"
+
+        optional :string, :stepValue, 1
+        optional ::Gauge::Messages::Span, :span, 2
+      end
+
+      repeated ::Gauge::Messages::StepPositionsResponse::StepPosition, :stepPositions, 1
+      optional :string, :error, 2
+    end
+
+    class ImplementationFileListRequest < ::ProtocolBuffers::Message
+      set_fully_qualified_name "gauge.messages.ImplementationFileListRequest"
+
+    end
+
+    class ImplementationFileListResponse < ::ProtocolBuffers::Message
+      set_fully_qualified_name "gauge.messages.ImplementationFileListResponse"
+
+      repeated :string, :implementationFilePaths, 1
+    end
+
+    class StubImplementationCodeRequest < ::ProtocolBuffers::Message
+      set_fully_qualified_name "gauge.messages.StubImplementationCodeRequest"
+
+      optional :string, :implementationFilePath, 1
+      repeated :string, :codes, 2
+    end
+
+    class TextDiff < ::ProtocolBuffers::Message
+      set_fully_qualified_name "gauge.messages.TextDiff"
+
+      optional ::Gauge::Messages::Span, :span, 1
+      optional :string, :content, 2
+    end
+
+    class FileDiff < ::ProtocolBuffers::Message
+      set_fully_qualified_name "gauge.messages.FileDiff"
+
+      optional :string, :filePath, 1
+      repeated ::Gauge::Messages::TextDiff, :textDiffs, 2
+    end
+
     class Message < ::ProtocolBuffers::Message
       # forward declarations
 
@@ -275,6 +363,13 @@ module Gauge
         RefactorRequest = 21
         RefactorResponse = 22
         UnsupportedMessageResponse = 23
+        CacheFileRequest = 24
+        StepPositionsRequest = 25
+        StepPositionsResponse = 26
+        ImplementationFileListRequest = 27
+        ImplementationFileListResponse = 28
+        StubImplementationCodeRequest = 29
+        FileDiff = 30
       end
 
       set_fully_qualified_name "gauge.messages.Message"
@@ -305,6 +400,13 @@ module Gauge
       optional ::Gauge::Messages::RefactorRequest, :refactorRequest, 24
       optional ::Gauge::Messages::RefactorResponse, :refactorResponse, 25
       optional ::Gauge::Messages::UnsupportedMessageResponse, :unsupportedMessageResponse, 26
+      optional ::Gauge::Messages::CacheFileRequest, :cacheFileRequest, 27
+      optional ::Gauge::Messages::StepPositionsRequest, :stepPositionsRequest, 28
+      optional ::Gauge::Messages::StepPositionsResponse, :stepPositionsResponse, 29
+      optional ::Gauge::Messages::ImplementationFileListRequest, :implementationFileListRequest, 30
+      optional ::Gauge::Messages::ImplementationFileListResponse, :implementationFileListResponse, 31
+      optional ::Gauge::Messages::StubImplementationCodeRequest, :stubImplementationCodeRequest, 32
+      optional ::Gauge::Messages::FileDiff, :fileDiff, 33
     end
 
   end

data/lib/method_cache.rb

@@ -1,4 +1,4 @@
-# Copyright 2015 ThoughtWorks, Inc.
+# Copyright 2018 ThoughtWorks, Inc.
 
 # This file is part of Gauge-Ruby.
 
@@ -19,39 +19,44 @@ require_relative 'configuration'
 module Gauge
   # @api private
   class MethodCache
-    ["before_step", "after_step", "before_spec", "after_spec", "before_scenario", "after_scenario", "before_suite", "after_suite"].each { |hook|
-      define_singleton_method "add_#{hook}_hook" do |options={}, &block|
+    %w[before_step after_step before_spec after_spec before_scenario after_scenario before_suite after_suite].each { |hook|
+      define_singleton_method "add_#{hook}_hook" do |options = {}, &block|
         options = {operator: "AND", tags: []}.merge options
-        self.class_variable_get("@@#{hook}_hooks").push :block=>  block, :options=> options
+        class_variable_get("@@#{hook}_hooks").push :block => block, :options => options
       end
       define_singleton_method "get_#{hook}_hooks" do
-        self.class_variable_get("@@#{hook}_hooks")
+        class_variable_get("@@#{hook}_hooks")
       end
     }
 
     def self.clear_hooks(hook)
-      self.class_variable_get("@@#{hook}_hooks").clear
+      class_variable_get("@@#{hook}_hooks").clear
     end
 
-    def self.add_step(parameterized_step_text, &block)
-      @@steps_map[parameterized_step_text] = @@steps_map[parameterized_step_text] || []
-      @@steps_map[parameterized_step_text].push(block)
+    def self.clear()
+      @@steps_map.clear
     end
 
-    def self.get_step(parameterized_step_text)
-      @@steps_map[parameterized_step_text][0]
+    def self.add_step(step_value, step_info)
+      if @@steps_map.key? step_value
+        @@steps_map[step_value][:locations].push(step_info[:location])
+      else
+        @@steps_map[step_value] = {
+            locations: [step_info[:location]],
+            block: step_info[:block],
+            step_text: step_info[:step_text],
+            recoverable: step_info[:recoverable]
+        }
+      end
     end
 
-    def self.get_steps(parameterized_step_text)
-      @@steps_map[parameterized_step_text] || []
+    def self.get_step_info(step_value)
+      @@steps_map[step_value]
     end
 
-    def self.add_step_text(parameterized_step_text, step_text)
-      @@steps_text_map[parameterized_step_text] = step_text
-    end
 
-    def self.get_step_text(parameterized_step_text)
-      @@steps_text_map[parameterized_step_text]
+    def self.get_step_text(step_value)
+      @@steps_map[step_value][:step_text]
     end
 
     def self.add_step_alias(*step_texts)
@@ -63,26 +68,43 @@ module Gauge
     end
 
     def self.valid_step?(step)
-      @@steps_map.has_key? step
+      @@steps_map.key? step
     end
 
     def self.all_steps
-      @@steps_text_map.values
+      @@steps_map.values.map { |si| si[:step_text] }
+    end
+
+    def self.recoverable?(step_value)
+      @@steps_map[step_value][:recoverable]
     end
 
-    def self.is_recoverable?(parameterized_step_text)
-      @@recoverable_steps.include? parameterized_step_text
+    def self.remove_steps(file)
+      @@steps_map.each_pair do |step, info|
+        l = info[:locations].reject { |loc| File.identical? loc[:file], file }
+        l.empty? ? @@steps_map.delete(step) : @@steps_map[step][:locations] = l
+      end
+    end
+
+    def self.multiple_implementation?(step_value)
+      @@steps_map[step_value][:locations].length > 1
     end
 
-    def self.set_recoverable(parameterized_step_text)
-      @@recoverable_steps.push parameterized_step_text
+    def self.step_positions(file)
+      step_positions = []
+      @@steps_map.each_pair do |step, info|
+        info[:locations].each do |location|
+          if location[:file] == file
+            step_positions.push({stepValue: step, span: location[:span]})
+          end
+        end
+      end
+      step_positions
     end
 
     private
     @@steps_map = Hash.new
-    @@steps_text_map = Hash.new
     @@steps_with_aliases = []
-    @@recoverable_steps = []
     @@before_suite_hooks = []
     @@after_suite_hooks = []
     @@before_spec_hooks = []

data/lib/processors/cache_file_processor.rb

@@ -0,0 +1,43 @@
+# 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 '../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
+        ast = CodeParser.code_to_ast File.read(f)
+        StaticLoader.reload_steps(f, ast)
+      else
+        StaticLoader.remove_steps(f)
+      end
+    end
+
+  end
+end

data/lib/processors/execute_step_request_processor.rb

@@ -29,7 +29,7 @@ module Gauge
       begin
         Executor.execute_step step_text, args
       rescue Exception => e
-        return handle_failure message, e, time_elapsed_since(start_time), MethodCache.is_recoverable?(step_text)
+        return handle_failure message, e, time_elapsed_since(start_time), MethodCache.recoverable?(step_text)
       end
       handle_pass message, time_elapsed_since(start_time)
     end

data/lib/processors/execution_handler.rb

@@ -37,24 +37,35 @@ module Gauge
       end
 
       def handle_failure(message, 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
+        line_number =  stacktrace.split("\n").first.split("/").last.split(":")[1]
+        code_snippet = "\n" + '> ' + get_code_snippet(filepath, line_number.to_i)
         execution_status_response =
           Messages::ExecutionStatusResponse.new(
             :executionResult => Messages::ProtoExecutionResult.new(:failed => true,
              :recoverableError => recoverable,
              :errorMessage => exception.message,
-             :stackTrace => exception.backtrace.join("\n")+"\n",
+             :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)
       end
 
+      def get_code_snippet(filename, number)
+        return nil if number < 1
+        line = File.readlines(filename)[number-1]
+        number.to_s + " | " + line.strip + "\n\n"
+      end
+
       def screenshot_bytes
         return nil if (ENV['screenshot_on_failure'] || "").downcase == "false" || which("gauge_screenshot").nil?
         begin
           Configuration.instance.screengrabber.call
         rescue Exception => e
-          puts e
+          Gauge::Log.error e
           return nil
         end
       end

data/lib/processors/execution_hook_processors.rb

@@ -17,12 +17,16 @@
 
 require_relative "execution_handler"
 require_relative "../gauge_messages"
-
+require_relative "../executor"
+require_relative "../method_cache"
+require_relative "../util"
 module Gauge
   module Processors
     include ExecutionHandler
 
     def process_execution_start_request(message)
+      Gauge::MethodCache.clear
+      Executor.load_steps(Util.get_step_implementation_dir)
       handle_hooks_execution(MethodCache.get_before_suite_hooks, message, message.executionStartingRequest.currentExecutionInfo,false)
     end
 

data/lib/processors/implementation_file_list_processor.rb

@@ -0,0 +1,29 @@
+# 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_file_list_request(message)
+      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)
+    end
+  end
+end