fastlane 2.189.0 → 2.193.0

data/fastlane/lib/assets/completions/completion.bash

@@ -4,6 +4,7 @@ _fastlane_complete() {
   COMPREPLY=()
   local word="${COMP_WORDS[COMP_CWORD]}"
   local completions=""
+  local file
 
   # look for Fastfile either in this directory or fastlane/ then grab the lane names
   if [[ -e "Fastfile" ]]; then
@@ -12,10 +13,12 @@ _fastlane_complete() {
     file="fastlane/Fastfile"
   elif [[ -e ".fastlane/Fastfile" ]]; then
     file=".fastlane/Fastfile"
+  else
+    return 1
   fi
 
   # parse 'beta' out of 'lane :beta do', etc
-  completions=$(grep "^\s*lane \:" $file | awk -F ':' '{print $2}' | awk -F ' ' '{print $1}')
+  completions="$(sed -En 's/^[ 	]*lane +:([^ 	]+).*$/\1/p' "$file")"
   completions="$completions update_fastlane"
 
   COMPREPLY=( $(compgen -W "$completions" -- "$word") )

data/fastlane/lib/assets/completions/completion.zsh

@@ -1,7 +1,7 @@
 #!/bin/zsh
 
 _fastlane_complete() {
-  local word completions
+  local word completions file
   word="$1"
 
   # look for Fastfile either in this directory or fastlane/ then grab the lane names
@@ -11,13 +11,14 @@ _fastlane_complete() {
     file="fastlane/Fastfile"
   elif [[ -e ".fastlane/Fastfile" ]] then
     file=".fastlane/Fastfile"
+  else
+    return 1
   fi
 
   # parse 'beta' out of 'lane :beta do', etc
-  completions=`cat $file | grep "^\s*lane \:" | awk -F ':' '{print $2}' | awk -F ' ' '{print $1}'`
-  completions="$completions
-update_fastlane"
+  completions="$(sed -En 's/^[ 	]*lane +:([^ 	]+).*$/\1/p' "$file")"
+  completions="$completions update_fastlane"
 
-  reply=( "${(ps:\n:)completions}" )
+  reply=( "${=completions}" )
 }
 

data/fastlane/lib/fastlane/actions/app_store_connect_api_key.rb

@@ -80,7 +80,7 @@ module Fastlane
                                        env_name: "APP_STORE_CONNECT_API_KEY_DURATION",
                                        description: "The token session duration",
                                        optional: true,
-                                       default_value: Spaceship::ConnectAPI::Token::MAX_TOKEN_DURATION,
+                                       default_value: Spaceship::ConnectAPI::Token::DEFAULT_TOKEN_DURATION,
                                        type: Integer,
                                        verify_block: proc do |value|
                                          UI.user_error!("The duration can't be more than 1200 (20 minutes) and the value entered was '#{value}'") unless value <= 1200

data/fastlane/lib/fastlane/actions/bundle_install.rb

@@ -24,6 +24,8 @@ module Fastlane
           cmd << "--trust-policy" if params[:trust_policy]
           cmd << "--without #{params[:without]}" if params[:without]
           cmd << "--with #{params[:with]}" if params[:with]
+          cmd << "--frozen" if params[:frozen]
+          cmd << "--redownload" if params[:redownload]
 
           return sh(cmd.join(' '))
         else
@@ -146,7 +148,17 @@ module Fastlane
           FastlaneCore::ConfigItem.new(key: :with,
                                        env_name: "FL_BUNDLE_INSTALL_WITH",
                                        description: "Include gems that are part of the specified named group",
-                                       optional: true)
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :frozen,
+                                       env_name: "FL_BUNDLE_INSTALL_FROZEN",
+                                       description: "Don't allow the Gemfile.lock to be updated after install",
+                                       type: Boolean,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :redownload,
+                                       env_name: "FL_BUNDLE_INSTALL_REDOWNLOAD",
+                                       description: "Force download every gem, even if the required versions are already available locally",
+                                       type: Boolean,
+                                       default_value: false)
         ]
       end
     end

data/fastlane/lib/fastlane/actions/clean_cocoapods_cache.rb

@@ -7,6 +7,10 @@ module Fastlane
         cmd = ['pod cache clean']
 
         cmd << params[:name].to_s if params[:name]
+        cmd << '--no-ansi' if params[:no_ansi]
+        cmd << '--verbose' if params[:verbose]
+        cmd << '--silent' if params[:silent]
+        cmd << '--allow-root' if params[:allow_root]
         cmd << '--all'
 
         Actions.sh(cmd.join(' '))
@@ -24,7 +28,27 @@ module Fastlane
                                        optional: true,
                                        verify_block: proc do |value|
                                          UI.user_error!("You must specify pod name which should be removed from cache") if value.to_s.empty?
-                                       end)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :no_ansi,
+                                       env_name: "FL_CLEAN_COCOAPODS_CACHE_NO_ANSI",
+                                       description: "Show output without ANSI codes",
+                                       type: Boolean,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :verbose,
+                                       env_name: "FL_CLEAN_COCOAPODS_CACHE_VERBOSE",
+                                       description: "Show more debugging information",
+                                       type: Boolean,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :silent,
+                                       env_name: "FL_CLEAN_COCOAPODS_CACHE_SILENT",
+                                       description: "Show nothing",
+                                       type: Boolean,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :allow_root,
+                                       env_name: "FL_CLEAN_COCOAPODS_CACHE_ALLOW_ROOT",
+                                       description: "Allows CocoaPods to run as root",
+                                       type: Boolean,
+                                       default_value: false)
         ]
       end
 

