gauge-ruby 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4e04db5143c0125740f2adb38e62d1dd57ad9670
-  data.tar.gz: 14d3f58fdf3e195028b69bc0c7758922cb2a27f8
+  metadata.gz: 3d02594acc904fc72ca2ee33b36d035f16a2f7d6
+  data.tar.gz: 101648409eacd64b386ee67a779676fb4c7e3d34
 SHA512:
-  metadata.gz: eb5ada07b9e706a722b480a17e75f8e88bc17c32e0317e88f2ece1f9cd6b744fdc3199cbfec05159fc7ebe4ba26be5fa68291781b6f892fff1b2692665aa027e
-  data.tar.gz: 3c11170de25a233e43d309d7eb47bba637a1124a0af38dfa78b2cfc16ec236899badf59ee5d2aa67330fa09244a585c612263183ce71a441b462e08717d45434
+  metadata.gz: 4447626f14695ddf0f3ce41562007a4544e4f55451ef0a9d613c83e552f8d1c2c77a04c41021826ae58f31edfb4bbaf18753a4048064d4cb33ed74aabee3012b
+  data.tar.gz: 99a5cf6190e7e4ab33736ee3dfd15c7b568a30d6fee44681341c4123664f0ddc91b0fca511f47fd489ba23d9e9a9d3a5074ee452ee9bee82dd42c5c995e54713

data/lib/code_parser.rb

@@ -19,6 +19,7 @@ require 'parser/current'
 require 'method_source'
 require 'fileutils'
 require 'tempfile'
+require 'util'
 
 module Gauge
   # @api private
@@ -32,9 +33,13 @@ module Gauge
     def self.refactor_args(code, param_positions, new_param_values, new_step_text)
       new_params = []
       args = step_args_from_code code
-      param_positions.sort_by!(&:newPosition).each { |e|
+      param_positions.sort_by!(&:newPosition).each.with_index { |e,i|
         if e.oldPosition == -1
-          new_params[e.newPosition] = "arg_#{new_param_values[e.newPosition].downcase.split.join('_')}"
+          param = Util.remove_special_chars new_param_values[e.newPosition].downcase.split.join('_')
+          if param == ''
+            param = i
+          end
+          new_params[e.newPosition] = "arg_#{param}"
         else
           new_params[e.newPosition] = args[e.oldPosition].children[0]
         end
@@ -58,8 +63,7 @@ module Gauge
 
     def self.refactor(code, param_positions, new_param_values, new_step_text)
       source_code=code.source
-      ast = code_to_ast source_code
-      file, line = code.source_location
+      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)})

data/lib/configuration.rb

@@ -22,7 +22,8 @@ module Gauge
   class << self
     # @api public
     # Custom configuration for Gauge
-    # Lets you configure modules that need to be included at runtime.
+    # - Lets you configure modules that need to be included at runtime.
+    # - Lets you define a custom screengrabber, which will be invoked to capture screenshot on failure.
     # 
     # @example
     #   # Given there are two modules defined
@@ -37,6 +38,12 @@ module Gauge
     #   Gauge.configure do |config|
     #     config.include Foo, Bar
     #   end
+    # @example
+    #   # Default behaviour is to capture the active desktop at the point of failure.
+    #   # The implementation should return a byte array of the image.
+    #   Gauge.configure do |config|
+    #     config.screengrabber =  -> { return File.binread("/path/to/screenshot")}
+    #   end
     def configure(&block)
       Configuration.instance.instance_eval &block
     end
@@ -46,6 +53,13 @@ module Gauge
   class Configuration
     def initialize
       @includes=[]
+      @screengrabber = -> {
+          file = File.open("#{Dir.tmpdir}/screenshot.png", "w+")
+          `gauge_screenshot #{file.path}`
+          file_content = File.binread(file.path)
+          File.delete file
+          return file_content
+      }
     end
 
     def self.instance
@@ -60,6 +74,14 @@ module Gauge
       @includes
     end
 
