gauge-ruby 0.4.2 → 0.4.3

data/lib/processors/refactor_step_request_processor.rb

@@ -20,25 +20,26 @@ require_relative '../code_parser'
 module Gauge
   module Processors
     def refactor_step(message)
-      oldStepValue = message.refactorRequest.oldStepValue.stepValue
-      newStep = message.refactorRequest.newStepValue
+      request = message.refactorRequest
       refactor_response = Messages::RefactorResponse.new(success: true)
       begin
-        stepBlock = get_step oldStepValue
-        CodeParser.refactor stepBlock, message.refactorRequest.paramPositions, newStep.parameters, newStep.parameterizedStepValue
-        file, _ = stepBlock.source_location
+        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)]
       rescue Exception => e
-        refactor_response.success=false
-        refactor_response.error=e.message
+        refactor_response.success = false
+        refactor_response.error = e.message
       end
       Messages::Message.new(:messageType => Messages::Message::MessageType::RefactorResponse, :messageId => message.messageId, refactorResponse: refactor_response)
     end
 
     def get_step(step_text)
-      blocks = MethodCache.get_steps step_text
-      raise "Multiple step implementations found for => '#{step_text}'" if blocks.length > 1
-      blocks[0]
+      md = MethodCache.multiple_implementation? step_text
+      raise "Multiple step implementations found for => '#{step_text}'" if md
+      MethodCache.get_step_info(step_text)
     end
   end
 end

data/lib/processors/step_name_request_processor.rb

@@ -1,4 +1,4 @@
-# Copyright 2015 ThoughtWorks, Inc.
+# Copyright 2018 ThoughtWorks, Inc.
 
 # This file is part of Gauge-Ruby.
 
@@ -18,12 +18,18 @@
 module Gauge
   module Processors
     def process_step_name_request(message)
-      parsed_step_text = message.stepNameRequest.stepValue
-      is_valid = MethodCache.valid_step?(parsed_step_text)
-      step_text = is_valid ? MethodCache.get_step_text(parsed_step_text) : ""
-      has_alias = MethodCache.has_alias?(step_text)
-      get_step_name_response = Messages::StepNameResponse.new(isStepPresent: is_valid, stepName: [step_text], hasAlias: has_alias)
-      Messages::Message.new(:messageType => Messages::Message::MessageType::StepNameResponse, :messageId => message.messageId, :stepNameResponse => get_step_name_response)
+      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)
+      end
     end
   end
 end

data/lib/processors/step_positions_request_processor.rb

@@ -0,0 +1,35 @@
+# 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/>.
+
+module Gauge
+  module Processors
+    def process_step_positions_request(message)
+      file = message.stepPositionsRequest.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)
+    end
+
+    def create_step_position_messages(positions)
+      positions.map do |p|
+        span = Gauge::Messages::Span.new(:start => p[:span].begin.line, :end => p[:span].end.line, :startChar => p[:span].begin.column, :endChar => p[:span].end.column)
+        Messages::StepPositionsResponse::StepPosition.new(:stepValue => p[:stepValue], :span => span)
+      end
+    end
+  end
+end

data/lib/processors/step_validation_request_processor.rb

@@ -18,24 +18,32 @@
 module Gauge
   module Processors
     def process_step_validation_request(message)
-      step_validate_request = message.stepValidateRequest
+      request = message.stepValidateRequest
       is_valid = true
-      msg = ''
+      msg,suggestion = ''
       err_type = nil
-      blocks = MethodCache.get_steps(step_validate_request.stepText)
-      if blocks.length > 1
-        is_valid = false
-        msg = "Multiple step implementations found for => '#{step_validate_request.stepText}'"
-        err_type = Messages::StepValidateResponse::ErrorType::DUPLICATE_STEP_IMPLEMENTATION
-      elsif blocks.length == 0
+      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?
+      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 = ''
       end
-      step_validate_response = Messages::StepValidateResponse.new(:isValid => is_valid, :errorMessage => msg, :errorType => err_type)
+      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)
+                            :messageId => message.messageId,
+                            :stepValidateResponse => step_validate_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 '#{step_text}' do |#{params}|\n\traise 'Unimplemented Step'\nend"
     end
   end
 end

data/lib/processors/stub_implementation_processor.rb

@@ -0,0 +1,46 @@
+# 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 '../../lib/util'
+
+module Gauge
+  module Processors
+    def process_stub_implementation_code_request(message)
+      codes = message.stubImplementationCodeRequest.codes
+      file_path = message.stubImplementationCodeRequest.implementationFilePath
+      content = ''
+      if File.file? file_path
+        content = File.read(file_path)
+      else
+        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)
+    end
+
+    def create_span(content, codes)
+      unless content.empty?
+        eof_char = content.strip.length == content.length ? "\n" : ''
+        codes.unshift(eof_char)
+        line = content.split("\n").length
+        return Messages::Span.new(start: line, startChar: 0, end: line, endChar: 0)
+      end
+      Messages::Span.new(start: 0, startChar: 0, end: 0, endChar: 0)
+    end
+  end
+end