data/fastlane/lib/fastlane/actions/create_xcframework.rb

@@ -5,12 +5,19 @@ module Fastlane
     end
 
     class CreateXcframeworkAction < Action
+      PARAMETERS_TO_OPTIONS = { headers: '-headers', dsyms: '-debug-symbols' }
+
       def self.run(params)
-        UI.user_error!("Please provide either :frameworks or :libraries to be packaged into the xcframework") unless params[:frameworks] || params[:libraries]
+        artifacts = normalized_artifact_info(params[:frameworks], [:dsyms]) ||
+                    normalized_artifact_info(params[:frameworks_with_dsyms], [:dsyms]) ||
+                    normalized_artifact_info(params[:libraries], [:headers, :dsyms]) ||
+                    normalized_artifact_info(params[:libraries_with_headers_or_dsyms], [:headers, :dsyms])
+
+        UI.user_error!("Please provide either :frameworks, :frameworks_with_dsyms, :libraries or :libraries_with_headers_or_dsyms to be packaged into the xcframework") unless artifacts
 
+        artifacts_type = params[:frameworks] || params[:frameworks_with_dsyms] ? '-framework' : '-library'
         create_command = ['xcodebuild', '-create-xcframework']
-        create_command << params[:frameworks].map { |framework| ['-framework', "\"#{framework}\""] }.flatten if params[:frameworks]
-        create_command << params[:libraries].map { |library, headers| ['-library', "\"#{library}\""] + (headers.empty? ? [] : ['-headers', "\"#{headers}\""]) } if params[:libraries]
+        create_command << artifacts.map { |artifact, artifact_info| [artifacts_type, "\"#{artifact}\""] + artifact_info_as_options(artifact_info) }.flatten
         create_command << ['-output', "\"#{params[:output]}\""]
         create_command << ['-allow-internal-distribution'] if params[:allow_internal_distribution]
 
@@ -24,6 +31,32 @@ module Fastlane
         sh(create_command)
       end
 
+      def self.normalized_artifact_info(artifacts_with_info, valid_info)
+        case artifacts_with_info
+        when Array
+          artifacts_with_info.map { |artifact| [artifact, {}] }.to_h
+        when Hash
+          # Convert keys of artifact info to symbols ('dsyms' to :dsyms) and only keep keys we are interested in
+          # For example with valid_info = [:dsyms]
+          #  { 'FrameworkA.framework' => { 'dsyms' => 'FrameworkA.framework.dSYM', 'foo' => bar } }
+          # gets converted to
+          #  { 'FrameworkA.framework' => { dsyms: 'FrameworkA.framework.dSYM' } }
+          artifacts_with_info.transform_values { |artifact_info| artifact_info.transform_keys(&:to_sym).slice(*valid_info) }
+        else
+          artifacts_with_info
+        end
+      end
+
+      def self.artifact_info_as_options(artifact_info)
+        artifact_info.map { |type, file| [PARAMETERS_TO_OPTIONS[type], "\"#{file}\""] }.flatten
+      end
+
+      def self.check_artifact_info(artifact_info)
+        UI.user_error!("Headers and dSYMs information should be a hash") unless artifact_info.kind_of?(Hash)
+        UI.user_error!("#{artifact_info[:headers]} doesn't exist or is not a directory") if artifact_info[:headers] && !File.directory?(artifact_info[:headers])
+        UI.user_error!("#{artifact_info[:dsyms]} doesn't seem to be a dSYM archive") if artifact_info[:dsyms] && !File.directory?(artifact_info[:dsyms])
+      end
+
       #####################################################
       # @!group Documentation
       #####################################################
