fastlane 2.73.0 → 2.74.0.beta.20180106010004

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a60f5fe37ddce7931d25079c7d083ebe840b42a6
-  data.tar.gz: b6438be238ba86f59e014453052abb76423e7502
+  metadata.gz: 244eb914f52a52b8114ccf2b46476f43d44ed56e
+  data.tar.gz: fd4ddc091bb00205542592c5925a9eaa66ff5116
 SHA512:
-  metadata.gz: 6fe03b54f9eb4ebe997e9195326e325d7cb73ee08ed68b53ef3aa10c290338238cd388de7827c458aef55657eb020edccff47091fdcd2810745b6d4b103e0301
-  data.tar.gz: 7bbe34f2689363834606058664d2584036a389e139035d004f9c0b9de26832859f64c892f2071727489cc189a1b21cb2dfcc1e7a013a60356e6b9441125b6425
+  metadata.gz: ee764b619920b915d8b7bc4958b758d47599d0f0af067bf9265801a63b933f671a3fcc9f71b823f8bc8647f4dea31603d19f4bab540ebc15fb8cdd978f33a0e7
+  data.tar.gz: 5a5fc60562c8d5b48acb9f9b880fd484c503d3e1a4b1bd84cae6434cfe609acb232a1bf7a9bc90e0370f01441385bf70d58a4e60316fdf5f2fcfd0fbbc3f5133

data/deliver/lib/assets/summary.html.erb

@@ -261,7 +261,8 @@
           </div>
         
         <hr />
-      <% end # end data %>
+      <% end # end data
+      %>
       <% if @options[:trade_representative_contact_information] %>
         <div class="app-minor-information">
           <div class="cat-headline">Trade Representative Contact Information</div>

data/fastlane/lib/fastlane.rb

@@ -20,8 +20,6 @@ require 'fastlane/supported_platforms'
 require 'fastlane/configuration_helper'
 require 'fastlane/one_off'
 require 'fastlane/server/socket_server_action_command_executor'
-require 'fastlane/server/command_executor'
-require 'fastlane/server/command'
 require 'fastlane/server/socket_server'
 require 'fastlane/command_line_handler'
 require 'fastlane/documentation/docs_generator'

data/fastlane/lib/fastlane/commands_generator.rb

@@ -43,7 +43,10 @@ module Fastlane
     ensure
       Fastlane::PluginUpdateManager.show_update_status
       if FastlaneCore::Globals.capture_output?
-        FastlaneCore::Globals.captured_output = Helper.strip_ansi_colors($stdout.string)
+        if $stdout.respond_to?(:string)
+          # Sometimes you can get NoMethodError: undefined method `string' for #<IO:<STDOUT>> when runing with FastlaneRunner (swift)
+          FastlaneCore::Globals.captured_output = Helper.strip_ansi_colors($stdout.string)
+        end
         $stdout = STDOUT
         $stderr = STDERR
 
@@ -87,7 +90,7 @@ module Fastlane
 
       global_option('--verbose') { FastlaneCore::Globals.verbose = true }
       global_option('--capture_output', 'Captures the output of the current run, and generates a markdown issue template') do
-        FastlaneCore::Globals.capture_output = true
+        FastlaneCore::Globals.capture_output = false
         FastlaneCore::Globals.verbose = true
       end
       global_option('--troubleshoot', 'Enables extended verbose mode. Use with caution, as this even includes ALL sensitive data. Cannot be used on CI.')

data/fastlane/lib/fastlane/lane_manager.rb

@@ -68,7 +68,6 @@ module Fastlane
       Fastlane::DocsGenerator.run(ff) unless skip_docs?
 
       duration = ((Time.now - started) / 60.0).round
-
       finish_fastlane(ff, duration, e)
 
       return ff
@@ -78,50 +77,6 @@ module Fastlane
       Helper.test? || FastlaneCore::Env.truthy?("FASTLANE_SKIP_DOCS")
     end
 
