fastlane 2.173.0 → 2.194.0

data/scan/lib/scan/detect_values.rb

@@ -15,22 +15,24 @@ module Scan
 
       prevalidate
 
-      # Detect the project
-      FastlaneCore::Project.detect_projects(config)
-      Scan.project = FastlaneCore::Project.new(config)
-
-      # Go into the project's folder, as there might be a Snapfile there
-      imported_path = File.expand_path(Scan.scanfile_name)
-      Dir.chdir(File.expand_path("..", Scan.project.path)) do
-        config.load_configuration_file(Scan.scanfile_name) unless File.expand_path(Scan.scanfile_name) == imported_path
-      end
+      # Detect the project if not SPM package
+      if Scan.config[:package_path].nil?
+        FastlaneCore::Project.detect_projects(config)
+        Scan.project = FastlaneCore::Project.new(config)
+
+        # Go into the project's folder, as there might be a Snapfile there
+        imported_path = File.expand_path(Scan.scanfile_name)
+        Dir.chdir(File.expand_path("..", Scan.project.path)) do
+          config.load_configuration_file(Scan.scanfile_name) unless File.expand_path(Scan.scanfile_name) == imported_path
+        end
 
-      Scan.project.select_scheme
+        Scan.project.select_scheme
+      end
 
       devices = Scan.config[:devices] || Array(Scan.config[:device]) # important to use Array(nil) for when the value is nil
       if devices.count > 0
         detect_simulator(devices, '', '', '', nil)
-      else
+      elsif Scan.project
         if Scan.project.ios?
           # An iPhone 5s is a reasonably small and useful default for tests
           detect_simulator(devices, 'iOS', 'IPHONEOS_DEPLOYMENT_TARGET', 'iPhone 5s', nil)
@@ -38,6 +40,7 @@ module Scan
           detect_simulator(devices, 'tvOS', 'TVOS_DEPLOYMENT_TARGET', 'Apple TV 1080p', 'TV')
         end
       end
+
       detect_destination
 
       default_derived_data
@@ -72,6 +75,8 @@ module Scan
     end
 
     def self.default_derived_data
+      return unless Scan.project
+
       return unless Scan.config[:derived_data_path].to_s.empty?
       default_path = Scan.project.build_settings(key: "BUILT_PRODUCTS_DIR")
       # => /Users/.../Library/Developer/Xcode/DerivedData/app-bqrfaojicpsqnoglloisfftjhksc/Build/Products/Release-iphoneos
@@ -162,7 +167,10 @@ module Scan
               filter_simulators(simulators, :equal, version).tap(&potential_emptiness_error).select(&selector)
             end
           ).tap do |array|
-            UI.error("Ignoring '#{device_string}', couldn’t find matching simulator") if array.empty?
+            if array.empty?
+              UI.test_failure!("No device found with name '#{device_string}'") if Scan.config[:ensure_devices_found]
+              UI.error("Ignoring '#{device_string}', couldn’t find matching simulator")
+            end
           end
         end
 
@@ -213,14 +221,18 @@ module Scan
         Scan.config[:destination] = ["platform=macOS,variant=Mac Catalyst"]
       elsif Scan.devices && Scan.devices.count > 0
         Scan.config[:destination] = Scan.devices.map { |d| "platform=#{d.os_type} Simulator,id=#{d.udid}" }
-      elsif Scan.project.mac_app?
+      elsif Scan.project && Scan.project.mac_app?
         Scan.config[:destination] = min_xcode8? ? ["platform=macOS"] : ["platform=OS X"]
       end
     end
 
     # get deployment target version
     def self.get_deployment_target_version(deployment_target_key)
-      Scan.config[:deployment_target_version] || Scan.project.build_settings(key: deployment_target_key) || '0'
+      version = Scan.config[:deployment_target_version]
+      version ||= Scan.project.build_settings(key: deployment_target_key) if Scan.project
+      version ||= 0
+
+      return version
     end
   end
 end

data/scan/lib/scan/module.rb

@@ -23,6 +23,7 @@ module Scan
     end
 
     def building_mac_catalyst_for_mac?
+      return false unless Scan.project
       Scan.project.supports_mac_catalyst? && Scan.config[:catalyst_platform] == "macos"
     end
   end

data/scan/lib/scan/options.rb

@@ -24,19 +24,30 @@ module Scan
                                        v = File.expand_path(value.to_s)
                                        UI.user_error!("Workspace file not found at path '#{v}'") unless File.exist?(v)
                                        UI.user_error!("Workspace file invalid") unless File.directory?(v)