data/lib/spec.pb.rb

@@ -24,6 +24,7 @@ module Gauge
     class ProtoHookFailure < ::ProtocolBuffers::Message; end
     class ProtoSuiteResult < ::ProtocolBuffers::Message; end
     class ProtoSpecResult < ::ProtocolBuffers::Message; end
+    class Error < ::ProtocolBuffers::Message; end
     class ProtoStepValue < ::ProtocolBuffers::Message; end
 
     # enums
@@ -44,10 +45,12 @@ module Gauge
       optional :string, :specHeading, 1
       repeated ::Gauge::Messages::ProtoItem, :items, 2
       optional :bool, :isTableDriven, 3
-      optional ::Gauge::Messages::ProtoHookFailure, :preHookFailure, 4
-      optional ::Gauge::Messages::ProtoHookFailure, :postHookFailure, 5
+      repeated ::Gauge::Messages::ProtoHookFailure, :preHookFailures, 4
+      repeated ::Gauge::Messages::ProtoHookFailure, :postHookFailures, 5
       optional :string, :fileName, 6
       repeated :string, :tags, 7
+      repeated :string, :preHookMessages, 8
+      repeated :string, :postHookMessages, 9
     end
 
     class ProtoItem < ::ProtocolBuffers::Message
@@ -97,6 +100,8 @@ module Gauge
       repeated ::Gauge::Messages::ProtoItem, :tearDownSteps, 12
       optional ::Gauge::Messages::Span, :span, 13
       optional ::Gauge::Messages::ExecutionStatus, :executionStatus, 14
+      repeated :string, :preHookMessages, 15
+      repeated :string, :postHookMessages, 16
     end
 
     class Span < ::ProtocolBuffers::Message
@@ -104,6 +109,8 @@ module Gauge
 
       optional :int64, :start, 1
       optional :int64, :end, 2
+      optional :int64, :startChar, 3
+      optional :int64, :endChar, 4
     end
 
     class ProtoTableDrivenScenario < ::ProtocolBuffers::Message
@@ -120,6 +127,8 @@ module Gauge
       optional :string, :parsedText, 2
       repeated ::Gauge::Messages::Fragment, :fragments, 3
       optional ::Gauge::Messages::ProtoStepExecutionResult, :stepExecutionResult, 4
+      repeated :string, :preHookMessages, 5
+      repeated :string, :postHookMessages, 6
     end
 
     class ProtoConcept < ::ProtocolBuffers::Message
@@ -240,6 +249,7 @@ module Gauge
       optional :string, :stackTrace, 1
       optional :string, :errorMessage, 2
       optional :bytes, :screenShot, 3
+      optional :int32, :tableRowIndex, 4
     end
 
     class ProtoSuiteResult < ::ProtocolBuffers::Message
@@ -257,6 +267,8 @@ module Gauge
       optional :string, :projectName, 10
       optional :string, :timestamp, 11
       optional :int32, :specsSkippedCount, 12
+      repeated :string, :preHookMessages, 13
+      repeated :string, :postHookMessages, 14
     end
 
     class ProtoSpecResult < ::ProtocolBuffers::Message
@@ -269,8 +281,30 @@ module Gauge
       repeated :int32, :failedDataTableRows, 5
       optional :int64, :executionTime, 6
       optional :bool, :skipped, 7
-      optional :int32, :scenarioSkippedCount, 9
-      repeated :int32, :skippedDataTableRows, 10
+      optional :int32, :scenarioSkippedCount, 8
+      repeated :int32, :skippedDataTableRows, 9
+      repeated ::Gauge::Messages::Error, :errors, 10
+    end
+
+    class Error < ::ProtocolBuffers::Message
+      # forward declarations
+
+      # enums
+      module ErrorType
+        include ::ProtocolBuffers::Enum
+
+        set_fully_qualified_name "gauge.messages.Error.ErrorType"
+
+        PARSE_ERROR = 0
+        VALIDATION_ERROR = 1
+      end
+
+      set_fully_qualified_name "gauge.messages.Error"
+
+      optional ::Gauge::Messages::Error::ErrorType, :type, 1
+      optional :string, :filename, 2
+      optional :int32, :lineNumber, 3
+      optional :string, :message, 4
     end
 
     class ProtoStepValue < ::ProtocolBuffers::Message

data/lib/static_loader.rb