-    # All the finishing up that needs to be done
-    def self.finish_fastlane(ff, duration, error)
-      # Finished with all the lanes
-      Fastlane::JUnitGenerator.generate(Fastlane::Actions.executed_actions)
-      print_table(Fastlane::Actions.executed_actions)
-
-      Fastlane::PluginUpdateManager.show_update_status
-
-      if error
-        UI.error 'fastlane finished with errors'
-        raise error
-      elsif duration > 5
-        UI.success "fastlane.tools just saved you #{duration} minutes! 🎉"
-      else
-        UI.success 'fastlane.tools finished successfully 🎉'
-      end
-    end
-
-    # Print a table as summary of the executed actions
-    def self.print_table(actions)
-      return if actions.count == 0
-
-      require 'terminal-table'
-
-      rows = []
-      actions.each_with_index do |current, i|
-        is_error_step = !current[:error].to_s.empty?
-
-        name = current[:name][0..60]
-        name = name.red if is_error_step
-        index = i + 1
-        index = "💥" if is_error_step
-        rows << [index, name, current[:time].to_i]
-      end
-
-      puts ""
-      puts Terminal::Table.new(
-        title: "fastlane summary".green,
-        headings: ["Step", "Action", "Time (in s)"],
-        rows: FastlaneCore::PrintTable.transform_output(rows)
-      )
-      puts ""
-    end
-
     # Lane chooser if user didn't provide a lane
     # @param platform: is probably nil, but user might have called `fastlane android`, and only wants to list those actions
     def self.choose_lane(ff, platform)

data/fastlane/lib/fastlane/lane_manager_base.rb

@@ -7,7 +7,7 @@ module Fastlane
     end
 
     # All the finishing up that needs to be done
-    def self.finish_fastlane(ff, duration, error)
+    def self.finish_fastlane(ff, duration, error, skip_message: false)
       # Sometimes we don't have a fastfile because we're using Fastfile.swift
       unless ff.nil?
         ff.runner.did_finish
@@ -20,12 +20,12 @@ module Fastlane
       Fastlane::PluginUpdateManager.show_update_status
 
       if error
-        UI.error 'fastlane finished with errors'
+        UI.error 'fastlane finished with errors' unless skip_message
         raise error
       elsif duration > 5
-        UI.success "fastlane.tools just saved you #{duration} minutes! 🎉"
+        UI.success "fastlane.tools just saved you #{duration} minutes! 🎉" unless skip_message
       else
-        UI.success 'fastlane.tools finished successfully 🎉'
+        UI.success 'fastlane.tools finished successfully 🎉' unless skip_message
       end
     end
 

data/fastlane/lib/fastlane/runner.rb

@@ -347,6 +347,10 @@ module Fastlane
       @lanes ||= {}
     end
 
+    def did_finish
+      # to maintain compatibility with other sibling classes that have this API
+    end
+
     def before_each_blocks
       @before_each ||= {}
     end

data/fastlane/lib/fastlane/server/{command.rb → action_command.rb}

@@ -1,6 +1,5 @@
-require 'json'
-
 module Fastlane
+  # Represents an argument to the ActionCommand
   class Argument
     def initialize(json: nil)
       @name = json['name']
@@ -25,19 +24,28 @@ module Fastlane
     attr_reader :value_type
   end
 
-  class Command
+  # Represents a command that is meant to execute an Action on the client's behalf
+  class ActionCommand
+    attr_reader :command_id # always present
+    attr_reader :args # always present
+    attr_reader :method_name # always present
+    attr_reader :class_name # only present when executing a class-method
+
     def initialize(json: nil)
-      command_json = JSON.parse(json)
-      @method_name = command_json['methodName']
-      @class_name = command_json['className']
-      @command_id = command_json['commandID']
+      @method_name = json['methodName']
+      @class_name = json['className']
+      @command_id = json['commandID']
 
-      args_json = command_json['args'] ||= []
+      args_json = json['args'] ||= []
       @args = args_json.map do |arg|
         Argument.new(json: arg)
       end
     end
 
+    def cancel_signal?
+      return @command_id == "cancelFastlaneRun"
+    end
+
     def target_class
       unless class_name
         return nil
@@ -49,22 +57,5 @@ module Fastlane
     def is_class_method_command
       return class_name.to_s.length > 0
     end
-
-    attr_reader :command_id # always present
-    attr_reader :args # always present
-    attr_reader :method_name # always present
-    attr_reader :class_name # only present when executing a class-method
-  end
-
-  class CommandReturn
-    attr_reader :return_value
-    attr_reader :return_value_type
-    attr_reader :closure_argument_value
-
-    def initialize(return_value: nil, return_value_type: nil, closure_argument_value: nil)
-      @return_value = return_value
-      @closure_argument_value = closure_argument_value
-      @return_value_type = return_value_type
-    end
   end
 end

data/fastlane/lib/fastlane/server/action_command_return.rb

@@ -0,0 +1,14 @@
+module Fastlane
+  # Encapsulates the result and description of a return object returned by an executed fastlane action
+  class ActionCommandReturn
+    attr_reader :return_value
+    attr_reader :return_value_type
+    attr_reader :closure_argument_value
+
+    def initialize(return_value: nil, return_value_type: nil, closure_argument_value: nil)
+      @return_value = return_value
+      @closure_argument_value = closure_argument_value
+      @return_value_type = return_value_type
+    end
+  end
+end

