fastlane 2.141.0 → 2.142.0

data/fastlane/lib/fastlane/actions/notarize.rb

@@ -0,0 +1,183 @@
+module Fastlane
+  module Actions
+    class NotarizeAction < Action
+      def self.run(params)
+        package_path = params[:package]
+        bundle_id = params[:bundle_id]
+        try_early_stapling = params[:try_early_stapling]
+        print_log = params[:print_log]
+        verbose = params[:verbose]
+
+        # Compress and read bundle identifier only for .app bundle.
+        compressed_package_path = nil
+        if File.extname(package_path) == '.app'
+          compressed_package_path = "#{package_path}.zip"
+          Actions.sh(
+            "ditto -c -k --rsrc --keepParent \"#{package_path}\" \"#{compressed_package_path}\"",
+            log: verbose
+          )
+
+          unless bundle_id
+            info_plist_path = File.join(package_path, 'Contents', 'Info.plist')
+            bundle_id = Actions.sh(
+              "/usr/libexec/PlistBuddy -c \"Print :CFBundleIdentifier\" \"#{info_plist_path}\"",
+              log: verbose
+            ).strip
+          end
+        end
+
+        UI.user_error!('Could not read bundle identifier, provide as a parameter') unless bundle_id
+
+        apple_id_account = CredentialsManager::AccountManager.new(user: params[:username])
+
+        # Add password as a temporary environment variable for altool.
+        # Use app specific password if specified.
+        ENV['FL_NOTARIZE_PASSWORD'] = ENV['FASTLANE_APPLE_APPLICATION_SPECIFIC_PASSWORD'] || apple_id_account.password
+
+        UI.message('Uploading package to notarization service, might take a while')
+
+        notarization_upload_command = "xcrun altool --notarize-app -t osx -f \"#{compressed_package_path || package_path}\" --primary-bundle-id #{bundle_id} -u #{apple_id_account.user} -p @env:FL_NOTARIZE_PASSWORD --output-format xml"
+        notarization_upload_command << " --asc-provider \"#{params[:asc_provider]}\"" if params[:asc_provider]
+
+        notarization_upload_response = Actions.sh(
+          notarization_upload_command,
+          log: verbose
+        )
+
+        FileUtils.rm_rf(compressed_package_path) if compressed_package_path
+
+        notarization_upload_plist = Plist.parse_xml(notarization_upload_response)
+        notarization_request_id = notarization_upload_plist['notarization-upload']['RequestUUID']
+
+        UI.success("Successfully uploaded package to notarization service with request identifier #{notarization_request_id}")
+
+        notarization_info = {}
+        while notarization_info.empty? || (notarization_info['Status'] == 'in progress')
+          if notarization_info.empty?
+            UI.message('Waiting to query request status')
+          elsif try_early_stapling
+            UI.message('Request in progress, trying early staple')
+
+            begin
+              self.staple(package_path, verbose)
+              UI.message('Successfully notarized and early stapled package.')
+
+              return
+            rescue
+              UI.message('Early staple failed, waiting to query again')
+            end
+          end
+
+          sleep(30)
+
+          UI.message('Querying request status')
+
+          notarization_info_response = Actions.sh(
+            "xcrun altool --notarization-info #{notarization_request_id} -u #{apple_id_account.user} -p @env:FL_NOTARIZE_PASSWORD --output-format xml",
+            log: verbose
+          )
+
+          notarization_info_plist = Plist.parse_xml(notarization_info_response)
+          notarization_info = notarization_info_plist['notarization-info']
+        end
+
+        log_url = notarization_info['LogFileURL']
+        ENV['FL_NOTARIZE_LOG_FILE_URL'] = log_url
+        log_suffix = ''
+        if log_url && print_log
+          log_response = Net::HTTP.get(URI(log_url))
+          log_json_object = JSON.parse(log_response)
+          log_suffix = ", with log:\n#{JSON.pretty_generate(log_json_object)}"
+        end
+
+        case notarization_info['Status']
+        when 'success'
+          UI.message('Stapling package')
+
+          self.staple(package_path, verbose)
+
+          UI.success("Successfully notarized and stapled package#{log_suffix}")
+        when 'invalid'
+          UI.user_error!("Could not notarize package with message '#{notarization_info['Status Message']}'#{log_suffix}")
+        else
+          UI.crash!("Could not notarize package with status '#{notarization_info['Status']}'#{log_suffix}")
+        end
+      ensure
+        ENV.delete('FL_NOTARIZE_PASSWORD')
+      end
+
+      def self.staple(package_path, verbose)
+        Actions.sh(
+          "xcrun stapler staple \"#{package_path}\"",
+          log: verbose
+        )
+      end
+
+      def self.description
+        'Notarizes a macOS app'
+      end
+
+      def self.authors
+        ['zeplin']
+      end
+
+      def self.available_options
+        username = CredentialsManager::AppfileConfig.try_fetch_value(:apple_dev_portal_id)
+        username ||= CredentialsManager::AppfileConfig.try_fetch_value(:apple_id)
+
+        asc_provider = CredentialsManager::AppfileConfig.try_fetch_value(:itc_team_id)
+
+        [
+          FastlaneCore::ConfigItem.new(key: :package,
+                                       env_name: 'FL_NOTARIZE_PACKAGE',
+                                       description: 'Path to package to notarize, e.g. .app bundle or disk image',
+                                       is_string: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Could not find package at '#{value}'") unless File.exist?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :try_early_stapling,
+                                       env_name: 'FL_NOTARIZE_TRY_EARLY_STAPLING',
+                                       description: 'Whether to try early stapling while the notarization request is in progress',
+                                       optional: true,
+                                       default_value: false,
+                                       type: Boolean),
+          FastlaneCore::ConfigItem.new(key: :bundle_id,
+                                       env_name: 'FL_NOTARIZE_BUNDLE_ID',
+                                       description: 'Bundle identifier to uniquely identify the package',
+                                       optional: true,
+                                       is_string: true),
+          FastlaneCore::ConfigItem.new(key: :username,
+                                       env_name: 'FL_NOTARIZE_USERNAME',
+                                       description: 'Apple ID username',
+                                       default_value: username,
+                                       default_value_dynamic: true),
+          FastlaneCore::ConfigItem.new(key: :asc_provider,
+                                       env_name: 'FL_NOTARIZE_ASC_PROVIDER',
+                                       description: 'Provider short name for accounts associated with multiple providers',
+                                       optional: true,
+                                       default_value: asc_provider),
+          FastlaneCore::ConfigItem.new(key: :print_log,
+                                       env_name: 'FL_NOTARIZE_PRINT_LOG',
+                                       description: 'Whether to print notarization log file, listing issues on failure and warnings on success',
+                                       optional: true,
+                                       default_value: false,
+                                       type: Boolean),
+          FastlaneCore::ConfigItem.new(key: :verbose,
+                                       env_name: 'FL_NOTARIZE_VERBOSE',
+                                       description: 'Whether to log requests',
+                                       optional: true,
+                                       default_value: false,
+                                       type: Boolean)
+        ]
+      end
+
+      def self.is_supported?(platform)
+        platform == :mac
+      end
+
+      def self.category
+        :code_signing
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/s3.rb