+    def screengrabber
+      @screengrabber
+    end
+
+    def screengrabber=(block)
+      @screengrabber=block
+    end
+
     def self.include_configured_modules
       # include all modules that have been configured
       # TODO: move this feature to something more specific, ex look at supporting Sandboxed execution.

data/lib/executor.rb

@@ -21,7 +21,13 @@ module Gauge
   # @api private
   module Executor
     def self.load_steps(steps_implementation_dir)
-      Dir["#{steps_implementation_dir}/**/*.rb"].each { |x| require x }
+      Dir["#{steps_implementation_dir}/**/*.rb"].each { |x|
+        begin
+          require x
+        rescue Exception => e
+          puts "[ERROR] Cannot import #{x}. Reason: #{e.message}"
+        end
+      }
     end
 
     def self.execute_step(step, args)

data/lib/gauge.rb

@@ -89,13 +89,28 @@ module Kernel
   #       puts x.columns.join("|")
   #       x.rows.each { |r| puts r.join("|") }
   #   end
+  # @example
+  #   # for a given step say
+  #   # setting :continue_on_failure=>true in implementation will not break on failure of this step
+  #   # and will continue to execute the next step in the scenario
+  #   # * say "hello" to "gauge"
+  #   step 'say <what> to <who>', :continue_on_failure => false do |what, who|
+  #     puts "say #{what} to #{who}"
+  #     raise "Some Failure"
+  #   end
+  #
   # @param step_texts [string, ...] the step text(s)
+  # @param opts [Hash] pass :continue_on_failure => true to tell Gauge not to break on failure for this step
   # @param block [block] the implementation block for given step.
-  def step(*step_texts, &block)
+  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.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]
     end
     Gauge::MethodCache.add_step_alias(*step_texts)
   end

data/lib/gauge_runtime.rb

@@ -74,5 +74,6 @@ module Gauge
     Connector.make_connections()
     Executor.load_steps(DEFAULT_IMPLEMENTATIONS_DIR_PATH)
     dispatch_messages(Connector.executionSocket)
+    exit(0)
   end
 end

data/lib/messages.pb.rb

@@ -157,6 +157,7 @@ module Gauge
         set_fully_qualified_name "gauge.messages.StepValidateResponse.ErrorType"
 
         STEP_IMPLEMENTATION_NOT_FOUND = 0
+        DUPLICATE_STEP_IMPLEMENTATION = 1
       end
 
       set_fully_qualified_name "gauge.messages.StepValidateResponse"

data/lib/method_cache.rb

@@ -34,11 +34,16 @@ module Gauge
     end
 
     def self.add_step(parameterized_step_text, &block)
-      @@steps_map[parameterized_step_text] = block
+      @@steps_map[parameterized_step_text] = @@steps_map[parameterized_step_text] || []
+      @@steps_map[parameterized_step_text].push(block)
     end
 
     def self.get_step(parameterized_step_text)
-      @@steps_map[parameterized_step_text]
+      @@steps_map[parameterized_step_text][0]
+    end
+
+    def self.get_steps(parameterized_step_text)
+      @@steps_map[parameterized_step_text] || []
     end
 
     def self.add_step_text(parameterized_step_text, step_text)
@@ -65,10 +70,19 @@ module Gauge
       @@steps_text_map.values
     end
 
+    def self.is_recoverable?(parameterized_step_text)
+      @@recoverable_steps.include? parameterized_step_text
+    end
+
+    def self.set_recoverable(parameterized_step_text)
+      @@recoverable_steps.push parameterized_step_text
+    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/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)
+        return handle_failure message, e, time_elapsed_since(start_time), MethodCache.is_recoverable?(step_text)
       end
       handle_pass message, time_elapsed_since(start_time)
     end

data/lib/processors/execution_handler.rb

@@ -27,7 +27,7 @@ module Gauge
         if execution_error == nil
           return handle_pass message, time_elapsed_since(start_time)
         else
-          return handle_failure message, execution_error, time_elapsed_since(start_time)
+          return handle_failure message, execution_error, time_elapsed_since(start_time), false
         end
       end
 
