fastlane 2.170.0 → 2.175.0

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

@@ -0,0 +1,118 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      XCFRAMEWORK_PATH ||= :XCFRAMEWORK_PATH
+    end
+
+    class CreateXcframeworkAction < Action
+      def self.run(params)
+        UI.user_error!("Please provide either :frameworks or :libraries to be packaged into the xcframework") unless params[:frameworks] || params[:libraries]
+
+        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 << ['-output', "\"#{params[:output]}\""]
+        create_command << ['-allow-internal-distribution'] if params[:allow_internal_distribution]
+
+        Actions.lane_context[SharedValues::XCFRAMEWORK_PATH] = params[:output]
+
+        sh(create_command)
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Package multiple build configs of a library/framework into a single xcframework"
+      end
+
+      def self.details
+        <<~DETAILS
+          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 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).
+
+          Finally specify the location of the xcframework to be generated using the :output
+          parameter.
+        DETAILS
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :frameworks,
+                                       env_name: "FL_CREATE_XCFRAMEWORK_FRAMEWORKS",
+                                       description: "Frameworks to add to the target xcframework",
+                                       type: Array,
+                                       optional: true,
+                                       conflicting_options: [:libraries],
+                                       verify_block: proc do |value|
+                                         value.each do |framework|
+                                           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)
+                                         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",
+                                       type: Hash,
+                                       optional: true,
+                                       conflicting_options: [:frameworks],
+                                       verify_block: proc do |value|
+                                         value.each do |library, headers|
+                                           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)
+                                         end
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :output,
+                                       env_name: "FL_CREATE_XCFRAMEWORK_OUTPUT",
+                                       description: "The path to write the xcframework to",
+                                       type: String,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :allow_internal_distribution,
+                                       env_name: "FL_CREATE_XCFRAMEWORK_ALLOW_INTERNAL_DISTRIBUTION",
+                                       description: "Specifies that the created xcframework contains information not suitable for public distribution",
+                                       type: Boolean,
+                                       optional: true,
+                                       default_value: false)
+        ]
+      end
+
+      def self.output
+        [
+          ['XCFRAMEWORK_PATH', 'Location of the generated xcframework']
+        ]
+      end
+
+      def self.return_value
+      end
+
+      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')"
+        ]
+      end
+
+      def self.category
+        :building
+      end
+
+      def self.authors
+        ["jgongo"]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+    end
+  end
+end

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

@@ -21,7 +21,7 @@ _screengrab_ generates localized screenshots of your Android app for different d
 Install the gem
 
 ```no-highlight
-sudo gem install fastlane
+gem install fastlane
 ```
 
 ##### Gradle dependency

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

@@ -345,5 +345,5 @@ brew install imagemagick
 
 ## Uninstall
 
-- `sudo gem uninstall fastlane`
+- `gem uninstall fastlane`
 - `rm -rf ~/.frameit`

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

@@ -99,16 +99,22 @@ If your machine is currently using SSH to authenticate with GitHub, you'll want
 Using parameter:
 
 ```
-match(git_basic_authorization: '<YOUR KEY>')
+match(git_basic_authorization: '<YOUR BASE64 KEY>')
 ```
 
 Using environment variable:
 
 ```
-ENV['MATCH_GIT_BASIC_AUTHORIZATION'] = '<YOUR KEY>'
+ENV['MATCH_GIT_BASIC_AUTHORIZATION'] = '<YOUR BASE64 KEY>'
 match
 ```
 