@@ -37,13 +70,31 @@ module Fastlane
           Utility for packaging multiple build configurations of a given library
           or framework into a single xcframework.
 
-          If you want to package several frameworks just provide an array containing
-          the list of frameworks to be packaged using the :frameworks parameter.
+          If you want to package several frameworks just provide one of:
+
+            * An array containing the list of frameworks using the :frameworks parameter
+              (if they have no associated dSYMs):
+                ['FrameworkA.framework', 'FrameworkB.framework']
+
+            * A hash containing the list of frameworks with their dSYMs using the
+              :frameworks_with_dsyms parameter:
+                {
+                  'FrameworkA.framework' => {},
+                  'FrameworkB.framework' => { dsyms: 'FrameworkB.framework.dSYM' }
+                }
 
-          If you want to package several libraries with their corresponding headers
-          provide a hash containing the library as the key and the directory containing
-          its headers as the value (or an empty string if there are no headers associated
-          with the provided library).
+          If you want to package several libraries just provide one of:
+
+            * An array containing the list of libraries using the :libraries parameter
+              (if they have no associated headers or dSYMs):
+                ['LibraryA.so', 'LibraryB.so']
+
+            * A hash containing the list of libraries with their headers and dSYMs
+              using the :libraries_with_headers_or_dsyms parameter:
+                {
+                  'LibraryA.so' => { dsyms: 'libraryA.so.dSYM' },
+                  'LibraryB.so' => { headers: 'headers' }
+                }
 
           Finally specify the location of the xcframework to be generated using the :output
           parameter.