-                                       UI.user_error!("Workspace file is not a workspace, must end with .xcworkspace") unless v.include?(".xcworkspace")
                                      end),
         FastlaneCore::ConfigItem.new(key: :project,
                                      short_option: "-p",
                                      optional: true,
                                      env_name: "SCAN_PROJECT",
                                      description: "Path to the project file",
+                                     conflicting_options: [:package_path],
                                      verify_block: proc do |value|
                                        v = File.expand_path(value.to_s)
                                        UI.user_error!("Project file not found at path '#{v}'") unless File.exist?(v)
                                        UI.user_error!("Project file invalid") unless File.directory?(v)
                                        UI.user_error!("Project file is not a project file, must end with .xcodeproj") unless v.include?(".xcodeproj")
                                      end),
+        FastlaneCore::ConfigItem.new(key: :package_path,
+                                     short_option: "-P",
+                                     optional: true,
+                                     env_name: "SCAN_PACKAGE_PATH",
+                                     description: "Path to the Swift Package",
+                                     conflicting_options: [:project],
+                                     verify_block: proc do |value|
+                                       v = File.expand_path(value.to_s)
+                                       UI.user_error!("Package path not found at path '#{v}'") unless File.exist?(v)
+                                       UI.user_error!("Package path invalid") unless File.directory?(v)
+                                     end),
         FastlaneCore::ConfigItem.new(key: :scheme,
                                      short_option: "-s",
                                      optional: true,
@@ -69,6 +80,11 @@ module Scan
                                      default_value: false,
                                      type: Boolean,
                                      optional: true),
+        FastlaneCore::ConfigItem.new(key: :ensure_devices_found,
+                                     description: "Should fail if devices not found",
+                                     default_value: false,
+                                     type: Boolean,
+                                     optional: true),
 
         # simulator management
         FastlaneCore::ConfigItem.new(key: :force_quit_simulator,
@@ -269,6 +285,11 @@ module Scan
                                      optional: true,
                                      is_string: false,
                                      default_value: false),
+        FastlaneCore::ConfigItem.new(key: :output_xctestrun,
+                                     type: Boolean,
+                                     env_name: "SCAN_OUTPUT_XCTESTRUN",
+                                     description: "Should provide additional copy of .xctestrun file (settings.xctestrun) and place in output path?",
+                                     default_value: false),
         FastlaneCore::ConfigItem.new(key: :result_bundle,
                                      short_option: "-z",
                                      env_name: "SCAN_RESULT_BUNDLE",
@@ -462,11 +483,16 @@ module Scan
                                      type: Boolean,
                                      default_value: false),
         FastlaneCore::ConfigItem.new(key: :use_system_scm,
-                                     env_name: "SCAN_USE_SYSTEM_SCM",
-                                     description: "Lets xcodebuild use system's scm configuration",
-                                     optional: true,
-                                     type: Boolean,
-                                     default_value: false)
+                                    env_name: "SCAN_USE_SYSTEM_SCM",
+                                    description: "Lets xcodebuild use system's scm configuration",
+                                    optional: true,
+                                    type: Boolean,
+                                    default_value: false),
+        FastlaneCore::ConfigItem.new(key: :number_of_retries,
+                                    env_name: 'SCAN_NUMBER_OF_RETRIES',
+                                    description: "The number of times a test can fail before scan should stop retrying",
+                                    type: Integer,
+                                    default_value: 0)
 
       ]
     end

data/scan/lib/scan/runner.rb

@@ -51,7 +51,14 @@ module Scan
         end
       end
 
+      execute(retries: Scan.config[:number_of_retries])
+    end
+
+    def execute(retries: 0)
+      Scan.cache[:retry_attempt] = Scan.config[:number_of_retries] - retries
+
       command = @test_command_generator.generate