+To generate your base64 key [according to RFC 7617](https://tools.ietf.org/html/rfc7617), run this:
+
+```
+echo -n your_github_username:your_personal_access_token | base64
+```
+
 You can find more information about GitHub basic authentication and personal token generation here: [https://developer.github.com/v3/auth/#basic-authentication](https://developer.github.com/v3/auth/#basic-authentication)
 
 ##### Git Storage on GitHub - Deploy keys

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

@@ -218,7 +218,7 @@ fastlane pilot upload --verbose
 
 ## Firewall Issues
 
-_pilot_ uses the iTunes Transporter to upload metadata and binaries. In case you are behind a firewall, you can specify a different transporter protocol from the command line using
+_pilot_ uses the iTunes [Transporter](https://help.apple.com/itc/transporteruserguide/#/apdATD1E1288-D1E1A1303-D1E1288A1126) to upload metadata and binaries. In case you are behind a firewall, you can specify a different transporter protocol from the command line using
 
 ```no-highlight
 DELIVER_ITMSTRANSPORTER_ADDITIONAL_UPLOAD_PARAMETERS="-t DAV" pilot ...
@@ -231,6 +231,10 @@ ENV["DELIVER_ITMSTRANSPORTER_ADDITIONAL_UPLOAD_PARAMETERS"] = "-t DAV"
 pilot...
 ```
 
+Note, however, that Apple recommends you don’t specify the `-t transport` and instead allow Transporter to use automatic transport discovery to determine the best transport mode for your packages. For this reason, if the `t` option is passed, we will raise a warning.
+
+Also note that `-t` is not the only additional parameter that can be used. The string specified in the `DELIVER_ITMSTRANSPORTER_ADDITIONAL_UPLOAD_PARAMETERS` environment variable will be forwarded to Transporter. For all the available options, check [Apple's Transporter User Guide](https://help.apple.com/itc/transporteruserguide/#/apdATD1E1288-D1E1A1303-D1E1288A1126).
+
 ## Credentials Issues
 
 If your password contains special characters, _pilot_ may throw a confusing error saying your "Your Apple ID or password was entered incorrectly". The easiest way to fix this error is to change your password to something that **does not** contains special characters.

data/fastlane/lib/fastlane/actions/download_app_privacy_details_from_app_store.rb

@@ -0,0 +1,142 @@
+module Fastlane
+  module Actions
+    class DownloadAppPrivacyDetailsFromAppStoreAction < Action
+      DEFAULT_PATH = Fastlane::Helper.fastlane_enabled_folder_path
+      DEFAULT_FILE_NAME = "app_privacy_details.json"
+
+      def self.run(params)
+        require 'spaceship'
+
+        # Prompts select team if multiple teams and none specified
+        UI.message("Login to App Store Connect (#{params[:username]})")
+        Spaceship::ConnectAPI.login(params[:username], use_portal: false, use_tunes: true, tunes_team_id: params[:team_id], team_name: params[:team_name])
+        UI.message("Login successful")
+
+        # Get App
+        app = Spaceship::ConnectAPI::App.find(params[:app_identifier])
+        unless app
+          UI.user_error!("Could not find app with bundle identifier '#{params[:app_identifier]}' on account #{params[:username]}")
+        end
+
+        # Download usages and return a config
+        raw_usages = download_app_data_usages(params, app)
+
+        usages_config = []
+        if raw_usages.count == 1 && raw_usages.first.data_protection.id == Spaceship::ConnectAPI::AppDataUsageDataProtection::ID::DATA_NOT_COLLECTED
+          usages_config << {
+            "data_protections" => [Spaceship::ConnectAPI::AppDataUsageDataProtection::ID::DATA_NOT_COLLECTED]
+          }
+        else
+          grouped_usages = raw_usages.group_by do |usage|
+            usage.category.id
+          end
+          grouped_usages.sort_by(&:first).each do |key, usage_group|
+            purposes = usage_group.map(&:purpose).compact || []
+            data_protections = usage_group.map(&:data_protection).compact || []
+            usages_config << {
+              "category" => key,
+              "purposes" => purposes.map(&:id).sort.uniq,
+              "data_protections" => data_protections.map(&:id).sort.uniq
+            }
+          end
+        end
+
+        # Save to JSON file
+        json = JSON.pretty_generate(usages_config)
+        path = output_path(params)
+
+        UI.message("Writing file to #{path}")
+        File.write(path, json)
+      end
+
+      def self.output_path(params)
+        path = params[:output_json_path]
+        return File.absolute_path(path)
+      end
+
+      def self.download_app_data_usages(params, app)
+        UI.message("Downloading App Data Usage")
+
+        # Delete all existing usages for new ones
+        Spaceship::ConnectAPI::AppDataUsage.all(app_id: app.id, includes: "category,grouping,purpose,dataProtection", limit: 500)
+      end
+
+      def self.description
+        "Download App Privacy Details from an app in App Store Connect"
+      end
+
+      def self.available_options
+        user = CredentialsManager::AppfileConfig.try_fetch_value(:itunes_connect_id)
+        user ||= CredentialsManager::AppfileConfig.try_fetch_value(:apple_id)
+
+        [
+          FastlaneCore::ConfigItem.new(key: :username,
+                                       env_name: "FASTLANE_USER",
+                                       description: "Your Apple ID Username for App Store Connect",
+                                       default_value: user,
+                                       default_value_dynamic: true),
+          FastlaneCore::ConfigItem.new(key: :app_identifier,
+                                       env_name: "UPLOAD_APP_PRIVACY_DETAILS_TO_APP_STORE_APP_IDENTIFIER",
+                                       description: "The bundle identifier of your app",
+                                       code_gen_sensitive: true,
+                                       default_value: CredentialsManager::AppfileConfig.try_fetch_value(:app_identifier),
+                                       default_value_dynamic: true),
+          FastlaneCore::ConfigItem.new(key: :team_id,
+                                       env_name: "FASTLANE_ITC_TEAM_ID",
+                                       description: "The ID of your App Store Connect team if you're in multiple teams",
+                                       optional: true,
+                                       is_string: false, # as we also allow integers, which we convert to strings anyway
+                                       code_gen_sensitive: true,
+                                       default_value: CredentialsManager::AppfileConfig.try_fetch_value(:itc_team_id),
+                                       default_value_dynamic: true),
+          FastlaneCore::ConfigItem.new(key: :team_name,
+                                       env_name: "FASTLANE_ITC_TEAM_NAME",
+                                       description: "The name of your App Store Connect team if you're in multiple teams",
+                                       optional: true,
+                                       code_gen_sensitive: true,
+                                       default_value: CredentialsManager::AppfileConfig.try_fetch_value(:itc_team_name),
+                                       default_value_dynamic: true),
+
+          # JSON paths
+          FastlaneCore::ConfigItem.new(key: :output_json_path,
+                                       env_name: "UPLOAD_APP_PRIVACY_DETAILS_TO_APP_STORE_OUTPUT_JSON_PATH",
+                                       description: "Path to the app usage data JSON file generated by interactive questions",
+                                       conflicting_options: [:skip_json_file_saving],
+                                       default_value: File.join(DEFAULT_PATH, DEFAULT_FILE_NAME))
+        ]
+      end
+
+      def self.author
+        "igor-makarov"
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac, :tvos].include?(platform)
+      end
+
+      def self.details
+        "Download App Privacy Details from an app in App Store Connect. For more detail information, view https://docs.fastlane.tools/uploading-app-privacy-details"
+      end
+
+      def self.example_code
+        [
+          'download_app_privacy_details_from_app_store(
+            username: "your@email.com",
+            team_name: "Your Team",
+            app_identifier: "com.your.bundle"
+          )',
+          'download_app_privacy_details_from_app_store(
+            username: "your@email.com",
+            team_name: "Your Team",
+            app_identifier: "com.your.bundle",
+            output_json_path: "fastlane/app_data_usages.json"
+          )'
+        ]
+      end
+
+      def self.category
+        :production
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/download_dsyms.rb

@@ -39,13 +39,8 @@ module Fastlane
         # Set version if it is latest
         if version == 'latest'
           # Try to grab the edit version first, else fallback to live version
-          UI.message("Looking for latest version...")
-          latest_version = app.get_edit_app_store_version(platform: platform) || app.get_live_app_store_version(platform: platform)
-
-          UI.user_error!("Could not find latest version for your app, please try setting a specific version") if latest_version.nil?
-
-          latest_build = get_latest_build!(app_id: app.id, version: latest_version.version_string, platform: platform)
-
+          UI.message("Looking for latest build...")
+          latest_build = get_latest_build!(app_id: app.id, platform: platform)
           version = latest_build.app_version
           build_number = latest_build.version
         elsif version == 'live'
@@ -59,11 +54,6 @@ module Fastlane
           build_number = live_version.build.version
         end
 
-        # Remove leading zeros from version string (eg. 1.02 -> 1.2)
-        if version
-          version = version.split(".").map(&:to_i).join(".")
-        end
-
         # Make sure output_directory has a slash on the end
         if output_directory && !output_directory.end_with?('/')
           output_directory += '/'
@@ -161,14 +151,14 @@ module Fastlane
       end
       # rubocop:enable Metrics/PerceivedComplexity
 
-      def self.get_latest_build!(app_id: nil, version: nil, platform: nil)
+      def self.get_latest_build!(app_id: nil, platform: nil)
         filter = { app: app_id }
-        filter["preReleaseVersion.version"] = version
         filter["preReleaseVersion.platform"] = platform
         latest_build = Spaceship::ConnectAPI.get_builds(filter: filter, sort: "-uploadedDate", includes: "preReleaseVersion").first
 
         if latest_build.nil?
-          UI.user_error!("Could not find latest build for version #{version}")
+          UI.user_error!("Could not find any build for platform #{platform}") if platform
+          UI.user_error!("Could not find any build")
         end
 
         return latest_build
@@ -285,7 +275,6 @@ module Fastlane
                                        short_option: "-p",
                                        env_name: "DOWNLOAD_DSYMS_PLATFORM",
                                        description: "The app platform for dSYMs you wish to download (ios, appletvos)",
-                                       optional: true,
                                        default_value: :ios),
           FastlaneCore::ConfigItem.new(key: :version,
                                        short_option: "-v",

data/fastlane/lib/fastlane/actions/git_commit.rb

@@ -11,7 +11,11 @@ module Fastlane
         skip_git_hooks = params[:skip_git_hooks] ? '--no-verify' : ''
 
         if params[:allow_nothing_to_commit]
-          repo_clean = Actions.sh("git status --porcelain").empty?
+          # Here we check if the path passed in parameter contains any modification
+          # and we skip the `git commit` command if there is none.
+          # That means you can have other files modified that are not in the path parameter
+          # and still make use of allow_nothing_to_commit.
+          repo_clean = Actions.sh("git status #{paths} --porcelain").empty?
           UI.success("Nothing to commit, working tree clean ✅.") if repo_clean
           return if repo_clean
         end
@@ -33,7 +37,7 @@ module Fastlane
       def self.available_options
         [
           FastlaneCore::ConfigItem.new(key: :path,
-                                       description: "The file you want to commit",
+                                       description: "The file(s) or directory(ies) you want to commit. You can pass an array of multiple file-paths or fileglobs \"*.txt\" to commit all matching files. The files already staged but not specified and untracked files won't be committed",
                                        is_string: false),
           FastlaneCore::ConfigItem.new(key: :message,
                                        description: "The commit message that should be used"),
@@ -42,7 +46,7 @@ module Fastlane
                                        type: Boolean,
                                        optional: true),
           FastlaneCore::ConfigItem.new(key: :allow_nothing_to_commit,
-                                       description: "Set to true to allow commit without any git changes",
+                                       description: "Set to true to allow commit without any git changes in the files you want to commit",
                                        type: Boolean,
                                        optional: true)
         ]