@@ -54,27 +105,54 @@ module Fastlane
         [
           FastlaneCore::ConfigItem.new(key: :frameworks,
                                        env_name: "FL_CREATE_XCFRAMEWORK_FRAMEWORKS",
-                                       description: "Frameworks to add to the target xcframework",
+                                       description: "Frameworks (without dSYMs) to add to the target xcframework",
                                        type: Array,
                                        optional: true,
-                                       conflicting_options: [:libraries],
+                                       conflicting_options: [:frameworks_with_dsyms, :libraries, :libraries_with_headers_or_dsyms],
                                        verify_block: proc do |value|
-                                         value.each do |framework|
+                                         normalized_artifact_info(value, [:dsyms]).each do |framework, framework_info|
                                            UI.user_error!("#{framework} doesn't end with '.framework'. Is this really a framework?") unless framework.end_with?('.framework')
                                            UI.user_error!("Couldn't find framework at #{framework}") unless File.exist?(framework)
                                            UI.user_error!("#{framework} doesn't seem to be a framework") unless File.directory?(framework)
+                                           check_artifact_info(framework_info)
+                                         end
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :frameworks_with_dsyms,
+                                       env_name: "FL_CREATE_XCFRAMEWORK_FRAMEWORKS_WITH_DSYMS",
+                                       description: "Frameworks (with dSYMs) to add to the target xcframework",
+                                       type: Hash,
+                                       optional: true,
+                                       conflicting_options: [:frameworks, :libraries, :libraries_with_headers_or_dsyms],
+                                       verify_block: proc do |value|
+                                         normalized_artifact_info(value, [:dsyms]).each do |framework, framework_info|
+                                           UI.user_error!("#{framework} doesn't end with '.framework'. Is this really a framework?") unless framework.end_with?('.framework')
+                                           UI.user_error!("Couldn't find framework at #{framework}") unless File.exist?(framework)
+                                           UI.user_error!("#{framework} doesn't seem to be a framework") unless File.directory?(framework)
+                                           check_artifact_info(framework_info)
                                          end
                                        end),
           FastlaneCore::ConfigItem.new(key: :libraries,
                                        env_name: "FL_CREATE_XCFRAMEWORK_LIBRARIES",
-                                       description: "Libraries to add to the target xcframework, with their corresponding headers",
+                                       description: "Libraries (without headers or dSYMs) to add to the target xcframework",
+                                       type: Array,
+                                       optional: true,
+                                       conflicting_options: [:frameworks, :frameworks_with_dsyms, :libraries_with_headers_or_dsyms],
+                                       verify_block: proc do |value|
+                                         normalized_artifact_info(value, [:headers, :dsyms]).each do |library, library_info|
+                                           UI.user_error!("Couldn't find library at #{library}") unless File.exist?(library)
+                                           check_artifact_info(library_info)
+                                         end
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :libraries_with_headers_or_dsyms,
+                                       env_name: "FL_CREATE_XCFRAMEWORK_LIBRARIES_WITH_HEADERS_OR_DSYMS",
+                                       description: "Libraries (with headers or dSYMs) to add to the target xcframework",
                                        type: Hash,
                                        optional: true,
-                                       conflicting_options: [:frameworks],
+                                       conflicting_options: [:frameworks, :frameworks_with_dsyms, :libraries],
                                        verify_block: proc do |value|
-                                         value.each do |library, headers|
+                                         normalized_artifact_info(value, [:headers, :dsyms]).each do |library, library_info|
                                            UI.user_error!("Couldn't find library at #{library}") unless File.exist?(library)
-                                           UI.user_error!("#{headers} doesn't exist or is not a directory") unless headers.empty? || File.directory?(headers)
+                                           check_artifact_info(library_info)
                                          end
                                        end),
           FastlaneCore::ConfigItem.new(key: :output,
@@ -103,7 +181,9 @@ module Fastlane
       def self.example_code
         [
           "create_xcframework(frameworks: ['FrameworkA.framework', 'FrameworkB.framework'], output: 'UniversalFramework.xcframework')",
-          "create_xcframework(libraries: { 'LibraryA.so' => '', 'LibraryB.so' => 'LibraryBHeaders'}, output: 'UniversalFramework.xcframework')"
+          "create_xcframework(frameworks_with_dsyms: {'FrameworkA.framework' => {}, 'FrameworkB.framework' => { dsyms: 'FrameworkB.framework.dSYM' } }, output: 'UniversalFramework.xcframework')",
+          "create_xcframework(libraries: ['LibraryA.so', 'LibraryB.so'], output: 'UniversalFramework.xcframework')",
+          "create_xcframework(libraries_with_headers_or_dsyms: { 'LibraryA.so' => { dsyms: 'libraryA.so.dSYM' }, 'LibraryB.so' => { headers: 'LibraryBHeaders' } }, output: 'UniversalFramework.xcframework')"
         ]
       end
 

data/fastlane/lib/fastlane/actions/docs/capture_android_screenshots.md

@@ -247,7 +247,7 @@ new CleanStatusBar()
 
 # Advanced _screengrab_
 
-<details>
+<details markdown="1">
 <summary>Launch Arguments</summary>
 
 You can provide additional arguments to your test cases on launch. These strings will be available in your tests through `InstrumentationRegistry.getArguments()`.
@@ -277,7 +277,7 @@ if (extras != null) {
 ```
 </details>
 
-<details>
+<details markdown="1">
 <summary>Detecting screengrab at runtime</summary>
 
 For some apps, it is helpful to know when _screengrab_ is running so that you can display specific data for your screenshots. For iOS fastlane users, this is much like "FASTLANE_SNAPSHOT". In order to do this, you'll need to have at least two product flavors of your app.

data/fastlane/lib/fastlane/actions/docs/upload_to_app_store.md.erb

@@ -104,7 +104,7 @@ deliver(
 
 ## More options
 
-<details>
+<details markdown="1">
 <summary>View all available options and their valid values</summary>
 
 ## Available options
@@ -497,7 +497,7 @@ Key | Editable While Live | Directory | Filename | Deprecated Filename
 
 ## Reference
 
-<details>
+<details markdown="1">
 <summary>View all available categories, etc.</summary>
 
 ### Available Categories

data/fastlane/lib/fastlane/actions/get_provisioning_profile.rb

@@ -64,7 +64,7 @@ module Fastlane
           ['SIGH_PROFILE_PATHS', 'Paths in which certificates, key and profile are exported'],
           ['SIGH_UUID', 'UUID (Universally Unique IDentifier) of a provisioning profile'],
           ['SIGH_NAME', 'The name of the profile'],
-          ['SIGH_PROFILE_TYPE', 'The profile type, can be appstore, adhoc, development, enterprise']
+          ['SIGH_PROFILE_TYPE', 'The profile type, can be app-store, ad-hoc, development, enterprise, developer-id, can be used in `build_app` as a default value for `export_method`']
         ]
       end
 

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

@@ -10,6 +10,8 @@ module Fastlane
         verbose = params[:verbose]
         api_key_path = params[:api_key_path]
 
+        use_notarytool = params[:use_notarytool]
+
         # Compress and read bundle identifier only for .app bundle.
         compressed_package_path = nil
         if File.extname(package_path) == '.app'
@@ -30,6 +32,74 @@ module Fastlane
 
         UI.user_error!('Could not read bundle identifier, provide as a parameter') unless bundle_id
 
+        if use_notarytool
+          notarytool(params, package_path, bundle_id, try_early_stapling, print_log, verbose, api_key_path, compressed_package_path)
+        else
+          altool(params, package_path, bundle_id, try_early_stapling, print_log, verbose, api_key_path, compressed_package_path)
+        end
+      end
+
+      def self.notarytool(params, package_path, bundle_id, try_early_stapling, print_log, verbose, api_key_path, compressed_package_path)
+        temp_file = nil
+
+        # Create authorization part of command with either API Key or Apple ID
+        auth_parts = []
+        if api_key_path
+          api_key = Spaceship::ConnectAPI::Token.from_json_file(api_key_path)
+
+          # Writes key contents to temporary file for command
+          require 'tempfile'
+          temp_file = Tempfile.new
+          api_key.write_key_to_file(temp_file.path)
+
+          auth_parts << "--key #{temp_file.path}"
+          auth_parts << "--key-id #{api_key.key_id}"
+          auth_parts << "--issuer #{api_key.issuer_id}"
+        else
+          auth_parts << "--apple-id #{params[:username]}"
+          auth_parts << "--password #{ENV['FASTLANE_APPLE_APPLICATION_SPECIFIC_PASSWORD']}"
+          auth_parts << "--team-id #{params[:asc_provider]}"
+        end
+
+        # Submits package and waits for processing using `xcrun notarytool submit --wait`
+        submit_parts = [
+          "xcrun notarytool submit",
+          (compressed_package_path || package_path).shellescape,
+          "--output-format json",
+          "--wait"
+        ] + auth_parts
+
+        submit_command = submit_parts.join(' ')
+        submit_response = Actions.sh(
+          submit_command,
+          log: verbose,
+          error_callback: lambda { |msg|
+            UI.error("Error polling for notarization info: #{msg}")
+          }
+        )
+
+        notarization_info = JSON.parse(submit_response)
+
+        # Staple
+        case notarization_info['status']
+        when 'Accepted'
+          submission_id = notarization_info["id"]
+          UI.success("Successfully uploaded package to notarization service with request identifier #{submission_id}")
+
+          UI.message('Stapling package')
+          self.staple(package_path, verbose)
+
+          UI.success("Successfully notarized and stapled package")
+        when 'Invalid'
+          UI.user_error!("Could not notarize package with message '#{notarization_info['statusSummary']}'")
+        else
+          UI.crash!("Could not notarize package with status '#{notarization_info['status']}'")
+        end
+      ensure
+        temp_file.delete if temp_file
+      end
+
+      def self.altool(params, package_path, bundle_id, try_early_stapling, print_log, verbose, api_key_path, compressed_package_path)
         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} --output-format xml"
@@ -125,7 +195,7 @@ module Fastlane
 
       def self.staple(package_path, verbose)
         Actions.sh(
-          "xcrun stapler staple \"#{package_path}\"",
+          "xcrun stapler staple #{package_path.shellescape}",
           log: verbose
         )
       end
@@ -180,6 +250,12 @@ module Fastlane
                                        verify_block: proc do |value|
                                          UI.user_error!("Could not find package at '#{value}'") unless File.exist?(value)
                                        end),
+          FastlaneCore::ConfigItem.new(key: :use_notarytool,
+                                       env_name: 'FL_NOTARIZE_USE_NOTARYTOOL',
+                                       description: 'Whether to `xcrun notarytool` or `xcrun altool`',
+                                       default_value: Helper.mac? && Helper.xcode_at_least?("13.0"), # Notary tool added in Xcode 13
+                                       default_value_dynamic: true,
+                                       type: Boolean),
           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',

data/fastlane/lib/fastlane/actions/push_git_tags.rb

@@ -9,7 +9,7 @@ module Fastlane
         ]
 
         if params[:tag]
-          command << "refs/tags/#{params[:tag]}"
+          command << "refs/tags/#{params[:tag].shellescape}"
         else
           command << '--tags'
         end