@@ -434,8 +434,8 @@ module Fastlane
             access_key: ENV["S3_ACCESS_KEY"],               # Required from user.
             secret_access_key: ENV["S3_SECRET_ACCESS_KEY"], # Required from user.
             bucket: ENV["S3_BUCKET"],                       # Required from user.
-            ipa: "AppName.ipa",                             # Optional is you use `ipa` to build
-            dsym: "AppName.app.dSYM.zip",                   # Optional is you use `ipa` to build
+            ipa: "AppName.ipa",                             # Optional if you use `ipa` to build
+            dsym: "AppName.app.dSYM.zip",                   # Optional if you use `ipa` to build
             path: "v{CFBundleShortVersionString}_b{CFBundleVersion}/", # This is actually the default.
             upload_metadata: true,                          # Upload version.json, plist and HTML. Set to false to skip uploading of these files.
             version_file_name: "app_version.json",          # Name of the file to upload to S3. Defaults to "version.json"

data/fastlane/lib/fastlane/actions/spm.rb

@@ -15,6 +15,9 @@ module Fastlane
         end
         if params[:xcpretty_output]
           cmd += ["2>&1", "|", "xcpretty", "--#{params[:xcpretty_output]}"]
+          if params[:xcpretty_args]
+            cmd << (params[:xcpretty_args]).to_s
+          end
           cmd = %w(set -o pipefail &&) + cmd
         end
 