data/fastlane/lib/fastlane/actions/github_api.rb

@@ -13,7 +13,7 @@ module Fastlane
 
           http_method = (params[:http_method] || 'GET').to_s.upcase
           url = construct_url(params[:server_url], params[:path], params[:url])
-          headers = construct_headers(params[:api_token], params[:headers])
+          headers = construct_headers(params[:api_token], params[:api_bearer], params[:headers])
           payload = construct_body(params[:body], params[:raw_body])
           error_handlers = params[:error_handlers] || {}
           secure = params[:secure]
@@ -89,12 +89,22 @@ module Fastlane
             FastlaneCore::ConfigItem.new(key: :api_token,
                                          env_name: "FL_GITHUB_API_TOKEN",
                                          description: "Personal API Token for GitHub - generate one at https://github.com/settings/tokens",
+                                         conflicting_options: [:api_bearer],
                                          sensitive: true,
                                          code_gen_sensitive: true,
                                          is_string: true,
                                          default_value: ENV["GITHUB_API_TOKEN"],
                                          default_value_dynamic: true,
-                                         optional: false),
+                                         optional: true),
+            FastlaneCore::ConfigItem.new(key: :api_bearer,
+                                         env_name: "FL_GITHUB_API_BEARER",
+                                         sensitive: true,
+                                         code_gen_sensitive: true,
+                                         is_string: true,
+                                         description: "Use a Bearer authorization token. Usually generated by Github Apps, e.g. GitHub Actions GITHUB_TOKEN environment variable",
+                                         conflicting_options: [:api_token],
+                                         optional: true,
+                                         default_value: nil),
             FastlaneCore::ConfigItem.new(key: :http_method,
                                          env_name: "FL_GITHUB_API_HTTP_METHOD",
                                          description: "The HTTP method. e.g. GET / POST",
@@ -202,10 +212,11 @@ module Fastlane
 
         private
 
-        def construct_headers(api_token, overrides)
+        def construct_headers(api_token, api_bearer, overrides)
           require 'base64'
           headers = { 'User-Agent' => 'fastlane-github_api' }
           headers['Authorization'] = "Basic #{Base64.strict_encode64(api_token)}" if api_token
+          headers['Authorization'] = "Bearer #{api_bearer}" if api_bearer
           headers.merge(overrides || {})
         end