data/fastlane/lib/fastlane/server/command_executor.rb

@@ -1,5 +1,3 @@
-require 'fastlane/server/command.rb'
-
 module Fastlane
   class CommandExecutor
     def execute(command: nil, target_object: nil)

data/fastlane/lib/fastlane/server/command_parser.rb

@@ -0,0 +1,20 @@
+require 'fastlane/server/action_command.rb'
+require 'fastlane/server/control_command.rb'
+require 'json'
+
+module Fastlane
+  class CommandParser
+    def self.parse(json: nil)
+      command_json = JSON.parse(json)
+      command_type = command_json['commandType'].to_sym
+      command = command_json['command']
+
+      case command_type
+      when :action
+        return ActionCommand.new(json: command)
+      when :control
+        return ControlCommand.new(json: command)
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/server/control_command.rb

@@ -0,0 +1,23 @@
+module Fastlane
+  # Represents a command that is meant to signal the server to do something on the client's behalf
+  # Examples are: :cancelFastlaneRune, and :done
+  class ControlCommand
+    attr_reader :command
+    attr_reader :user_message
+    attr_reader :reason
+
+    def initialize(json: nil)
+      @command = json['command'].to_sym
+      @user_message = json['userMessage']
+      @reason = json['reason'].to_sym if json['reason']
+    end
+
+    def cancel_signal?
+      return @command == :cancelFastlaneRun
+    end
+
+    def done_signal?
+      return @command == :done
+    end
+  end
+end

data/fastlane/lib/fastlane/server/json_return_value_processor.rb

@@ -0,0 +1,71 @@
+require 'json'
+
+module Fastlane
+  class JSONReturnValueProcessor
+    def prepare_object(return_value: nil, return_value_type: nil)
+      case return_value_type
+      when nil
+        UI.verbose("return_value_type is nil value: #{return_value}")
+        return process_value_as_string(return_value: return_value)
+      when :string
+        return process_value_as_string(return_value: return_value)
+      when :int
+        return process_value_as_int(return_value: return_value)
+      when :bool
+        return process_value_as_bool(return_value: return_value)
+      when :array_of_strings
+        return process_value_as_array_of_strings(return_value: return_value)
+      when :hash_of_strings
+        return process_value_as_hash_of_strings(return_value: return_value)
+      else
+        UI.verbose("Unknown return type defined: #{return_value_type} for value: #{return_value}")
+        return process_value_as_string(return_value: return_value)
+      end
+    end
+
+    def process_value_as_string(return_value: nil)
+      if return_value.nil?
+        return_value = ""
+      end
+
+      # quirks_mode because sometimes the built-in library is used for some folks and that needs quirks_mode: true
+      return JSON.generate(return_value.to_s, quirks_mode: true)
+    end
+
+    def process_value_as_array_of_strings(return_value: nil)
+      if return_value.nil?
+        return_value = []
+      end
+
+      # quirks_mode shouldn't be required for real objects
+      return JSON.generate(return_value)
+    end
+
+    def process_value_as_hash_of_strings(return_value: nil)
+      if return_value.nil?
+        return_value = {}
+      end
+
+      # quirks_mode shouldn't be required for real objects
+      return JSON.generate(return_value)
+    end
+
+    def process_value_as_bool(return_value: nil)
+      if return_value.nil?
+        return_value = false
+      end
+
+      # quirks_mode because sometimes the built-in library is used for some folks and that needs quirks_mode: true
+      return JSON.generate(return_value.to_s, quirks_mode: true)
+    end
+
+    def process_value_as_int(return_value: nil)
+      if return_value.nil?
+        return_value = 0
+      end
+
+      # quirks_mode because sometimes the built-in library is used for some folks and that needs quirks_mode: true
+      return JSON.generate(return_value.to_s, quirks_mode: true)
+    end
+  end
+end

data/fastlane/lib/fastlane/server/socket_server.rb

@@ -1,10 +1,17 @@
-require 'fastlane/server/command.rb'
 require 'fastlane/server/command_executor.rb'
+require 'fastlane/server/command_parser.rb'
+require 'fastlane/server/json_return_value_processor.rb'
 require 'socket'
 require 'json'
 
 module Fastlane
   class SocketServer
+    COMMAND_EXECUTION_STATE = {
+      ready: :ready,
+      already_shutdown: :already_shutdown,
+      error: :error
+    }
+
     attr_accessor :command_executor
     attr_accessor :return_value_processor
 