@@ -67,6 +70,11 @@ module Fastlane
                                        verify_block: proc do |value|
                                          UI.user_error!("Please pass a valid xcpretty output type: (#{xcpretty_output_types.join('|')})") unless xcpretty_output_types.include?(value)
                                        end),
+          FastlaneCore::ConfigItem.new(key: :xcpretty_args,
+                                       env_name: "FL_SPM_XCPRETTY_ARGS",
+                                       description: "Pass in xcpretty additional command line arguments (e.g. '--test --no-color' or '--tap --no-utf'), requires xcpretty_output to be specified also",
+                                       type: String,
+                                       optional: true),
           FastlaneCore::ConfigItem.new(key: :verbose,
                                        short_option: "-v",
                                        env_name: "FL_SPM_VERBOSE",

data/fastlane/lib/fastlane/actions/swiftlint.rb

@@ -37,6 +37,7 @@ module Fastlane
           Actions.sh(command)
         rescue
           handle_swiftlint_error(params[:ignore_exit_status], $?.exitstatus)
+          raise if params[:raise_if_swiftlint_error]
         end
       end
 
@@ -106,10 +107,22 @@ module Fastlane
                                        is_string: false,
                                        type: Boolean,
                                        optional: true),
+          FastlaneCore::ConfigItem.new(key: :raise_if_swiftlint_error,
+                                       description: "Raises an error if swiftlint fails, so you can fail CI/CD jobs if necessary \
+                                                    (true/false)",
+                                       default_value: false,
+                                       is_string: false,
+                                       type: Boolean,
+                                       optional: true),
           FastlaneCore::ConfigItem.new(key: :reporter,
-                                       description: 'Choose output reporter',
+                                       description: "Choose output reporter. Available: xcode, json, csv, checkstyle, junit, html, \
+                                                     emoji, sonarqube, markdown, github-actions-logging",
                                        is_string: true,
-                                       optional: true),
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         available = ['xcode', 'json', 'csv', 'checkstyle', 'junit', 'html', 'emoji', 'sonarqube', 'markdown', 'github-actions-logging']
+                                         UI.user_error!("Available values are '#{available.join("', '")}'") unless available.include?(value)
+                                       end),
           FastlaneCore::ConfigItem.new(key: :quiet,
                                        description: "Don't print status logs like 'Linting <file>' & 'Done linting'",
                                        default_value: false,
@@ -161,7 +174,9 @@ module Fastlane
               "AppDelegate.swift",
               "path/to/project/Model.swift"
             ],
+            raise_if_swiftlint_error: true,      # Allow fastlane to raise an error if swiftlint fails
             ignore_exit_status: true              # Allow fastlane to continue even if SwiftLint returns a non-zero exit status
+
           )'
         ]
       end

data/fastlane/lib/fastlane/actions/upload_symbols_to_crashlytics.rb

@@ -10,8 +10,8 @@ module Fastlane
         find_gsp_path(params)
         find_api_token(params)
 
-        if !params[:api_token] && !params[:gsp_path]
-          UI.user_error!('Either Fabric API key or path to Firebase Crashlytics GoogleService-Info.plist must be given.')
+        if !params[:app_id] && !params[:gsp_path] && !params[:api_token]
+          UI.user_error!('Either Firebase Crashlytics App ID, path to GoogleService-Info.plist or legacy Fabric API key must be given.')
         end
 
         dsym_paths = []
@@ -87,7 +87,9 @@ module Fastlane
         UI.message("Uploading '#{path}'...")
         command = []
         command << File.expand_path(params[:binary_path]).shellescape
-        if params[:gsp_path]
+        if params[:app_id]
+          command << "-ai #{params[:app_id].shellescape}"
+        elsif params[:gsp_path]
           command << "-gsp #{params[:gsp_path].shellescape}"
         elsif params[:api_token]
           command << "-a #{params[:api_token]}"
