gauge-ruby 0.4.2 → 0.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7eae6ad6fe9c27f238406b2e4309ee08ba70f360
-  data.tar.gz: 9372308c2f74fe4b24437992ec71b6590f68c53d
+  metadata.gz: 86bb6e44e272971e83b2bef3c38dd92106cae506
+  data.tar.gz: cfdf3a81e93b61c3acc54da0a123630781043860
 SHA512:
-  metadata.gz: 8b41d7a8fa4bf549200a1d2323292d364cf7b455c67eae939c53d8676335ff98cd798996854dcb9994c073bc7a25a5086840190cb99472fc2019289f03e45dae
-  data.tar.gz: 359dc83b45668e572aa2d58ff1f547372a9d2cf71397f7ad178ad69fbc73e76e50f3e96d880447d28c1e8679d166f3e43b3c5e0fedf9011f694234ef3d8e98d5
+  metadata.gz: 36640d7d7936fc4600b7dc1040b922f893bd72ff4e1a514251fefba70a16459009c508031c57e328c59b87da07e4845622409f5da1c4539a66426fa074660042
+  data.tar.gz: 220d4b472ee354d203bcbe35ab54f40f33be040d9eb8b664fc6e5001b0c5888f5000cd508fb4de196f6ed7a831641a2ee54f156247846a97af9846495016a341

data/lib/api.pb.rb

@@ -16,7 +16,6 @@ module Gauge
     class GetAllStepsResponse < ::ProtocolBuffers::Message; end
     class SpecsRequest < ::ProtocolBuffers::Message; end
     class SpecsResponse < ::ProtocolBuffers::Message; end
-    class Error < ::ProtocolBuffers::Message; end
     class GetAllConceptsRequest < ::ProtocolBuffers::Message; end
     class GetAllConceptsResponse < ::ProtocolBuffers::Message; end
     class ConceptInfo < ::ProtocolBuffers::Message; end
@@ -27,7 +26,6 @@ module Gauge
     class ErrorResponse < ::ProtocolBuffers::Message; end
     class PerformRefactoringRequest < ::ProtocolBuffers::Message; end
     class PerformRefactoringResponse < ::ProtocolBuffers::Message; end
-    class ExtractConceptInfoRequest < ::ProtocolBuffers::Message; end
     class ExtractConceptRequest < ::ProtocolBuffers::Message; end
     class TextInfo < ::ProtocolBuffers::Message; end
     class Step < ::ProtocolBuffers::Message; end
@@ -93,14 +91,6 @@ module Gauge
       repeated ::Gauge::Messages::SpecsResponse::SpecDetail, :details, 1
     end
 
-    class Error < ::ProtocolBuffers::Message
-      set_fully_qualified_name "gauge.messages.Error"
-
-      optional :string, :filename, 1
-      optional :int32, :lineNumber, 2
-      optional :string, :message, 3
-    end
-
     class GetAllConceptsRequest < ::ProtocolBuffers::Message
       set_fully_qualified_name "gauge.messages.GetAllConceptsRequest"
 
@@ -166,12 +156,6 @@ module Gauge
       repeated :string, :filesChanged, 3
     end
 
-    class ExtractConceptInfoRequest < ::ProtocolBuffers::Message
-      set_fully_qualified_name "gauge.messages.ExtractConceptInfoRequest"
-
-      optional :string, :text, 1
-    end
-
     class ExtractConceptRequest < ::ProtocolBuffers::Message
       set_fully_qualified_name "gauge.messages.ExtractConceptRequest"
 

data/lib/code_parser.rb

@@ -1,4 +1,4 @@
-# Copyright 2015 ThoughtWorks, Inc.
+# Copyright 2018 ThoughtWorks, Inc.
 #
 # This file is part of Gauge-Ruby.
 #
@@ -16,6 +16,7 @@
 # along with Gauge-Ruby.  If not, see <http://www.gnu.org/licenses/>.
 
 require 'parser/current'
+require 'unparser'
 require 'method_source'
 require 'fileutils'
 require 'tempfile'
@@ -24,16 +25,15 @@ require 'util'
 module Gauge
   # @api private
   class CodeParser
-    def self.step_args_from_code(code)
-      ast=code_to_ast(code)
+    def self.step_args_from_code(ast)
       arg_node = ast.children[1]
       arg_node.children
     end
 
-    def self.refactor_args(code, param_positions, new_param_values, new_step_text)
+    def self.process_node(node, param_positions, new_param_values, new_step_text)
       new_params = []