@@ -24,53 +31,112 @@ module Fastlane
       @stay_alive = stay_alive
     end
 
-    # This is the public API, don't call anything else
+    # this is the public API, don't call anything else
     def start
-      while listen
-        # Loop for-ev-er
+      listen
+
+      while @stay_alive
+        UI.important("stay_alive is set to true, restarting server")
+        listen
       end
     end
 
     private
 
     def receive_and_process_commands
-      # We'll break out of the infinite loop somehow, either error or 'done' message
-      ended_loop_due_to_error = true
-
-      loop do # No idea how many commands are coming, so we loop until an error or the done command is sent
-        str = nil
+      loop do # no idea how many commands are coming, so we loop until an error or the done command is sent
+        execution_state = COMMAND_EXECUTION_STATE[:ready]
 
+        command_string = nil
         begin
-          str = @client.recv(1_048_576) # 1024 * 1024
+          command_string = @client.recv(1_048_576) # 1024 * 1024
         rescue Errno::ECONNRESET => e
           UI.verbose(e)
-          break
+          execution_state = COMMAND_EXECUTION_STATE[:error]
         end
 
-        if str == 'done'
-          time = Time.new
-          UI.verbose("[#{time.usec}]: received done signal, shutting down")
-          ended_loop_due_to_error = false
-          break
+        if execution_state == COMMAND_EXECUTION_STATE[:ready]
+          # Ok, all is good, let's see what command we have
+          execution_state = parse_and_execute_command(command_string: command_string)
         end
-        response_json = process_command(command_json: str)
 
-        time = Time.new
-        UI.verbose("[#{time.usec}]: sending #{response_json}")
-        begin
-          @client.puts(response_json) # Send some json to the client
-        rescue Errno::EPIPE => e
-          UI.verbose(e)
+        case execution_state
+        when COMMAND_EXECUTION_STATE[:ready]
+          # command executed successfully, let's setup for the next command
+          next
+        when COMMAND_EXECUTION_STATE[:already_shutdown]
+          # we shutdown in response to a command, nothing left to do but exit
+          break
+        when COMMAND_EXECUTION_STATE[:error]
+          # we got an error somewhere, let's shutdown and exit
+          handle_disconnect(error: true, exit_reason: :error)
           break
         end
       end
+    end
+
+    def parse_and_execute_command(command_string: nil)
+      command = CommandParser.parse(json: command_string)
+      case command
+      when ControlCommand
+        return handle_control_command(command)
+      when ActionCommand
+        return handle_action_command(command)
+      end
 
-      return handle_disconnect(error: ended_loop_due_to_error)
+      # catch all
+      raise "Command #{command} not supported"
+    end
+
+    # we got a server control command from the client to do something like shutdown
+    def handle_control_command(command)
+      exit_reason = nil
+      if command.cancel_signal?
+        UI.verbose("received cancel signal shutting down, reason: #{command.reason}")
+
+        # send an ack to the client to let it know we're shutting down
+        cancel_response = '{"payload":{"status":"cancelled"}}'
+        send_response(cancel_response)
+
+        exit_reason = :cancelled
+      elsif command.done_signal?
+        UI.verbose("received done signal shutting down")
+
+        # client is already in the process of shutting down, no need to ack
+        exit_reason = :done
+      end
+
+      # if the command came in with a user-facing message, display it
+      if command.user_message
+        UI.important(command.user_message)
+      end
+
+      # currently all control commands should trigger a disconnect and shutdown
+      handle_disconnect(error: false, exit_reason: exit_reason)
+      return COMMAND_EXECUTION_STATE[:already_shutdown]
+    end
+
+    # execute and send back response to client
+    def handle_action_command(command)
+      response_json = process_action_command(command: command)
+      return send_response(response_json)
+    end
+
+    # send json back to client
+    def send_response(json)
+      UI.verbose("sending #{json}")
+      begin
+        @client.puts(json) # Send some json to the client
+      rescue Errno::EPIPE => e
+        UI.verbose(e)
+        return COMMAND_EXECUTION_STATE[:error]
+      end
+      return COMMAND_EXECUTION_STATE[:ready]
     end
 
     def listen
       @server = TCPServer.open('localhost', 2000) # Socket to listen on port 2000
-      UI.message("Waiting for #{@connection_timeout} seconds for a connection from FastlaneRunner")
+      UI.verbose("Waiting for #{@connection_timeout} seconds for a connection from FastlaneRunner")
 
       # set thread local to ready so we can check it
       Thread.current[:ready] = true
