fastlane 2.156.1 → 2.157.4

data/fastlane/lib/fastlane/actions/app_store_build_number.rb

@@ -26,27 +26,31 @@ module Fastlane
       end
 
       def self.get_build_number(params)
+        # Prompts select team if multiple teams and none specified
         UI.message("Login to App Store Connect (#{params[:username]})")
-        Spaceship::Tunes.login(params[:username])
-        Spaceship::Tunes.select_team(team_id: params[:team_id], team_name: params[:team_name])
+        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")
 
-        app = Spaceship::Tunes::Application.find(params[:app_identifier], mac: params[:platform] == "osx")
+        platform = Spaceship::ConnectAPI::Platform.map(params[:platform])
+
+        app = Spaceship::ConnectAPI::App.find(params[:app_identifier])
         UI.user_error!("Could not find an app on App Store Connect with app_identifier: #{params[:app_identifier]}") unless app
         if params[:live]
           UI.message("Fetching the latest build number for live-version")
-          UI.user_error!("Could not find a live-version of #{params[:app_identifier]} on iTC") unless app.live_version
-          build_nr = app.live_version.current_build_number
+          live_version = app.get_live_app_store_version(platform: platform)
+
+          UI.user_error!("Could not find a live-version of #{params[:app_identifier]} on App Store Connect") unless live_version
+          build_nr = live_version.build.version
 
-          UI.message("Latest upload for live-version #{app.live_version.version} is build: #{build_nr}")
+          UI.message("Latest upload for live-version #{live_version.version_string} is build: #{build_nr}")
 
-          return OpenStruct.new({ build_nr: build_nr, build_v: app.live_version.version })
+          return OpenStruct.new({ build_nr: build_nr, build_v: live_version.version_string })
         else
           version_number = params[:version]
           platform = params[:platform]
 
           # Create filter for get_builds with optional version number
-          filter = { app: app.apple_id }
+          filter = { app: app.id }
           if version_number
             filter["preReleaseVersion.version"] = version_number
             version_number_message = "version #{version_number}"

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