@@ -186,6 +188,14 @@ module Fastlane
                                          UI.user_error!("Couldn't find file at path '#{File.expand_path(value)}'") unless File.exist?(value)
                                          UI.user_error!("No Path to GoogleService-Info.plist for Firebase Crashlytics given, pass using `gsp_path: 'path'`") if value.to_s.length == 0
                                        end),
+          FastlaneCore::ConfigItem.new(key: :app_id,
+                                       env_name: "CRASHLYTICS_APP_ID",
+                                       sensitive: true,
+                                       optional: true,
+                                       description: "Firebase Crashlytics APP ID",
+                                       verify_block: proc do |value|
+                                         UI.user_error!("No App ID for Firebase Crashlytics given, pass using `app_id: 'appId'`") if value.to_s.length == 0
+                                       end),
           FastlaneCore::ConfigItem.new(key: :binary_path,
                                        env_name: "FL_UPLOAD_SYMBOLS_TO_CRASHLYTICS_BINARY_PATH",
                                        description: "The path to the upload-symbols file of the Fabric app",

data/fastlane/lib/fastlane/helper/adb_helper.rb

@@ -24,7 +24,7 @@ module Fastlane
           adb_path = File.join(android_home, "platform-tools", "adb")
         end
 
-        self.adb_path = adb_path
+        self.adb_path = File.expand_path(adb_path)
         self.adb_host = adb_host
       end
 

data/fastlane/lib/fastlane/plugins/plugin_manager.rb

@@ -373,7 +373,7 @@ module Fastlane
       # (a plugin may contain any number of actions)
       version_number = Fastlane::ActionCollector.determine_version(gem_name)
       references = Fastlane.const_get(module_name).all_classes.collect do |path|
-        next unless File.dirname(path).end_with?("/actions") # we only want to match actions
+        next unless File.dirname(path).include?("/actions") # we only want to match actions
 
         File.basename(path).gsub("_action", "").gsub(".rb", "").to_sym # the _action is optional
       end

data/fastlane/lib/fastlane/server/socket_server_action_command_executor.rb

@@ -83,7 +83,7 @@ module Fastlane
 
       case command.method_name
       when "sh"
-        error_callback = proc { |string_value| closure_argument_value = string_value }
+        error_callback = proc { |string_value| closure_argument_value = string_value } if parameter_map[:error_callback]
         command_param = parameter_map[:command]
         log_param = parameter_map[:log]
         action_return = Fastlane::FastFile.sh(command_param, log: log_param, error_callback: error_callback)

data/fastlane/lib/fastlane/version.rb

@@ -1,5 +1,5 @@
 module Fastlane
-  VERSION = '2.141.0'.freeze
+  VERSION = '2.142.0'.freeze
   DESCRIPTION = "The easiest way to automate beta deployments and releases for your iOS and Android apps".freeze
   MINIMUM_XCODE_RELEASE = "7.0".freeze
   RUBOCOP_REQUIREMENT = '0.49.1'.freeze

data/fastlane/swift/Deliverfile.swift

@@ -18,4 +18,4 @@ class Deliverfile: DeliverfileProtocol {
 
 
 
-// Generated with fastlane 2.141.0
+// Generated with fastlane 2.142.0

data/fastlane/swift/Fastlane.swift

@@ -2832,7 +2832,7 @@ func ensureEnvVars(envVars: [String]) {
 /**
  Raises an exception if not on a specific git branch
 
- - parameter branch: The branch that should be checked for. String that can be either the full name of the branch or a regex to match
+ - parameter branch: The branch that should be checked for. String that can be either the full name of the branch or a regex e.g. `^feature/.*$` to match
 
  This action will check if your git repo is checked out to a specific branch.
  You may only want to make releases from a specific branch, so `ensure_git_branch` will stop a lane if it was accidentally executed on an incorrect branch.
@@ -2892,14 +2892,19 @@ func ensureNoDebugCode(text: String,
 /**
  Ensure the right version of Xcode is used
 
- - parameter version: Xcode version to verify that is selected
+ - parameters:
+   - version: Xcode version to verify that is selected
+   - strict: Should the version be verified strictly (all 3 version numbers), or matching only the given version numbers (i.e. `11.3` == `11.3.x`)
 
  If building your app requires a specific version of Xcode, you can invoke this command before using gym.
  For example, to ensure that a beta version of Xcode is not accidentally selected to build, which would make uploading to TestFlight fail.
  You can either manually provide a specific version using `version: ` or you make use of the `.xcode-version` file.
+ Using the `strict` parameter, you can either verify the full set of version numbers strictly (i.e. `11.3.1`) or only a subset of them (i.e. `11.3` or `11`).
 */
-func ensureXcodeVersion(version: String? = nil) {
-  let command = RubyCommand(commandID: "", methodName: "ensure_xcode_version", className: nil, args: [RubyCommand.Argument(name: "version", value: version)])
+func ensureXcodeVersion(version: String? = nil,
+                        strict: Bool = true) {
+  let command = RubyCommand(commandID: "", methodName: "ensure_xcode_version", className: nil, args: [RubyCommand.Argument(name: "version", value: version),
+                                                                                                      RubyCommand.Argument(name: "strict", value: strict)])
   _ = runner.executeCommand(command)
 }
 
@@ -4612,6 +4617,35 @@ func nexusUpload(file: String,
   _ = runner.executeCommand(command)
 }
 
+/**
+ Notarizes a macOS app
+
+ - parameters:
+   - package: Path to package to notarize, e.g. .app bundle or disk image
+   - tryEarlyStapling: Whether to try early stapling while the notarization request is in progress
+   - bundleId: Bundle identifier to uniquely identify the package
+   - username: Apple ID username
+   - ascProvider: Provider short name for accounts associated with multiple providers
+   - printLog: Whether to print notarization log file, listing issues on failure and warnings on success
+   - verbose: Whether to log requests
+*/
+func notarize(package: String,
+              tryEarlyStapling: Bool = false,
+              bundleId: String? = nil,
+              username: String,
+              ascProvider: String? = nil,
+              printLog: Bool = false,
+              verbose: Bool = false) {
+  let command = RubyCommand(commandID: "", methodName: "notarize", className: nil, args: [RubyCommand.Argument(name: "package", value: package),
+                                                                                          RubyCommand.Argument(name: "try_early_stapling", value: tryEarlyStapling),
+                                                                                          RubyCommand.Argument(name: "bundle_id", value: bundleId),
+                                                                                          RubyCommand.Argument(name: "username", value: username),
+                                                                                          RubyCommand.Argument(name: "asc_provider", value: ascProvider),
+                                                                                          RubyCommand.Argument(name: "print_log", value: printLog),
+                                                                                          RubyCommand.Argument(name: "verbose", value: verbose)])
+  _ = runner.executeCommand(command)
+}
+
 /**
  Display a macOS notification with custom message and title
 
@@ -5584,6 +5618,7 @@ func rubyVersion() {
    - shouldZipBuildProducts: Should zip the derived data build products and place in output path?
    - resultBundle: Should an Xcode result bundle be generated in the output directory
    - useClangReportName: Generate the json compilation database with clang naming convention (compile_commands.json)
+   - concurrentWorkers: Specify the exact number of test runners that will be spawned during parallel testing. Equivalent to -parallel-testing-worker-count
    - maxConcurrentSimulators: Constrain the number of simulator devices on which to test concurrently. Equivalent to -maximum-concurrent-test-simulator-destinations
    - disableConcurrentTesting: Do not run test bundles in parallel on the specified destinations. Testing will occur on each destination serially. Equivalent to -disable-concurrent-testing
    - skipBuild: Should debug build be skipped before test build?
@@ -5645,6 +5680,7 @@ func runTests(workspace: String? = nil,
               shouldZipBuildProducts: Bool = false,
               resultBundle: Bool = false,
               useClangReportName: Bool = false,
+              concurrentWorkers: Int? = nil,
               maxConcurrentSimulators: Int? = nil,
               disableConcurrentTesting: Bool = false,
               skipBuild: Bool = false,
@@ -5703,6 +5739,7 @@ func runTests(workspace: String? = nil,
                                                                                            RubyCommand.Argument(name: "should_zip_build_products", value: shouldZipBuildProducts),
                                                                                            RubyCommand.Argument(name: "result_bundle", value: resultBundle),
                                                                                            RubyCommand.Argument(name: "use_clang_report_name", value: useClangReportName),
+                                                                                           RubyCommand.Argument(name: "concurrent_workers", value: concurrentWorkers),
                                                                                            RubyCommand.Argument(name: "max_concurrent_simulators", value: maxConcurrentSimulators),
                                                                                            RubyCommand.Argument(name: "disable_concurrent_testing", value: disableConcurrentTesting),
                                                                                            RubyCommand.Argument(name: "skip_build", value: skipBuild),
@@ -5842,6 +5879,7 @@ func say(text: Any,
    - shouldZipBuildProducts: Should zip the derived data build products and place in output path?
    - resultBundle: Should an Xcode result bundle be generated in the output directory
    - useClangReportName: Generate the json compilation database with clang naming convention (compile_commands.json)
+   - concurrentWorkers: Specify the exact number of test runners that will be spawned during parallel testing. Equivalent to -parallel-testing-worker-count
    - maxConcurrentSimulators: Constrain the number of simulator devices on which to test concurrently. Equivalent to -maximum-concurrent-test-simulator-destinations
    - disableConcurrentTesting: Do not run test bundles in parallel on the specified destinations. Testing will occur on each destination serially. Equivalent to -disable-concurrent-testing
    - skipBuild: Should debug build be skipped before test build?
@@ -5903,6 +5941,7 @@ func scan(workspace: Any? = scanfile.workspace,
           shouldZipBuildProducts: Bool = scanfile.shouldZipBuildProducts,
           resultBundle: Bool = scanfile.resultBundle,
           useClangReportName: Bool = scanfile.useClangReportName,
+          concurrentWorkers: Int? = scanfile.concurrentWorkers,
           maxConcurrentSimulators: Int? = scanfile.maxConcurrentSimulators,
           disableConcurrentTesting: Bool = scanfile.disableConcurrentTesting,
           skipBuild: Bool = scanfile.skipBuild,
@@ -5961,6 +6000,7 @@ func scan(workspace: Any? = scanfile.workspace,
                                                                                       RubyCommand.Argument(name: "should_zip_build_products", value: shouldZipBuildProducts),
                                                                                       RubyCommand.Argument(name: "result_bundle", value: resultBundle),
                                                                                       RubyCommand.Argument(name: "use_clang_report_name", value: useClangReportName),
+                                                                                      RubyCommand.Argument(name: "concurrent_workers", value: concurrentWorkers),
                                                                                       RubyCommand.Argument(name: "max_concurrent_simulators", value: maxConcurrentSimulators),
                                                                                       RubyCommand.Argument(name: "disable_concurrent_testing", value: disableConcurrentTesting),
                                                                                       RubyCommand.Argument(name: "skip_build", value: skipBuild),
@@ -6863,6 +6903,7 @@ func splunkmint(dsym: String? = nil,
    - xcconfig: Use xcconfig file to override swift package generate-xcodeproj defaults
    - configuration: Build with configuration (debug|release) [default: debug]
    - xcprettyOutput: Specifies the output type for xcpretty. eg. 'test', or 'simple'
+   - xcprettyArgs: Pass in xcpretty additional command line arguments (e.g. '--test --no-color' or '--tap --no-utf'), requires xcpretty_output to be specified also
    - verbose: Increase verbosity of informational output
 */
 func spm(command: String = "build",
@@ -6871,6 +6912,7 @@ func spm(command: String = "build",
          xcconfig: String? = nil,
          configuration: String? = nil,
          xcprettyOutput: String? = nil,
+         xcprettyArgs: String? = nil,
          verbose: Bool = false) {
   let command = RubyCommand(commandID: "", methodName: "spm", className: nil, args: [RubyCommand.Argument(name: "command", value: command),
                                                                                      RubyCommand.Argument(name: "build_path", value: buildPath),
@@ -6878,6 +6920,7 @@ func spm(command: String = "build",
                                                                                      RubyCommand.Argument(name: "xcconfig", value: xcconfig),
                                                                                      RubyCommand.Argument(name: "configuration", value: configuration),
                                                                                      RubyCommand.Argument(name: "xcpretty_output", value: xcprettyOutput),
+                                                                                     RubyCommand.Argument(name: "xcpretty_args", value: xcprettyArgs),
                                                                                      RubyCommand.Argument(name: "verbose", value: verbose)])
   _ = runner.executeCommand(command)
 }
@@ -7033,7 +7076,8 @@ func supply(packageName: String,
    - strict: Fail on warnings? (true/false)
    - files: List of files to process
    - ignoreExitStatus: Ignore the exit status of the SwiftLint command, so that serious violations                                                     don't fail the build (true/false)
-   - reporter: Choose output reporter
+   - raiseIfSwiftlintError: Raises an error if swiftlint fails, so you can fail CI/CD jobs if necessary                                                     (true/false)
+   - reporter: Choose output reporter. Available: xcode, json, csv, checkstyle, junit, html,                                                      emoji, sonarqube, markdown, github-actions-logging
    - quiet: Don't print status logs like 'Linting <file>' & 'Done linting'
    - executable: Path to the `swiftlint` executable on your machine
    - format: Format code when mode is :autocorrect
@@ -7046,6 +7090,7 @@ func swiftlint(mode: Any = "lint",
                strict: Bool = false,
                files: Any? = nil,
                ignoreExitStatus: Bool = false,
+               raiseIfSwiftlintError: Bool = false,
                reporter: String? = nil,
                quiet: Bool = false,
                executable: String? = nil,
@@ -7058,6 +7103,7 @@ func swiftlint(mode: Any = "lint",
                                                                                            RubyCommand.Argument(name: "strict", value: strict),
                                                                                            RubyCommand.Argument(name: "files", value: files),
                                                                                            RubyCommand.Argument(name: "ignore_exit_status", value: ignoreExitStatus),
+                                                                                           RubyCommand.Argument(name: "raise_if_swiftlint_error", value: raiseIfSwiftlintError),
                                                                                            RubyCommand.Argument(name: "reporter", value: reporter),
                                                                                            RubyCommand.Argument(name: "quiet", value: quiet),
                                                                                            RubyCommand.Argument(name: "executable", value: executable),
@@ -7690,6 +7736,7 @@ func updateUrlSchemes(path: String,
    - dsymPaths: Paths to the DSYM files or zips to upload
    - apiToken: Crashlytics API Key
    - gspPath: Path to GoogleService-Info.plist
+   - appId: Firebase Crashlytics APP ID
    - binaryPath: The path to the upload-symbols file of the Fabric app
    - platform: The platform of the app (ios, appletvos, mac)
    - dsymWorkerThreads: The number of threads to use for simultaneous dSYM upload
@@ -7700,6 +7747,7 @@ func uploadSymbolsToCrashlytics(dsymPath: String = "./spec/fixtures/dSYM/Themoji
                                 dsymPaths: [String]? = nil,
                                 apiToken: String? = nil,
                                 gspPath: String? = nil,
+                                appId: String? = nil,
                                 binaryPath: String? = nil,
                                 platform: String = "ios",
                                 dsymWorkerThreads: Int = 1) {
@@ -7707,6 +7755,7 @@ func uploadSymbolsToCrashlytics(dsymPath: String = "./spec/fixtures/dSYM/Themoji
                                                                                                                RubyCommand.Argument(name: "dsym_paths", value: dsymPaths),
                                                                                                                RubyCommand.Argument(name: "api_token", value: apiToken),
                                                                                                                RubyCommand.Argument(name: "gsp_path", value: gspPath),
+                                                                                                               RubyCommand.Argument(name: "app_id", value: appId),
                                                                                                                RubyCommand.Argument(name: "binary_path", value: binaryPath),
                                                                                                                RubyCommand.Argument(name: "platform", value: platform),
                                                                                                                RubyCommand.Argument(name: "dsym_worker_threads", value: dsymWorkerThreads)])
@@ -8632,4 +8681,4 @@ let snapshotfile: Snapshotfile = Snapshotfile()
 
 // Please don't remove the lines below
 // They are used to detect outdated files
-// FastlaneRunnerAPIVersion [0.9.69]
+// FastlaneRunnerAPIVersion [0.9.70]