-      args = step_args_from_code code
-      param_positions.sort_by!(&:newPosition).each.with_index { |e,i|
+      args = step_args_from_code node
+      param_positions.sort_by!(&:newPosition).each.with_index {|e, i|
         if e.oldPosition == -1
           param = Util.remove_special_chars new_param_values[e.newPosition].downcase.split.join('_')
           if param == ''
@@ -44,41 +44,56 @@ module Gauge
           new_params[e.newPosition] = args[e.oldPosition].children[0]
         end
       }
-      buffer = Parser::Source::Buffer.new '(rewriter)'
-      buffer.source=code
-      
-      ast = code_to_ast(code)
-      new_params_string = "|#{new_params.join(', ')}|".gsub("||", "") # no params = empty string
-      
-      rewriter = Parser::Source::Rewriter.new(buffer)
-        .replace(ast.children[0].location.expression, "step '#{new_step_text}'")
-      
-      # hack, could not find an easy way to manipulate the ast to include arguments, when none existed originally.
-      # it's just easy to add arguments via string substitution.
-      return include_args(rewriter.process, new_params_string) if ast.children[1].location.expression.nil?
-      
-      #insert new arguments
-      rewriter.replace(ast.children[1].location.expression, new_params_string).process
+      args = new_params.map {|v| Parser::AST::Node.new(:arg, [v])}
+      step = [node.children[0].children[0], node.children[0].children[1], Parser::AST::Node.new(:str, [new_step_text])]
+      c1 = Parser::AST::Node.new(:send, step)
+      c2 = Parser::AST::Node.new(:args, args)
+      Parser::AST::Node.new(:block, [c1, c2, node.children[2]])
     end
 
-    def self.refactor(code, param_positions, new_param_values, new_step_text)
-      source_code=code.source
-      file, _ = code.source_location
-      refactored_code=refactor_args(source_code, param_positions, new_param_values, new_step_text)
-      tmp_file = Tempfile.new File.basename(file, ".rb")
-      tmp_file.write(File.open(file, "r") { |f| f.read.gsub(source_code, refactored_code)})
-      tmp_file.close
-      FileUtils.mv tmp_file.path, file
+    def self.replace(ast, &visitor)
+      return ast if ast.class != Parser::AST::Node
+      if ast && step_node?(ast)
+        visitor.call(ast)
+      else
+        children = ast.children.map {|node|
+          replace(node, &visitor)
+        }
+        return ast.updated(nil, children, nil)
+      end
+    end
+
+    def self.step_node?(node)
+      node.type == :block && node.children[0].children.size > 2 && node.children[0].children[1] == :step
+    end
+
+    def self.refactor_args(step_text, ast, param_positions, new_param_values, new_step_text)
+      new_ast = replace ast do |node|
+        if node.children[0].children[2].children[0] == step_text
+          process_node(node, param_positions, new_param_values, new_step_text)
+        else
+          node
+        end
+      end
+      Unparser.unparse new_ast
+    end
+
+    def self.refactor(step_info, param_positions, new_step)
+      ast = code_to_ast File.read(step_info[:locations][0][:file])
+      refactor_args(step_info[:step_text], ast, param_positions, new_step.parameters, new_step.parameterizedStepValue)
     end
 
     private
 
     def self.code_to_ast(code)
-      buffer = Parser::Source::Buffer.new '(string)'
-      buffer.source = code
-
-      parser = Parser::CurrentRuby.new
-      parser.parse(buffer)
+      begin
+        buffer = Parser::Source::Buffer.new '(string)'
+        buffer.source = code
+        parser = Parser::CurrentRuby.new
+        return parser.parse(buffer)
+      rescue Exception => e
+        Gauge::Log.error e.message
+      end
     end
 
     def self.include_args(code_string, params)

data/lib/connector.rb

@@ -22,22 +22,16 @@ module Gauge
   # @api private
   module Connector
     GAUGE_PORT_ENV = "GAUGE_INTERNAL_PORT"
-    API_PORT_ENV = "GAUGE_API_PORT"
     HOST_NAME = 'localhost'
     @@executionSocket = nil
-    @@apiSocket = nil
 
-    def self.apiSocket
-      @@apiSocket
-    end
 
-    def self.executionSocket
+    def self.execution_socket
       @@executionSocket
     end
 
-    def self.make_connections
-      @@executionSocket = TCPSocket.open(HOST_NAME, Runtime.portFromEnvVariable(GAUGE_PORT_ENV))
-      @@apiSocket = TCPSocket.open(HOST_NAME, Runtime.portFromEnvVariable(API_PORT_ENV))
+    def self.make_connection
+      @@executionSocket = TCPSocket.open(HOST_NAME, Runtime.port_from_env_variable(GAUGE_PORT_ENV))
     end
 
     def self.message_length(socket)
@@ -45,29 +39,7 @@ module Gauge
     end
 
     def self.step_value text
-      stepValueRequest = Gauge::Messages::GetStepValueRequest.new(:stepText => text)
-      apiMessage = Gauge::Messages::APIMessage.new(:messageType => Gauge::Messages::APIMessage::APIMessageType::GetStepValueRequest, :stepValueRequest => stepValueRequest)
-      response = get_api_response(apiMessage)
-      if (response.messageType == Gauge::Messages::APIMessage::APIMessageType::ErrorResponse)
-        puts "[Error] Failed to load step implementation. #{response.error.error}:  \"#{text}\""
-        return ''
-      end
-      return response.stepValueResponse.stepValue.stepValue
-    end
-
-    def self.get_api_response(apiMessage)
-      apiMessage.messageId = get_unique_id
-      dataLen = apiMessage.serialize_to_string.bytesize
-      ProtocolBuffers::Varint.encode @@apiSocket, dataLen
-      apiMessage.serialize(@@apiSocket)
-
-      responseLen = message_length(@@apiSocket)
-      data = @@apiSocket.read responseLen
-      message = Gauge::Messages::APIMessage.parse(data)
-    end
-
-    def self.get_unique_id
-      rand(2**63-1)
+      return text.gsub(/(<.*?>)/, "{}")
     end
   end
 end

data/lib/executor.rb

@@ -1,4 +1,4 @@
-# Copyright 2015 ThoughtWorks, Inc.
+# Copyright 2018 ThoughtWorks, Inc.
 
 # This file is part of Gauge-Ruby.
 
@@ -14,28 +14,47 @@
 
 # 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 'ruby-debug-ide'
 require_relative 'gauge'
 
+ATTACH_DEBUGGER_EVENT = "Runner Ready for Debugging"
+
 module Gauge
+  class DebugOptions
+    attr_accessor :host, :port, :notify_dispatcher
+  end
+
   # @api private
   module Executor
-    def self.load_steps(steps_implementation_dir)
-      Dir["#{steps_implementation_dir}/**/*.rb"].each { |x|
+    def self.load_steps(dir)
+      start_debugger
+      Dir["#{dir}/**/*.rb"].each do |x|
         begin
+          ENV['GAUGE_STEP_FILE'] = x
           require x
         rescue Exception => e
-          puts "[ERROR] Cannot import #{x}. Reason: #{e.message}"
+          Gauge::Log.error "[ERROR] Cannot import #{x}. Reason: #{e.message}"
         end
-      }
+      end
+    end
+
+    def self.start_debugger
+      if ENV['DEBUGGING']
+        options = DebugOptions.new
+        options.host = '127.0.0.1'
+        options.port = ENV["DEBUG_PORT"].to_i
+        options.notify_dispatcher = false
+        Gauge::Log.info ATTACH_DEBUGGER_EVENT
+        Debugger.prepare_debugger(options)
+      end
     end
 
     def self.execute_step(step, args)
-      block = MethodCache.get_step step
+      si = MethodCache.get_step_info step
       if args.size == 1
-        block.call(args[0])
+        si[:block].call(args[0])
       else
-        block.call(args)
+        si[:block].call(args)
       end
     end
 

data/lib/gauge.rb

@@ -1,4 +1,4 @@
-# Copyright 2015 ThoughtWorks, Inc.
+# Copyright 2018 ThoughtWorks, Inc.
 
 # This file is part of Gauge-Ruby.
 
@@ -32,7 +32,7 @@ module Kernel
     #         puts "I am the $1 hook"
     #      end
     def hook(hook)
-      define_method hook do |options={}, &block|
+      define_method hook do |options = {}, &block|
         Gauge::MethodCache.send("add_#{hook}_hook".to_sym, options, &block)
       end
     end
@@ -104,31 +104,32 @@ module Kernel
   # @param block [block] the implementation block for given step.
   def step(*args, &block)
     opts = args.select {|x| x.is_a? Hash}
-    step_texts = args-opts
-    opts = {:continue_on_failure => false}.merge opts.reduce({}, :merge)
+    step_texts = args - opts
+    opts = { continue_on_failure: false }.merge opts.reduce({}, :merge)
     step_texts.each do |text|
-      parameterized_step_text = Gauge::Connector.step_value(text)
-      Gauge::MethodCache.add_step(parameterized_step_text, &block)
-      Gauge::MethodCache.add_step_text(parameterized_step_text, text)
-      Gauge::MethodCache.set_recoverable(parameterized_step_text) if opts[:continue_on_failure]
+      step_value = Gauge::Connector.step_value(text)
+      si = { location: { file: ENV['GAUGE_STEP_FILE'], span: {} },
+             block: block, step_text: text,
+             recoverable: opts[:continue_on_failure] }
+      Gauge::MethodCache.add_step(step_value, si)
     end
     Gauge::MethodCache.add_step_alias(*step_texts)
   end
 
   # Invoked before execution of every step.
-  tagged_hook "before_step"
+  tagged_hook 'before_step'
   # Invoked after execution of every step.
-  tagged_hook "after_step"
+  tagged_hook 'after_step'
   # Invoked before execution of every specification.
-  tagged_hook "before_spec"
+  tagged_hook 'before_spec'
   # Invoked after execution of every specification.
-  tagged_hook "after_spec"
+  tagged_hook 'after_spec'
   # Invoked before execution of every scenario.
-  tagged_hook "before_scenario"
+  tagged_hook 'before_scenario'
   # Invoked after execution of every scenario.
-  tagged_hook "after_scenario"
+  tagged_hook 'after_scenario'
   # Invoked before execution of the entire suite.
-  hook "before_suite"
+  hook 'before_suite'
   # Invoked after execution of the entire suite.
-  hook "after_suite"
+  hook 'after_suite'
 end

data/lib/gauge_runtime.rb

@@ -1,4 +1,4 @@
-# Copyright 2015 ThoughtWorks, Inc.
+# Copyright 2018 ThoughtWorks, Inc.
 
 # This file is part of Gauge-Ruby.
 
@@ -20,14 +20,17 @@ require 'protocol_buffers'
 
 require_relative 'messages.pb'
 require_relative 'executor'
+require_relative 'static_loader'
 require_relative 'connector'
 require_relative 'message_processor'
+require_relative 'util'
+require_relative 'log'
 
 
 module Gauge
   # @api private
   module Runtime
-    DEFAULT_IMPLEMENTATIONS_DIR_PATH = File.join(Dir.pwd, 'step_implementations')
+    DEFAULT_IMPLEMENTATIONS_DIR_PATH = Util.get_step_implementation_dir
 
     def self.dispatch_messages(socket)
       while (!socket.eof?)
@@ -35,7 +38,7 @@ module Gauge
         data = socket.read len
         message = Messages::Message.parse(data)
         handle_message(socket, message)
-        if (message.messageType == Messages::Message::MessageType::KillProcessRequest || message.messageType == Messages::Message::MessageType::ExecutionEnding)
+        if message.messageType == Messages::Message::MessageType::KillProcessRequest || message.messageType == Messages::Message::MessageType::ExecutionEnding
           socket.close
           return
         end
@@ -44,14 +47,14 @@ module Gauge
 
 
     def self.handle_message(socket, message)
-      if (!MessageProcessor.is_valid_message(message))
-        puts "Invalid message received : #{message}"
+      if !MessageProcessor.is_valid_message(message)
+        Gauge::Log.error "Invalid message received : #{message}"
         execution_status_response = Messages::ExecutionStatusResponse.new(:executionResult => Messages::ProtoExecutionResult.new(:failed => true, :executionTime => 0))
         message = Messages::Message.new(:messageType => Messages::Message::MessageType::ExecutionStatusResponse, :messageId => message.messageId, :executionStatusResponse => execution_status_response)
         write_message(socket, message)
       else
         response = MessageProcessor.process_message message
-        write_message(socket, response)
+        write_message(socket, response) if response
       end
     end
 
@@ -62,18 +65,19 @@ module Gauge
       socket.write serialized_message
     end
 
-    def self.portFromEnvVariable(envVariable)
-      port = ENV[envVariable]
-      if (port.nil?)
-        raise RuntimeError, "Could not find Env variable :#{envVariable}"
+    def self.port_from_env_variable(env_variable)
+      port = ENV[env_variable]
+      if port.nil?
+        raise RuntimeError, "Could not find Env variable :#{env_variable}"
       end
       return port
     end
 
     STDOUT.sync = true
-    Connector.make_connections()
-    Executor.load_steps(DEFAULT_IMPLEMENTATIONS_DIR_PATH)
-    dispatch_messages(Connector.executionSocket)
+    GaugeLog.init
+    Connector.make_connection
+    StaticLoader.load_files(DEFAULT_IMPLEMENTATIONS_DIR_PATH)
+    dispatch_messages(Connector.execution_socket)
     exit(0)
   end
 end

data/lib/log.rb

@@ -0,0 +1,33 @@
+# 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 'logger'
+
+module Gauge
+    Log = Logger.new(STDOUT)
+    module GaugeLog
+        def self.init()
+            Log.formatter = proc do |severity, datetime, progname, msg|
+                if ENV['IS_DAEMON']
+                    "#{datetime.strftime('%H:%M:%S.%L')} #{msg}\n"
+                else
+                    "#{msg}\n"
+                end
+            end
+        end 
+    end
+end