@@ -0,0 +1,120 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      APP_STORE_CONNECT_API_KEY = :APP_STORE_CONNECT_API_KEY
+    end
+
+    class AppStoreConnectApiKeyAction < Action
+      def self.run(options)
+        key_id = options[:key_id]
+        issuer_id = options[:issuer_id]
+        key_content = options[:key_content]
+        key_filepath = options[:key_filepath]
+        duration = options[:duration]
+        in_house = options[:in_house]
+
+        if key_content.nil? && key_filepath.nil?
+          UI.user_error!(":key_content or :key_filepath is required")
+        end
+
+        # This hash matches the named arguments on
+        # the Spaceship::ConnectAPI::Token.create method
+        key = {
+          key_id: key_id,
+          issuer_id: issuer_id,
+          key: key_content || File.binread(key_filepath),
+          duration: duration,
+          in_house: in_house
+        }
+
+        Actions.lane_context[SharedValues::APP_STORE_CONNECT_API_KEY] = key
+
+        return key
+      end
+
+      def self.description
+        "Load the App Store Connect API token to use in other fastlane tools and actions"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :key_id,
+                                       env_name: "APP_STORE_CONNECT_API_KEY_KEY_ID",
+                                       description: "The key ID"),
+          FastlaneCore::ConfigItem.new(key: :issuer_id,
+                                       env_name: "APP_STORE_CONNECT_API_KEY_ISSUER_ID",
+                                       description: "The issuer ID"),
+          FastlaneCore::ConfigItem.new(key: :key_filepath,
+                                       env_name: "APP_STORE_CONNECT_API_KEY_KEY_FILEPATH",
+                                       description: "The path to the key p8 file",
+                                       optional: true,
+                                       conflicting_options: [:key_content],
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Couldn't find key p8 file at path '#{value}'") unless File.exist?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :key_content,
+                                       env_name: "APP_STORE_CONNECT_API_KEY_KEY",
+                                       description: "The content of the key p8 file",
+                                       optional: true,
+                                       conflicting_options: [:filepath]),
+          FastlaneCore::ConfigItem.new(key: :duration,
+                                       env_name: "APP_STORE_CONNECT_API_KEY_DURATION",
+                                       description: "The token session duration",
+                                       optional: true,
+                                       type: Integer),
+          FastlaneCore::ConfigItem.new(key: :in_house,
+                                       env_name: "APP_STORE_CONNECT_API_KEY_IN_HOUSE",
+                                       description: "Is App Store or Enterprise (in house) team? App Store Connect API cannot not determine this on its own (yet)",
+                                       optional: true,
+                                       type: Boolean)
+        ]
+      end
+
+      def self.output
+        [
+          ['APP_STORE_CONNECT_API_KEY', 'The App Store Connect API key information used for authorization requests. This hash can be passed directly into the :api_key options on other tools or into Spaceship::ConnectAPI::Token.create method']
+        ]
+      end
+
+      def self.author
+        ["joshdholtz"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.details
+        [
+          "Load the App Store Connect API token to use in other fastlane tools and actions"
+        ].join("\n")
+      end
+
+      def self.example_code
+        [
+          'app_store_connect_api_key(
+            key_id: "D83848D23",
+            issuer_id: "227b0bbf-ada8-458c-9d62-3d8022b7d07f",
+            key_filepath: "D83848D23.p8"
+          )',
+          'app_store_connect_api_key(
+            key_id: "D83848D23",
+            issuer_id: "227b0bbf-ada8-458c-9d62-3d8022b7d07f",
+            key_filepath: "D83848D23.p8",
+            duration: 200,
+            in_house: true
+          )',
+          'app_store_connect_api_key(
+            key_id: "D83848D23",
+            issuer_id: "227b0bbf-ada8-458c-9d62-3d8022b7d07f",
+            key_content: "-----BEGIN EC PRIVATE KEY-----\nfewfawefawfe\n-----END EC PRIVATE KEY-----"
+          )'
+        ]
+      end
+
+      def self.category
+        :app_store_connect
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/commit_version_bump.rb

@@ -220,7 +220,7 @@ module Fastlane
           'commit_version_bump',
           'commit_version_bump(
             message: "Version Bump",                    # create a commit with a custom message
-            xcodeproj: "./path/to/MyProject.xcodeproj", # optional, if you have multiple Xcode project files, you must specify your main project here
+            xcodeproj: "./path/to/MyProject.xcodeproj"  # optional, if you have multiple Xcode project files, you must specify your main project here
           )',
           'commit_version_bump(
             settings: true # Include Settings.bundle/Root.plist

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

@@ -49,6 +49,8 @@ The previous p12 configuration is still currently supported.
 
 ## Quick Start
 
+> Before using _supply_ to connect to Google Play Store, you'll need to set up your app manually first by uploading at least one build to Google Play Store. See [fastane/fastlane#14686](https://github.com/fastlane/fastlane/issues/14686) for more info.
+
 - `cd [your_project_folder]`
 - `fastlane supply init`
 - Make changes to the downloaded metadata, add images, screenshots and/or an APK

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