@@ -0,0 +1,103 @@
+# 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 'gauge'
+require_relative 'code_parser'
+require_relative 'method_cache'
+
+module Gauge
+  # @api private
+  module StaticLoader
+    def self.load_files(dir)
+      Dir["#{dir}/**/*.rb"].each do |x|
+        load_steps(x, CodeParser.code_to_ast(File.read(x)))
+      end
+    end
+
+    def self.traverse(ast, &visitor)
+      return if ast.class != Parser::AST::Node
+      if ast && step_node?(ast)
+        visitor.call(ast)
+      elsif ast&.children
+        ast.children.each {|node|
+          traverse(node, &visitor)
+        }
+      end
+    end
+
+    def self.load_steps(file, ast)
+      traverse ast do |node|
+        process_node(file, node)
+      end
+    end
+
+    def self.reload_steps(file, ast)
+      return unless ast
+      remove_steps file
+      load_steps(file, ast)
+    end
+
+    def self.remove_steps(file)
+      Gauge::MethodCache.remove_steps file
+    end
+
+    def self.step_node?(node)
+      node.type == :block && node.children[0].children[1] == :step
+    end
+
+    def self.process_node(file, node)
+      if aliases?(node)
+        load_aliases(file, node)
+      else
+        step_text = node.children[0].children[2].children[0]
+        step_value = Gauge::Connector.step_value step_text
+        load_step(file, step_value, step_text, node, {recoverable: recoverable?(node)})
+      end
+    end
+
+    def self.aliases?(node)
+      return node.children[0].children.size > 3 && node.children[0].children[3].type == :str
+    end
+
+    def self.load_aliases(file, node)
+      recoverable = false
+      if recoverable? node
+        aliases = node.children[0].children.slice(2, node.children[0].children.length() - 3)
+        recoverable = true
+      else
+        aliases = node.children[0].children.slice(2, node.children[0].children.length() - 2)
+      end
+      Gauge::MethodCache.add_step_alias(*aliases.map {|x| x.children[0]})
+      aliases.each {|x|
+        sv = Gauge::Connector.step_value x.children[0]
+        load_step(file, sv, x.children[0], node, {recoverable: recoverable})
+      }
+    end
+
+    def self.recoverable?(node)
+      size = node.children[0].children.length
+      options = node.children[0].children[size - 1]
+      options.type == :hash && options.children[0].children[0].children[0] == :continue_on_failure
+    end
+
+    def self.load_step(file, step_value, step_text, block, options)
+      si = {location: {file: file, span: block.loc}, step_text: step_text,
+            block: block, recoverable: options[:recoverable]}
+      Gauge::MethodCache.add_step(step_value, si)
+    end
+  end
+end

data/lib/util.rb

@@ -18,7 +18,7 @@
 module Gauge
   class Util
     def self.valid_variable_name?(var_name)
-      Object.new.instance_variable_set ('@'+var_name).to_sym, nil
+      Object.new.instance_variable_set ('@' + var_name).to_sym, nil
       true
     rescue NameError
       !!(var_name =~ /^[0-9]+$/)
@@ -26,12 +26,24 @@ module Gauge
 
     def self.remove_special_chars(param)
       new_param = ''
-      param.each_char { |c|
+      param.each_char {|c|
         if valid_variable_name? c
-           new_param += c
+          new_param += c
         end
       }
       return new_param
-      end
+    end
+
+    def self.get_step_implementation_dir
+      return File.join(ENV["GAUGE_PROJECT_ROOT"].gsub(/\\/, "/"), 'step_implementations')
+    end
+
+    def self.get_file_name(prefix = '', counter = 0)
+      name = "step_implementation#{prefix}.rb"
+      file_name = File.join(get_step_implementation_dir, name)
+      return file_name unless File.file? file_name
+      counter += 1
+      get_file_name("_#{counter}", counter)
+    end
   end
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gauge-ruby
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.4.3
 platform: ruby
 authors:
 - Gauge Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-05 00:00:00.000000000 Z
+date: 2018-03-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-protocol-buffers
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.3'
+- !ruby/object:Gem::Dependency
+  name: unparser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.6
 - !ruby/object:Gem::Dependency
   name: method_source
   requirement: !ruby/object:Gem::Requirement
@@ -66,6 +80,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.8.2
+- !ruby/object:Gem::Dependency
+  name: ruby-debug-ide
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+- !ruby/object:Gem::Dependency
+  name: debase
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.2
 description: Adds Ruby support into Gauge tests
 email:
 - gauge@thoughtworks.com
@@ -82,19 +124,25 @@ files:
 - lib/gauge.rb
 - lib/gauge_messages.rb
 - lib/gauge_runtime.rb
+- lib/log.rb
 - lib/message_processor.rb
 - lib/messages.pb.rb
 - lib/method_cache.rb
+- lib/processors/cache_file_processor.rb
 - lib/processors/datastore_init_processor.rb
 - lib/processors/execute_step_request_processor.rb
 - lib/processors/execution_handler.rb
 - lib/processors/execution_hook_processors.rb
+- lib/processors/implementation_file_list_processor.rb
 - lib/processors/kill_request_processor.rb
 - lib/processors/refactor_step_request_processor.rb
 - lib/processors/step_name_request_processor.rb
 - lib/processors/step_names_request_processor.rb
+- lib/processors/step_positions_request_processor.rb
 - lib/processors/step_validation_request_processor.rb
+- lib/processors/stub_implementation_processor.rb
 - lib/spec.pb.rb
+- lib/static_loader.rb
 - lib/table.rb
 - lib/util.rb
 homepage: http://www.getgauge.io