@@ -84,34 +150,32 @@ module Fastlane
       rescue StandardError => e
         UI.user_error!("Something went wrong while waiting for a connection from the FastlaneRunner binary, shutting down\n#{e}")
       end
-      UI.message("Client connected")
+      UI.verbose("Client connected")
 
+      # this loops forever
       receive_and_process_commands
     end
 
-    def handle_disconnect(error: false)
-      UI.important("Client disconnected, or a pipe broke") if error
-      if @stay_alive
-        UI.important("stay_alive is set to true, restarting server")
-        # clean up before restart
-        @client.close
-        @client = nil
+    def handle_disconnect(error: false, exit_reason: :error)
+      Thread.current[:exit_reason] = exit_reason
 
-        @server.close
-        @server = nil
-        return true # Restart server
-      end
-      return false # Don't restart server
+      UI.important("Client disconnected, a pipe broke, or received malformed data") if exit_reason == :error
+      # clean up
+      @client.close
+      @client = nil
+
+      @server.close
+      @server = nil
     end
 
-    def process_command(command_json: nil)
-      time = Time.new
-      UI.verbose("[#{time.usec}]: received command:#{command_json}")
-      return execute_command(command_json: command_json)
+    # record fastlane action command and then execute it
+    def process_action_command(command: nil)
+      UI.verbose("received command:#{command.inspect}")
+      return execute_action_command(command: command)
     end
 
-    def execute_command(command_json: nil)
-      command = Command.new(json: command_json)
+    # execute fastlane action command
+    def execute_action_command(command: nil)
       command_return = @command_executor.execute(command: command, target_object: nil)
       ## probably need to just return Strings, or ready_for_next with object isn't String
       return_object = command_return.return_value
@@ -133,8 +197,11 @@ module Fastlane
         closure_arg = ', "closure_argument_value": ' + closure_arg
       end
 
+      Thread.current[:exception] = nil
       return '{"payload":{"status":"ready_for_next", "return_object":' + return_object + closure_arg + '}}'
     rescue StandardError => e
+      Thread.current[:exception] = e
+
       exception_array = []
       exception_array << "#{e.class}:"
       exception_array << e.backtrace
@@ -146,72 +213,4 @@ module Fastlane
       return "{\"payload\":{\"status\":\"failure\",\"failure_information\":#{exception_array.flatten}}}"
     end
   end
-
-  class JSONReturnValueProcessor
-    def prepare_object(return_value: nil, return_value_type: nil)
-      case return_value_type
-      when nil
-        UI.verbose("return_value_type is nil value: #{return_value}")
-        return process_value_as_string(return_value: return_value)
-      when :string
-        return process_value_as_string(return_value: return_value)
-      when :int
-        return process_value_as_int(return_value: return_value)
-      when :bool
-        return process_value_as_bool(return_value: return_value)
-      when :array_of_strings
-        return process_value_as_array_of_strings(return_value: return_value)
-      when :hash_of_strings
-        return process_value_as_hash_of_strings(return_value: return_value)
-      else
-        UI.verbose("Unknown return type defined: #{return_value_type} for value: #{return_value}")
-        return process_value_as_string(return_value: return_value)
-      end
-    end
-
-    def process_value_as_string(return_value: nil)
-      if return_value.nil?
-        return_value = ""
-      end
-
-      # quirks_mode because sometimes the built-in library is used for some folks and that needs quirks_mode: true
-      return JSON.generate(return_value.to_s, quirks_mode: true)
-    end
-
-    def process_value_as_array_of_strings(return_value: nil)
-      if return_value.nil?
-        return_value = []
-      end
-
-      # quirks_mode shouldn't be required for real objects
-      return JSON.generate(return_value)
-    end
-
-    def process_value_as_hash_of_strings(return_value: nil)
-      if return_value.nil?
-        return_value = {}
-      end
-
-      # quirks_mode shouldn't be required for real objects
-      return JSON.generate(return_value)
-    end
-
-    def process_value_as_bool(return_value: nil)
-      if return_value.nil?
-        return_value = false
-      end
-
-      # quirks_mode because sometimes the built-in library is used for some folks and that needs quirks_mode: true
-      return JSON.generate(return_value.to_s, quirks_mode: true)
-    end
-
-    def process_value_as_int(return_value: nil)
-      if return_value.nil?
-        return_value = 0
-      end
-
-      # quirks_mode because sometimes the built-in library is used for some folks and that needs quirks_mode: true
-      return JSON.generate(return_value.to_s, quirks_mode: true)
-    end
-  end
 end