@@ -26,7 +26,23 @@ _pilot_ uses [spaceship.airforce](https://spaceship.airforce) to interact with A
 
 # Usage
 
-For all commands you can specify the Apple ID to use using `-u felix@krausefx.com`. If you execute _pilot_ in a project already using [_fastlane_](https://fastlane.tools) the username and app identifier will automatically be determined.
+For all commands, you can either use an [API Key](#app-store-connect-api-key) or your [Apple ID](#apple-id).
+
+### App Store Connect API Key
+
+The App Store Connect API Key is the preferred authentication method (if you are able to use it).
+
+- Uses offial App Store Connect API
+- No need for 2FA
+- Better performance over Apple ID
+
+Specify the API key using `--api_key_path ./path/to/api_key_info.json` or `--api_key "{\"key_id\": \"D83848D23\", \"issuer_id\": \"227b0bbf-ada8-458c-9d62-3d8022b7d07f\", \"key_filepath\": \"D83848D23.p8\"}"`
+
+Go to [Using App Store Connect API](/app-store-connect-api) for information on obtaining an API key, the _fastlane_ `api_key_info.json` format, and other API key usage.
+
+### Apple ID
+
+Specify the Apple ID to use using `-u felix@krausefx.com`. If you execute _pilot_ in a project already using [_fastlane_](https://fastlane.tools) the username and app identifier will automatically be determined.
 
 ## Uploading builds
 

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

@@ -6,16 +6,18 @@ module Fastlane
     class DownloadDsymsAction < Action
       # rubocop:disable Metrics/PerceivedComplexity
       def self.run(params)
+        require 'openssl'
         require 'spaceship'
         require 'net/http'
 
+        # Team selection passed though FASTLANE_ITC_TEAM_ID and FASTLANE_ITC_TEAM_NAME environment variables
+        # Prompts select team if multiple teams and none specified
         UI.message("Login to App Store Connect (#{params[:username]})")
-        Spaceship::Tunes.login(params[:username])
-        Spaceship::Tunes.select_team
+        Spaceship::ConnectAPI.login(params[:username], use_portal: false, use_tunes: true)
         UI.message("Login successful")
 
         # Get App
-        app = Spaceship::Application.find(params[:app_identifier])
+        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
@@ -23,38 +25,35 @@ module Fastlane
         # Process options
         version = params[:version]
         build_number = params[:build_number].to_s unless params[:build_number].nil?
-        platform = params[:platform]
+        itc_platform = params[:platform]
         output_directory = params[:output_directory]
         wait_for_dsym_processing = params[:wait_for_dsym_processing]
         wait_timeout = params[:wait_timeout]
         min_version = Gem::Version.new(params[:min_version]) if params[:min_version]
 
+        platform = Spaceship::ConnectAPI::Platform.map(itc_platform)
+
         # 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.edit_version(platform: platform) || app.live_version(platform: platform)
-
-          UI.user_error!("Could not find latest version for your app, please try setting a specific version") if latest_version.version.nil?
-
-          latest_candidate_build = latest_version.candidate_builds.max_by(&:upload_date)
-          if latest_candidate_build.nil?
-            version = latest_version.version
-            build_number = latest_version.build_version
-          else
-            # The build_version of a candidate build does not always match the one in latest_version so get the version and build number from the same place.
-            version = latest_candidate_build.train_version
-            build_number = latest_candidate_build.build_version
-          end
+          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)
+
+          version = latest_build.app_version
+          build_number = latest_build.version
         elsif version == 'live'
           UI.message("Looking for live version...")
-          live_version = app.live_version(platform: platform)
+          live_version = app.get_live_app_store_version(platform: platform)
 
           UI.user_error!("Could not find live version for your app, please try setting 'latest' or a specific version") if live_version.nil?
 
           # No need to search for candidates, because released App Store version should only have one build
-          version = live_version.version
-          build_number = live_version.build_version
+          version = live_version.version_string
+          build_number = live_version.build.version
         end
 
         # Remove leading zeros from version string (eg. 1.02 -> 1.2)
@@ -74,76 +73,98 @@ module Fastlane
         message << "(#{build_number})" if build_number
         UI.message(message.join(" "))
 
-        app.tunes_all_build_trains(platform: platform).each do |train|
+        filter = { app: app.id }
+        filter["preReleaseVersion.platform"] = platform
+        build_resps = Spaceship::ConnectAPI.get_builds(filter: filter, sort: "-uploadedDate", includes: "preReleaseVersion").all_pages
+        builds = build_resps.flat_map(&:to_models)
+
+        builds.each do |build|
+          asc_app_version = build.app_version
+          asc_build_number = build.version
+
           message = []
-          message << "Found train (version): #{train.version_string}"
+          message << "Found train (version): #{asc_app_version}"
           message << ", comparing to supplied version: #{version}" if version
           UI.verbose(message.join(" "))
 
-          if version && version != train.version_string
-            UI.verbose("Version #{version} doesn't match: #{train.version_string}")
+          if version && version != asc_app_version
+            UI.verbose("Version #{version} doesn't match: #{asc_app_version}")
             next
           end
 
-          if min_version && min_version > Gem::Version.new(train.version_string)
-            UI.verbose("Min version #{min_version} not reached: #{train.version_string}")
+          if min_version && min_version > Gem::Version.new(asc_app_version)
+            UI.verbose("Min version #{min_version} not reached: #{asc_app_version}")
             next
           end
 
-          app.tunes_all_builds_for_train(train: train.version_string, platform: platform).each do |build|
-            message = []
-            message << "Found build version: #{build.build_version}"
-            message << ", comparing to supplied build_number: #{build_number}" if build_number
-            UI.verbose(message.join(" "))
+          message = []
+          message << "Found build version: #{asc_build_number}"
+          message << ", comparing to supplied build_number: #{build_number}" if build_number
+          UI.verbose(message.join(" "))
 
-            if build_number && build.build_version != build_number
-              UI.verbose("build_version: #{build.build_version} doesn't match: #{build_number}")
-              next
-            end
+          if build_number && asc_build_number != build_number
+            UI.verbose("build_version: #{asc_build_number} doesn't match: #{build_number}")
+            next
+          end
 
-            UI.verbose("Build_version: #{build.build_version} matches #{build_number}, grabbing dsym_url") if build_number
-
-            start = Time.now
-            download_url = nil
-
-            loop do
-              begin
-                build_details = app.tunes_build_details(train: train.version_string, build_number: build.build_version, platform: platform)
-                download_url = build_details.dsym_url
-                UI.verbose("dsym_url: #{download_url}")
-              rescue Spaceship::TunesClient::ITunesConnectError => ex
-                UI.error("Error accessing dSYM file for build\n\n#{build}\n\nException: #{ex}")
-              end
-
-              unless download_url
-                if !wait_for_dsym_processing || (Time.now - start) > wait_timeout
-                  # In some cases, AppStoreConnect does not process the dSYMs, thus no error should be thrown.
-                  UI.message("Could not find any dSYM for #{build.build_version} (#{train.version_string})")
-                else
-                  UI.message("Waiting for dSYM file to appear...")
-                  sleep(30)
-                  next
-                end
-              end
-
-              break
-            end
+          UI.verbose("Build_version: #{asc_build_number} matches #{build_number}, grabbing dsym_url") if build_number
+          get_details_and_download_dsym(app: app, train: asc_app_version, build_number: asc_build_number, platform: itc_platform, wait_for_dsym_processing: wait_for_dsym_processing, wait_timeout: wait_timeout, output_directory: output_directory)
+        end
+      end
+
+      def self.get_details_and_download_dsym(app: nil, train: nil, build_number: nil, platform: nil, wait_for_dsym_processing: nil, wait_timeout: nil, output_directory: nil)
+        start = Time.now
+        download_url = nil
+
+        loop do
+          begin
+            resp = Spaceship::Tunes.client.build_details(app_id: app.id, train: train, build_number: build_number, platform: platform)
+
+            resp['apple_id'] = app.id
+            build_details = Spaceship::Tunes::BuildDetails.factory(resp)
 
-            if download_url
-              self.download(download_url, app.bundle_id, train.version_string, build.build_version, output_directory)
-              break if build_number
+            download_url = build_details.dsym_url
+            UI.verbose("dsym_url: #{download_url}")
+          rescue Spaceship::TunesClient::ITunesConnectError => ex
+            UI.error("Error accessing dSYM file for build\n\n#{build}\n\nException: #{ex}")
+          end
+
+          unless download_url
+            if !wait_for_dsym_processing || (Time.now - start) > wait_timeout
+              # In some cases, AppStoreConnect does not process the dSYMs, thus no error should be thrown.
+              UI.message("Could not find any dSYM for #{build_number} (#{train})")
             else
-              UI.message("No dSYM URL for #{build.build_version} (#{train.version_string})")
+              UI.message("Waiting for dSYM file to appear...")
+              sleep(30)
+              next
             end
           end
+
+          break
         end
 
-        if (Actions.lane_context[SharedValues::DSYM_PATHS] || []).count == 0
-          UI.error("No dSYM files found on App Store Connect - this usually happens when no recompiling has happened yet")
+        if download_url
+          self.download(download_url, app.bundle_id, train, build_number, output_directory)
+          return if build_number
+        else
+          UI.message("No dSYM URL for #{build_number} (#{train})")
         end
       end
       # rubocop:enable Metrics/PerceivedComplexity
 
+      def self.get_latest_build!(app_id: nil, version: 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 bulid for version #{version}")
+        end
+
+        return latest_build
+      end
+
       def self.download(download_url, bundle_id, train_number, build_version, output_directory)
         result = self.download_file(download_url)
         path   = write_dsym(result, bundle_id, train_number, build_version, output_directory)

data/fastlane/lib/fastlane/actions/set_changelog.rb

@@ -4,9 +4,10 @@ module Fastlane
       def self.run(params)
         require 'spaceship'
 
+        # Team selection passed though FASTLANE_ITC_TEAM_ID and FASTLANE_ITC_TEAM_NAME environment variables
+        # Prompts select team if multiple teams and none specified
         UI.message("Login to App Store Connect (#{params[:username]})")
-        Spaceship::Tunes.login(params[:username])
-        Spaceship::Tunes.select_team
+        Spaceship::ConnectAPI.login(params[:username], use_portal: false, use_tunes: true)
         UI.message("Login successful")
 
         app = Spaceship::ConnectAPI::App.find(params[:app_identifier])

data/fastlane/lib/fastlane/actions/sonar.rb

@@ -16,6 +16,7 @@ module Fastlane
         sonar_scanner_args << "-Dsonar.projectName=\"#{params[:project_name]}\"" if params[:project_name]
         sonar_scanner_args << "-Dsonar.projectVersion=\"#{params[:project_version]}\"" if params[:project_version]
         sonar_scanner_args << "-Dsonar.sources=\"#{params[:sources_path]}\"" if params[:sources_path]
+        sonar_scanner_args << "-Dsonar.exclusions=\"#{params[:exclusions]}\"" if params[:exclusions]
         sonar_scanner_args << "-Dsonar.language=\"#{params[:project_language]}\"" if params[:project_language]
         sonar_scanner_args << "-Dsonar.sourceEncoding=\"#{params[:source_encoding]}\"" if params[:source_encoding]
         sonar_scanner_args << "-Dsonar.login=\"#{params[:sonar_login]}\"" if params[:sonar_login]
@@ -81,6 +82,10 @@ module Fastlane
                                        env_name: "FL_SONAR_RUNNER_SOURCES_PATH",
                                        description: "Comma-separated paths to directories containing source files. Must either be specified here or inside the sonar project configuration file",
                                        optional: true),
+          FastlaneCore::ConfigItem.new(key: :exclusions,
+                                       env_name: "FL_SONAR_RUNNER_EXCLUSIONS",
+                                       description: "Comma-separated paths to directories to be excluded from the analysis",
+                                       optional: true),
           FastlaneCore::ConfigItem.new(key: :project_language,
                                        env_name: "FL_SONAR_RUNNER_PROJECT_LANGUAGE",
                                        description: "Language key, e.g. objc",