@@ -36,11 +36,11 @@ module Gauge
         Messages::Message.new(:messageType => Messages::Message::MessageType::ExecutionStatusResponse, :messageId => message.messageId, :executionStatusResponse => execution_status_response)
       end
 
-      def handle_failure(message, exception, execution_time)
+      def handle_failure(message, exception, execution_time, recoverable)
         execution_status_response = 
           Messages::ExecutionStatusResponse.new(
             :executionResult => Messages::ProtoExecutionResult.new(:failed => true,
-             :recoverableError => false,
+             :recoverableError => recoverable,
              :errorMessage => exception.message,
              :stackTrace => exception.backtrace.join("\n")+"\n",
              :executionTime => execution_time,
@@ -51,11 +51,12 @@ module Gauge
 
       def screenshot_bytes
         return nil if (ENV['screenshot_enabled'] || "").downcase == "false" || which("gauge_screenshot").nil?
-        file = File.open("#{Dir.tmpdir}/screenshot.png", "w+")
-        `gauge_screenshot #{file.path}`
-        file_content = File.binread(file.path)
-        File.delete file
-        return file_content
+        begin
+          Configuration.instance.screengrabber.call
+        rescue Exception => e
+          puts e
+          return nil
+        end
       end
 
       def time_elapsed_since(start_time)
@@ -85,7 +86,7 @@ module Gauge
           }
         end
         return nil
-      end      
+      end
     end
   end
 end

data/lib/processors/refactor_step_request_processor.rb

@@ -22,15 +22,23 @@ module Gauge
     def refactor_step(message)
       oldStepValue = message.refactorRequest.oldStepValue.stepValue
       newStep = message.refactorRequest.newStepValue
-      stepBlock = MethodCache.get_step oldStepValue
       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
+        refactor_response.filesChanged = [file]
       rescue Exception => e
         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]
+    end
   end
 end

data/lib/processors/step_validation_request_processor.rb

@@ -19,9 +19,20 @@ module Gauge
   module Processors
     def process_step_validation_request(message)
       step_validate_request = message.stepValidateRequest
-      is_valid = MethodCache.valid_step?(step_validate_request.stepText)
-      step_validate_response = Messages::StepValidateResponse.new(:isValid => is_valid,
-        :errorMessage => is_valid ? "" : "Step implementation not found", :errorType => Messages::StepValidateResponse::ErrorType::STEP_IMPLEMENTATION_NOT_FOUND)
+      is_valid = true
+      msg = ''
+      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
+        is_valid = false
+        msg = 'Step implementation not found'
+        err_type = Messages::StepValidateResponse::ErrorType::STEP_IMPLEMENTATION_NOT_FOUND
+      end
+      step_validate_response = Messages::StepValidateResponse.new(:isValid => is_valid, :errorMessage => msg, :errorType => err_type)
       Messages::Message.new(:messageType => Messages::Message::MessageType::StepValidateResponse,
         :messageId => message.messageId, 
         :stepValidateResponse => step_validate_response)

data/lib/spec.pb.rb

@@ -9,6 +9,7 @@ module Gauge
     class ProtoSpec < ::ProtocolBuffers::Message; end
     class ProtoItem < ::ProtocolBuffers::Message; end
     class ProtoScenario < ::ProtocolBuffers::Message; end
+    class Span < ::ProtocolBuffers::Message; end
     class ProtoTableDrivenScenario < ::ProtocolBuffers::Message; end
     class ProtoStep < ::ProtocolBuffers::Message; end
     class ProtoConcept < ::ProtocolBuffers::Message; end
@@ -80,6 +81,16 @@ module Gauge
       optional :int64, :executionTime, 8
       required :bool, :skipped, 9
       repeated :string, :skipErrors, 10
+      optional :string, :ID, 11
+      repeated ::Gauge::Messages::ProtoItem, :tearDownSteps, 12
+      optional ::Gauge::Messages::Span, :span, 13
+    end
+
+    class Span < ::ProtocolBuffers::Message
+      set_fully_qualified_name "gauge.messages.Span"
+
+      required :int64, :start, 1
+      required :int64, :end, 2
     end
 
     class ProtoTableDrivenScenario < ::ProtocolBuffers::Message