+
       prefix_hash = [
         {
           prefix: "Running Tests: ",
@@ -71,7 +78,12 @@ module Scan
                                               error: proc do |error_output|
                                                 begin
                                                   exit_status = $?.exitstatus
-                                                  ErrorHandler.handle_build_error(error_output, @test_command_generator.xcodebuild_log_path)
+                                                  if retries > 0
+                                                    # If there are retries remaining, run the tests again
+                                                    return retry_execute(retries: retries, error_output: error_output)
+                                                  else
+                                                    ErrorHandler.handle_build_error(error_output, @test_command_generator.xcodebuild_log_path)
+                                                  end
                                                 rescue => ex
                                                   SlackPoster.new.run({
                                                     build_errors: 1
@@ -79,9 +91,50 @@ module Scan
                                                   raise ex
                                                 end
                                               end)
+
       exit_status
     end
 
+    def retry_execute(retries:, error_output: "")
+      tests = retryable_tests(error_output)
+
+      if tests.empty?
+        UI.crash!("Failed to find failed tests to retry (could not parse error output)")
+      end
+
+      Scan.config[:only_testing] = tests
+      UI.important("Retrying tests: #{Scan.config[:only_testing].join(', ')}")
+
+      retries -= 1
+      UI.important("Number of retries remaining: #{retries}")
+
+      return execute(retries: retries)
+    end
+
+    def retryable_tests(input)
+      input = Helper.strip_ansi_colors(input)
+
+      retryable_tests = []
+
+      failing_tests = input.split("Failing tests:\n").fetch(1, [])
+                           .split("\n\n").first
+
+      suites = failing_tests.split(/(?=\n\s+[\w\s]+:\n)/)
+
+      suites.each do |suite|
+        suite_name = suite.match(/\s*([\w\s\S]+):/).captures.first
+
+        test_cases = suite.split(":\n").fetch(1, []).split("\n").each
+                          .select { |line| line.match?(/^\s+/) }
+                          .map { |line| line.strip.gsub(".", "/").gsub("()", "") }
+                          .map { |line| suite_name + "/" + line }
+
+        retryable_tests += test_cases
+      end
+
+      return retryable_tests.uniq
+    end
+
     def handle_results(tests_exit_status)
       if Scan.config[:disable_xcpretty]
         unless tests_exit_status == 0
@@ -110,6 +163,7 @@ module Scan
 
       copy_simulator_logs
       zip_build_products
+      copy_xctestrun
 
       if result[:failures] > 0
         open_report
@@ -150,6 +204,32 @@ module Scan
       UI.message("Successfully zipped build products: #{output_path}")
     end
 
+    def copy_xctestrun
+      return unless Scan.config[:output_xctestrun]
+
+      # Gets :derived_data_path/Build/Products directory for coping .xctestrun file
+      derived_data_path = Scan.config[:derived_data_path]
+      path = File.join(derived_data_path, "Build", "Products")
+
+      # Gets absolute path of output directory
+      output_directory = File.absolute_path(Scan.config[:output_directory])
+      output_path = File.join(output_directory, "settings.xctestrun")
+
+      # Caching path for action to put into lane_context
+      Scan.cache[:output_xctestrun] = output_path
+
+      # Copy .xctestrun file and moves it to output directory
+      UI.message("Copying .xctestrun file")
+      xctestrun_file = Dir.glob("#{path}/*.xctestrun").first
+
+      if xctestrun_file
+        FileUtils.cp(xctestrun_file, output_path)
+        UI.message("Successfully copied xctestrun file: #{output_path}")
+      else
+        UI.user_error!("Could not find .xctextrun file to copy")
+      end
+    end
+
     def test_results
       temp_junit_report = Scan.cache[:temp_junit_report]
       return File.read(temp_junit_report) if temp_junit_report && File.file?(temp_junit_report)

data/scan/lib/scan/test_command_generator.rb

@@ -15,13 +15,25 @@ module Scan
     end
 
     def prefix
-      ["set -o pipefail &&"]
+      prefixes = ["set -o pipefail &&"]
+
+      package_path = Scan.config[:package_path]
+      prefixes << "cd #{package_path} &&" if package_path.to_s != ""
+
+      prefixes
     end
 
     # Path to the project or workspace as parameter
     # This will also include the scheme (if given)
     # @return [Array] The array with all the components to join
     def project_path_array
+      unless Scan.config[:package_path].nil?
+        params = []
+        params << "-scheme #{Scan.config[:scheme].shellescape}" if Scan.config[:scheme]
+        params << "-workspace #{Scan.config[:workspace].shellescape}" if Scan.config[:workspace]
+        return params
+      end
+
       proj = Scan.project.xcodebuild_parameters
       return proj if proj.count > 0
       UI.user_error!("No project/workspace found")
@@ -33,7 +45,7 @@ module Scan
       options = []
       options += project_path_array unless config[:xctestrun]
       options << "-sdk '#{config[:sdk]}'" if config[:sdk]
-      options << destination # generated in `detect_values`
+      options << destination if destination # generated in `detect_values`
       options << "-toolchain '#{config[:toolchain]}'" if config[:toolchain]
       if config[:derived_data_path] && !options.include?("-derivedDataPath #{config[:derived_data_path].shellescape}")
         options << "-derivedDataPath #{config[:derived_data_path].shellescape}"
@@ -136,7 +148,15 @@ module Scan
 
     # Store the raw file
     def xcodebuild_log_path
-      file_name = "#{Scan.config[:app_name] || Scan.project.app_name}-#{Scan.config[:scheme]}.log"
+      parts = []
+      if Scan.config[:app_name]
+        parts << Scan.config[:app_name]
+      elsif Scan.project
+        parts << Scan.project.app_name
+      end
+      parts << Scan.config[:scheme] if Scan.config[:scheme]
+
+      file_name = "#{parts.join('-')}.log"
       containing = File.expand_path(Scan.config[:buildlog_path])
       FileUtils.mkdir_p(containing)
 
@@ -162,16 +182,21 @@ module Scan
       Scan.cache[:build_path]
     end
 
+    # The path to the result bundle
     def result_bundle_path
-      unless Scan.cache[:result_bundle_path]
-        ext = FastlaneCore::Helper.xcode_version.to_i >= 11 ? '.xcresult' : '.test_result'
-        path = File.join(Scan.config[:output_directory], Scan.config[:scheme]) + ext
-        if File.directory?(path)
-          FileUtils.remove_dir(path)
-        end
-        Scan.cache[:result_bundle_path] = path
-      end
-      return Scan.cache[:result_bundle_path]
+      retry_count = Scan.cache[:retry_attempt] || 0
+      attempt = retry_count > 0 ? "-#{retry_count}" : ""
+      ext = FastlaneCore::Helper.xcode_version.to_i >= 11 ? '.xcresult' : '.test_result'
+      path = File.join(Scan.config[:output_directory], Scan.config[:scheme]) + attempt + ext
+
+      Scan.cache[:result_bundle_path] = path
+
+      # The result bundle path will be in the package path directory if specified
+      delete_path = path
+      delete_path = File.join(Scan.config[:package_path], path) if Scan.config[:package_path].to_s != ""
+      FileUtils.remove_dir(delete_path) if File.directory?(delete_path)
+
+      return path
     end
   end
 end

data/scan/lib/scan/xcpretty_reporter_options_generator.rb

@@ -13,7 +13,7 @@ module Scan
                Scan.config[:xcpretty_args])
     end
 
-    # Intialize with values from Scan.config matching these param names
+    # Initialize with values from Scan.config matching these param names
     def initialize(open_report, output_types, output_files, output_directory, use_clang_report_name, xcpretty_args)
       @open_report = open_report
       @output_types = output_types

data/screengrab/lib/screengrab/android_environment.rb

@@ -4,86 +4,38 @@ require 'fastlane_core/command_executor'
 module Screengrab
   class AndroidEnvironment
     attr_reader :android_home
-    attr_reader :build_tools_version
 
     # android_home        - the String path to the install location of the Android SDK
-    # build_tools_version - the String version of the Android build tools that should be used
-    def initialize(android_home, build_tools_version)
+    # build_tools_version - the String version of the Android build tools that should be used, ignored
+    def initialize(android_home, build_tools_version = nil)
       @android_home = android_home
-      @build_tools_version = build_tools_version
     end
 
     def platform_tools_path
       @platform_tools_path ||= find_platform_tools(android_home)
     end
 
-    def build_tools_path
-      @build_tools_path ||= find_build_tools(android_home, build_tools_version)
-    end
-
     def adb_path
       @adb_path ||= find_adb(platform_tools_path)
     end
 
-    def aapt_path
-      @aapt_path ||= find_aapt(build_tools_path)
-    end
-
     private
 
     def find_platform_tools(android_home)
       return nil unless android_home
 
-      platform_tools_path = File.join(android_home, 'platform-tools')
+      platform_tools_path = Helper.localize_file_path(File.join(android_home, 'platform-tools'))
       File.directory?(platform_tools_path) ? platform_tools_path : nil
     end
 
-    def find_build_tools(android_home, build_tools_version)
-      return nil unless android_home
-
-      build_tools_dir = File.join(android_home, 'build-tools')
-
-      return nil unless build_tools_dir && File.directory?(build_tools_dir)
-
-      return File.join(build_tools_dir, build_tools_version) if build_tools_version
-
-      version = select_build_tools_version(build_tools_dir)
-
-      return version ? File.join(build_tools_dir, version) : nil
-    end
-
-    def select_build_tools_version(build_tools_dir)
-      # Collect the sub-directories of the build_tools_dir, rejecting any that start with '.' to remove . and ..
-      dir_names = Dir.entries(build_tools_dir).select { |e| !e.start_with?('.') && File.directory?(File.join(build_tools_dir, e)) }
-
-      # Collect a sorted array of Version objects from the directory names, handling the possibility that some
-      # entries may not be valid version names
-      versions = dir_names.map do |d|
-        begin
-          Gem::Version.new(d)
-        rescue
-          nil
-        end
-      end.reject(&:nil?).sort
-
-      # We'll take the last entry (highest version number) as the directory name we want
-      versions.last.to_s
-    end
-
     def find_adb(platform_tools_path)
       return FastlaneCore::CommandExecutor.which('adb') unless platform_tools_path
 
-      adb_path = File.join(platform_tools_path, 'adb')
+      adb_path = Helper.get_executable_path(File.join(platform_tools_path, 'adb'))
+      adb_path = Helper.localize_file_path(adb_path)
       return executable_command?(adb_path) ? adb_path : nil
     end
 
-    def find_aapt(build_tools_path)
-      return FastlaneCore::CommandExecutor.which('aapt') unless build_tools_path
-
-      aapt_path = File.join(build_tools_path, 'aapt')
-      return executable_command?(aapt_path) ? aapt_path : nil
-    end
-
     def executable_command?(cmd_path)
       Helper.executable?(cmd_path)
     end

data/screengrab/lib/screengrab/commands_generator.rb

@@ -1,6 +1,7 @@
 require 'commander'
 
 require 'fastlane/version'
+require 'fastlane_core/ui/help_formatter'
 require 'fastlane_core/fastlane_folder'
 require 'fastlane_core/configuration/configuration'
 require_relative 'android_environment'
@@ -26,7 +27,7 @@ module Screengrab
       program :help, 'Authors', 'Andrea Falcone <asfalcone@google.com>, Michael Furtak <mfurtak@google.com>'
       program :help, 'Website', 'https://fastlane.tools'
       program :help, 'Documentation', 'https://docs.fastlane.tools/actions/screengrab/'
-      program :help_formatter, :compact
+      program :help_formatter, FastlaneCore::HelpFormatter
 
       global_option('--verbose', 'Shows a more verbose output') { FastlaneCore::Globals.verbose = true }
 

data/screengrab/lib/screengrab/dependency_checker.rb

@@ -6,7 +6,6 @@ module Screengrab
       return if Helper.test?
 
       check_adb(android_env)
-      check_aapt(android_env)
     end
 
     def self.check_adb(android_env)
@@ -30,25 +29,6 @@ module Screengrab
       UI.user_error!('adb command not found')
     end
 
-    def self.check_aapt(android_env)
-      android_home = android_env.android_home
-      aapt_path = android_env.aapt_path
-
-      warn_if_command_path_not_relative_to_android_home('aapt', android_home, aapt_path)
-      # aapt is not required in order to function, so we'll only warn if we can't find it.
-      warn_missing_aapt(android_home) unless aapt_path
-    end
-
-    def self.warn_missing_aapt(android_home)
-      if android_home
-        UI.important("The `aapt` command could not be found relative to your provided ANDROID_HOME at #{android_home}")
-        UI.important("Please ensure that the Android SDK is installed and you have the build tools downloaded")
-      else
-        UI.important("The `aapt` command could not be found on your PATH")
-        UI.important("Please ensure that the Android SDK is installed and you have the build tools downloaded and present on your PATH")
-      end
-    end
-
     def self.warn_if_command_path_not_relative_to_android_home(cmd_name, android_home, cmd_path)
       if android_home && cmd_path && !cmd_path.start_with?(android_home)
         UI.important("Using `#{cmd_name}` found at #{cmd_path} which is not within the specified ANDROID_HOME at #{android_home}")

data/screengrab/lib/screengrab/options.rb

@@ -22,7 +22,8 @@ module Screengrab
         FastlaneCore::ConfigItem.new(key: :build_tools_version,
                                      short_option: "-i",
                                      optional: true,
-                                     description: "The Android build tools version to use, e.g. '23.0.2'"),
+                                     description: "The Android build tools version to use, e.g. '23.0.2'",
+                                     deprecated: true),
         FastlaneCore::ConfigItem.new(key: :locales,
                                      description: "A list of locales which should be used",
                                      short_option: "-q",
@@ -82,10 +83,12 @@ module Screengrab
                                      env_name: 'SCREENGRAB_ENDING_LOCALE',
                                      optional: true,
                                      default_value: 'en-US',
-                                     description: "Return the device to this locale after running tests"),
+                                     description: "Return the device to this locale after running tests",
+                                     deprecated: true),
         FastlaneCore::ConfigItem.new(key: :use_adb_root,
                                      env_name: 'SCREENGRAB_USE_ADB_ROOT',
                                      description: "Restarts the adb daemon using `adb root` to allow access to screenshots directories on device. Use if getting 'Permission denied' errors",
+                                     deprecated: true,
                                      default_value: false,
                                      type: Boolean),
         FastlaneCore::ConfigItem.new(key: :app_apk_path,