@@ -185,6 +196,18 @@ module Gauge
     end
 
     class ProtoExecutionResult < ::ProtocolBuffers::Message
+      # forward declarations
+
+      # enums
+      module ErrorType
+        include ::ProtocolBuffers::Enum
+
+        set_fully_qualified_name "gauge.messages.ProtoExecutionResult.ErrorType"
+
+        ASSERTION = 1
+        VERIFICATION = 2
+      end
+
       set_fully_qualified_name "gauge.messages.ProtoExecutionResult"
 
       required :bool, :failed, 1
@@ -194,6 +217,7 @@ module Gauge
       optional :bytes, :screenShot, 5
       required :int64, :executionTime, 6
       repeated :string, :message, 7
+      optional ::Gauge::Messages::ProtoExecutionResult::ErrorType, :errorType, 8, :default => ::Gauge::Messages::ProtoExecutionResult::ErrorType::ASSERTION
     end
 
     class ProtoHookFailure < ::ProtocolBuffers::Message

data/lib/table.rb

@@ -24,20 +24,18 @@ module Gauge
       @columns = protoTable.headers.cells
       @rows = []
       protoTable.rows.each do |row|
-          @rows.push row.cells
+          @rows.push Row.new(@columns, row.cells)
       end
     end
 
     # Gets the column headers of the table
     # @return [string[]]
-    # @deprecated Use [] accessor instead
     def columns
       @columns
     end
 
     # Gets the rows of the table. The rows are two dimensional arrays.
     # @return [string[][]]
-    # @deprecated Use {#[]} accessor instead
     def rows
       @rows
     end
@@ -53,18 +51,38 @@ module Gauge
     #   table["Col1"] => ["Row1.Cell1", "Row1.Cell1", ...]
     #   table["Invalid_Col_Name"] => nil
     def [](index)
-      return row_values_as_hash(@rows[index]) if index.is_a?(Integer)
+      return @rows[index] if index.is_a?(Integer)
       column_values_as_array(index)
     end
 
     private
-    def row_values_as_hash(row)
-      row.nil? ? nil : Hash[@columns.zip(row)]
-    end
 
     def column_values_as_array(col_name)
       i = @columns.index col_name
       i.nil? ? nil : @rows.map { |r| r[i] }
     end
   end
+
+  # Holds a row of a table.
+  # @api public
+  class Row
+    # @api private
+    def initialize(columns, values)
+      @values = values
+      @columns = columns
+    end
+
+    # Gets the row cell.
+    # @param index Either cell index, or Column name.
+    # @return [string] value of the row cell
+    # @example
+    #   row[0] => 'value'
+    #   row['column'] => 'value'
+    #   row[i] => nil # when index is out of range
+    def [](index)
+      return @values[index] if index.is_a?(Integer)
+      columns_index = @columns.index(index)
+      columns_index.nil? ? nil : @values[columns_index]
+    end
+  end
 end

data/lib/util.rb

@@ -0,0 +1,37 @@
+# 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/>.
+
+module Gauge
+  class Util
+    def self.valid_variable_name?(var_name)
+      Object.new.instance_variable_set ('@'+var_name).to_sym, nil
+      true
+    rescue NameError
+      !!(var_name =~ /^[0-9]+$/)
+    end
+
+    def self.remove_special_chars(param)
+      new_param = ''
+      param.each_char { |c|
+        if valid_variable_name? c
+           new_param += c
+        end
+      }
+      return new_param
+      end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gauge-ruby
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Gauge Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-15 00:00:00.000000000 Z
+date: 2016-07-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-protocol-buffers
@@ -96,6 +96,7 @@ files:
 - lib/processors/step_validation_request_processor.rb
 - lib/spec.pb.rb
 - lib/table.rb
+- lib/util.rb
 homepage: http://www.getgauge.io
 licenses:
 - GPL-3.0
@@ -116,8 +117,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '1.9'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Ruby support for Gauge
 test_files: []
+has_rdoc: yard