fastlane 2.160.0 → 2.165.0

data/deliver/lib/deliver/app_screenshot_iterator.rb

@@ -52,10 +52,10 @@ module Deliver
       end
     end
 
-    # Iterate given local app_screenshot over localizations and app_screenshot_sets with index within each app_screenshot_set
+    # Iterate given local app_screenshot over localizations and app_screenshot_sets
     #
     # @param screenshots_per_language [Hash<String, Array<Deliver::AppScreenshot>]
-    # @yield [localization, app_screenshot_set, app_screenshot, index]
+    # @yield [localization, app_screenshot_set, app_screenshot]
     # @yieldparam [optional, Spaceship::ConnectAPI::AppStoreVersionLocalization] localization
     # @yieldparam [optional, Spaceship::ConnectAPI::AppStoreScreenshotSet] app_screenshot_set
     # @yieldparam [optional, Deliver::AppScreenshot] screenshot
@@ -85,8 +85,8 @@ module Deliver
           app_screenshot_set ||= localization.create_app_screenshot_set(attributes: { screenshotDisplayType: display_type })
 
           # iterate over screenshots per display size with index
-          screenshots.each.with_index do |screenshot, index|
-            yield(localization, app_screenshot_set, screenshot, index)
+          screenshots.each do |screenshot|
+            yield(localization, app_screenshot_set, screenshot)
           end
         end
       end

data/deliver/lib/deliver/module.rb

@@ -1,5 +1,6 @@
 require 'fastlane_core/helper'
 require 'fastlane_core/ui/ui'
+require 'fastlane/boolean'
 
 module Deliver
   class << self
@@ -7,6 +8,7 @@ module Deliver
 
   Helper = FastlaneCore::Helper # you gotta love Ruby: Helper.* should use the Helper class contained in FastlaneCore
   UI = FastlaneCore::UI
+  Boolean = Fastlane::Boolean
 
   # Constant that captures the root Pathname for the project. Should be used for building paths to assets or other
   # resources that code needs to locate locally

data/deliver/lib/deliver/options.rb

@@ -16,7 +16,7 @@ module Deliver
                                      env_name: "DELIVER_API_KEY_PATH",
                                      description: "Path to your App Store Connect API Key JSON file (https://docs.fastlane.tools/app-store-connect-api/#using-fastlane-api-key-json-file)",
                                      optional: true,
-                                     conflicting_options: [:username],
+                                     conflicting_options: [:api_key],
                                      verify_block: proc do |value|
                                        UI.user_error!("Couldn't find API key JSON file at path '#{value}'") unless File.exist?(value)
                                      end),
@@ -26,7 +26,7 @@ module Deliver
                                      type: Hash,
                                      optional: true,
                                      sensitive: true,
-                                     conflicting_options: [:api_key_path, :username]),
+                                     conflicting_options: [:api_key_path]),
 
         FastlaneCore::ConfigItem.new(key: :username,
                                      short_option: "-u",
@@ -153,7 +153,7 @@ module Deliver
         FastlaneCore::ConfigItem.new(key: :force,
                                      short_option: "-f",
                                      env_name: "DELIVER_FORCE",
-                                     description: "Skip the HTML report file verification",
+                                     description: "Skip verification of HTML preview file",
                                      is_string: false,
                                      default_value: false),
         FastlaneCore::ConfigItem.new(key: :overwrite_screenshots,
@@ -176,8 +176,8 @@ module Deliver
         FastlaneCore::ConfigItem.new(key: :automatic_release,
                                      env_name: "DELIVER_AUTOMATIC_RELEASE",
                                      description: "Should the app be automatically released once it's approved? (Can not be used together with `auto_release_date`)",
-                                     is_string: false,
-                                     default_value: false),
+                                     type: Boolean,
+                                     optional: true),
         FastlaneCore::ConfigItem.new(key: :auto_release_date,
                                      env_name: "DELIVER_AUTO_RELEASE_DATE",
                                      description: "Date in milliseconds for automatically releasing on pending approval (Can not be used together with `automatic_release`)",

data/deliver/lib/deliver/queue_worker.rb

@@ -6,9 +6,11 @@ module Deliver
   # Use this when you have all the items that you'll process in advance.
   # Simply enqueue them to this and call `QueueWorker#start`.
   class QueueWorker
+    NUMBER_OF_THREADS = Helper.test? ? 1 : [ENV.fetch("DELIVER_NUMBER_OF_THREADS", 10).to_i, 10].min
+
     # @param concurrency (Numeric) - A number of threads to be created
     # @param block (Proc) - A task you want to execute with enqueued items
-    def initialize(concurrency, &block)
+    def initialize(concurrency = NUMBER_OF_THREADS, &block)
       @concurrency = concurrency
       @block = block
       @queue = Queue.new
@@ -19,46 +21,29 @@ module Deliver
       @queue.push(job)
     end
 
+    # @param jobs (Array<Object>) - An array of arbitary object that keeps parameters
+    def batch_enqueue(jobs)
+      raise(ArgumentError, "Enqueue Array instead of #{jobs.class}") unless jobs.kind_of?(Array)
+      jobs.each { |job| enqueue(job) }
+    end
+
     # Call this after you enqueuned all the jobs you want to process
     # This method blocks current thread until all the enqueued jobs are processed
     def start
+      @queue.close
+
       threads = []
       @concurrency.times do
         threads << Thread.new do
-          while running? && !empty?
+          job = @queue.pop
+          while job
+            @block.call(job)
             job = @queue.pop
-            @block.call(job) if job
           end
         end
       end
 
-      wait_for_complete
       threads.each(&:join)
     end
-
-    private
-
-    def running?
-      !@queue.closed?
-    end
-
-    def empty?
-      @queue.empty?
-    end
-
-    def wait_for_complete
-      wait_thread = Thread.new do
-        loop do
-          if @queue.empty?
-            @queue.close
-            break
-          end
-
-          sleep(1)
-        end
-      end
-
-      wait_thread.join
-    end
   end
 end

data/deliver/lib/deliver/upload_metadata.rb

@@ -1,4 +1,5 @@
 require_relative 'module'
+require_relative 'queue_worker'
 
 module Deliver
   # upload description, rating, etc.
@@ -175,35 +176,48 @@ module Deliver
 
                        non_localized_version_attributes['earliestReleaseDate'] = date
                        Spaceship::ConnectAPI::AppStoreVersion::ReleaseType::SCHEDULED
-                     elsif options[:automatic_release]
+                     elsif options[:automatic_release] == true
                        Spaceship::ConnectAPI::AppStoreVersion::ReleaseType::AFTER_APPROVAL
-                     else
+                     elsif options[:automatic_release] == false
                        Spaceship::ConnectAPI::AppStoreVersion::ReleaseType::MANUAL
                      end
-      non_localized_version_attributes['releaseType'] = release_type
+      if release_type.nil?
+        UI.important("Release type will not be set because neither `automatic_release` nor `auto_release_date` were provided. Please explicitly set one of these options if you need a release type set")
+      else
+        non_localized_version_attributes['releaseType'] = release_type
+      end
 
       # Update app store version
       # This needs to happen before updating localizations (https://openradar.appspot.com/radar?id=4925914991296512)
+      #
+      # Adding some sleeps because the API will sometimes be in a state where releaseType can't be modified
+      #   https://github.com/fastlane/fastlane/issues/16911
       UI.message("Uploading metadata to App Store Connect for version")
+      sleep(2)
       version.update(attributes: non_localized_version_attributes)
+      sleep(1)
 
       # Update app store version localizations
-      app_store_version_localizations.each do |app_store_version_localization|
+      store_version_worker = Deliver::QueueWorker.new do |app_store_version_localization|
         attributes = localized_version_attributes_by_locale[app_store_version_localization.locale]
         if attributes
           UI.message("Uploading metadata to App Store Connect for localized version '#{app_store_version_localization.locale}'")
           app_store_version_localization.update(attributes: attributes)
         end
       end
+      store_version_worker.batch_enqueue(app_store_version_localizations)
+      store_version_worker.start
 
       # Update app info localizations
-      app_info_localizations.each do |app_info_localization|
+      app_info_worker = Deliver::QueueWorker.new do |app_info_localization|
         attributes = localized_info_attributes_by_locale[app_info_localization.locale]
         if attributes
           UI.message("Uploading metadata to App Store Connect for localized info '#{app_info_localization.locale}'")
           app_info_localization.update(attributes: attributes)
         end
       end
+      app_info_worker.batch_enqueue(app_info_localizations)
+      app_info_worker.start
 
       # Update categories
       app_info = fetch_edit_app_info(app)
@@ -584,6 +598,7 @@ module Deliver
     def set_review_information(version, options)
       return unless options[:app_review_information]
       info = options[:app_review_information]
+      info = info.collect { |k, v| [k.to_sym, v] }.to_h
       UI.user_error!("`app_review_information` must be a hash", show_github_issues: true) unless info.kind_of?(Hash)
 
       attributes = {}

data/deliver/lib/deliver/upload_screenshots.rb

@@ -13,8 +13,6 @@ module Deliver
     DeleteScreenshotJob = Struct.new(:app_screenshot, :localization, :app_screenshot_set)
     UploadScreenshotJob = Struct.new(:app_screenshot_set, :path)
 
-    NUMBER_OF_THREADS = Helper.test? ? 1 : [ENV.fetch("DELIVER_NUMBER_OF_THREADS", 10).to_i, 10].min
-
     def upload(options, screenshots)
       return if options[:skip_screenshots]
       return if options[:edit_live]
@@ -69,7 +67,7 @@ module Deliver
     def delete_screenshots(localizations, screenshots_per_language, tries: 5)
       tries -= 1
 
-      worker = QueueWorker.new(NUMBER_OF_THREADS) do |job|
+      worker = QueueWorker.new do |job|
         start_time = Time.now
         target = "#{job.localization.locale} #{job.app_screenshot_set.screenshot_display_type} #{job.app_screenshot.id}"
         begin
@@ -115,7 +113,7 @@ module Deliver
       tries -= 1
 
       # Upload screenshots
-      worker = QueueWorker.new(NUMBER_OF_THREADS) do |job|
+      worker = QueueWorker.new do |job|
         begin
           UI.verbose("Uploading '#{job.path}'...")
           start_time = Time.now
@@ -126,10 +124,16 @@ module Deliver
         end
       end
 
-      number_of_screenshots = 0
+      # Each app_screenshot_set can have only 10 images
+      number_of_screenshots_per_set = {}
+      total_number_of_screenshots = 0
+
       iterator = AppScreenshotIterator.new(localizations)
-      iterator.each_local_screenshot(screenshots_per_language) do |localization, app_screenshot_set, screenshot, index|
-        if index >= 10
+      iterator.each_local_screenshot(screenshots_per_language) do |localization, app_screenshot_set, screenshot|
+        # Initialize counter on each app screenshot set
+        number_of_screenshots_per_set[app_screenshot_set] ||= (app_screenshot_set.app_screenshots || []).count
+
+        if number_of_screenshots_per_set[app_screenshot_set] >= 10
           UI.error("Too many screenshots found for device '#{screenshot.device_type}' in '#{screenshot.language}', skipping this one (#{screenshot.path})")
           next
         end
@@ -141,10 +145,12 @@ module Deliver
         if duplicate
           UI.message("Previous uploaded. Skipping '#{screenshot.path}'...")
         else
+          UI.verbose("Queued uplaod sceeenshot job for #{localization.locale} #{app_screenshot_set.screenshot_display_type} #{screenshot.path}")
           worker.enqueue(UploadScreenshotJob.new(app_screenshot_set, screenshot.path))
+          number_of_screenshots_per_set[app_screenshot_set] += 1
         end
 
-        number_of_screenshots += 1
+        total_number_of_screenshots += 1
       end
 
       worker.start
@@ -154,7 +160,7 @@ module Deliver
       Helper.show_loading_indicator("Waiting for all the screenshots processed...")
       states = wait_for_complete(iterator)
       Helper.hide_loading_indicator
-      retry_upload_screenshots_if_needed(iterator, states, number_of_screenshots, tries, localizations, screenshots_per_language)
+      retry_upload_screenshots_if_needed(iterator, states, total_number_of_screenshots, tries, localizations, screenshots_per_language)
 
       UI.message("Successfully uploaded all screenshots")
     end
@@ -203,12 +209,21 @@ module Deliver
       # Check if local screenshots' checksum exist on App Store Connect
       checksum_to_app_screenshot = iterator.each_app_screenshot.map { |_, _, app_screenshot| [app_screenshot.source_file_checksum, app_screenshot] }.to_h
 
-      missing_local_screenshots = iterator.each_local_screenshot(screenshots_per_language).select do |_, _, local_screenshot, index|
+      number_of_screenshots_per_set = {}
+      missing_local_screenshots = iterator.each_local_screenshot(screenshots_per_language).select do |_, app_screenshot_set, local_screenshot|
+        number_of_screenshots_per_set[app_screenshot_set] ||= (app_screenshot_set.app_screenshots || []).count
         checksum = UploadScreenshots.calculate_checksum(local_screenshot.path)
-        checksum_to_app_screenshot[checksum].nil? && index < 10 # if index is more than 10, it's skipped
+
+        if checksum_to_app_screenshot[checksum]
+          next(false)
+        else
+          is_missing = number_of_screenshots_per_set[app_screenshot_set] < 10 # if it's more than 10, it's skipped
+          number_of_screenshots_per_set[app_screenshot_set] += 1
+          next(is_missing)
+        end
       end
 
-      missing_local_screenshots.each do |_, _, screenshot, _|
+      missing_local_screenshots.each do |_, _, screenshot|
         UI.error("#{screenshot.path} is missing on App Store Connect.")
       end
 
@@ -219,7 +234,7 @@ module Deliver
       iterator = AppScreenshotIterator.new(localizations)
 
       # Re-order screenshots within app_screenshot_set
-      worker = QueueWorker.new(NUMBER_OF_THREADS) do |app_screenshot_set|
+      worker = QueueWorker.new do |app_screenshot_set|
         original_ids = app_screenshot_set.app_screenshots.map(&:id)
         sorted_ids = app_screenshot_set.app_screenshots.sort_by(&:file_name).map(&:id)
         if original_ids != sorted_ids

data/fastlane/lib/fastlane/actions/actions_helper.rb

@@ -4,6 +4,25 @@ module Fastlane
       LANE_NAME = :LANE_NAME
       PLATFORM_NAME = :PLATFORM_NAME
       ENVIRONMENT = :ENVIRONMENT
+
+      # A slighly decorated hash that will store and fetch sensitive data
+      # but not display it while iterating keys and values
+      class LaneContextValues < Hash
+        def initialize
+          @sensitive_context = {}
+        end
+
+        def set_sensitive(key, value)
+          @sensitive_context[key] = value
+        end
+
+        def [](key)
+          if @sensitive_context.key?(key)
+            return @sensitive_context[key]
+          end
+          super
+        end
+      end
     end
 
     def self.reset_aliases
@@ -27,7 +46,7 @@ module Fastlane
 
     # The shared hash can be accessed by any action and contains information like the screenshots path or beta URL
     def self.lane_context
-      @lane_context ||= {}
+      @lane_context ||= SharedValues::LaneContextValues.new
     end
 
     # Used in tests to get a clear lane before every test

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

@@ -27,9 +27,15 @@ module Fastlane
 
       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::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")
+        token = self.api_token(params)
+        if token
+          UI.message("Using App Store Connect API token...")
+          Spaceship::ConnectAPI.token = token
+        else
+          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")
+        end
 
         platform = Spaceship::ConnectAPI::Platform.map(params[:platform])
 
@@ -92,6 +98,13 @@ module Fastlane
         versions.map(&:to_s).sort_by { |v| Gem::Version.new(v) }
       end
 
+      def self.api_token(params)
+        params[:api_key] ||= Actions.lane_context[SharedValues::APP_STORE_CONNECT_API_KEY]
+        api_token ||= Spaceship::ConnectAPI::Token.create(params[:api_key]) if params[:api_key]
+        api_token ||= Spaceship::ConnectAPI::Token.from_json_file(params[:api_key_path]) if params[:api_key_path]
+        return api_token
+      end
+
       #####################################################
       # @!group Documentation
       #####################################################
@@ -104,6 +117,21 @@ module Fastlane
         user = CredentialsManager::AppfileConfig.try_fetch_value(:itunes_connect_id)
         user ||= CredentialsManager::AppfileConfig.try_fetch_value(:apple_id)
         [
+          FastlaneCore::ConfigItem.new(key: :api_key_path,
+                                       env_name: "APPSTORE_BUILD_NUMBER_API_KEY_PATH",
+                                       description: "Path to your App Store Connect API Key JSON file (https://docs.fastlane.tools/app-store-connect-api/#using-fastlane-api-key-json-file)",
+                                       optional: true,
+                                       conflicting_options: [:api_key],
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Couldn't find API key JSON file at path '#{value}'") unless File.exist?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :api_key,
+                                       env_name: "APPSTORE_BUILD_NUMBER_API_KEY",
+                                       description: "Your App Store Connect API Key information (https://docs.fastlane.tools/app-store-connect-api/#use-return-value-and-pass-in-as-an-option)",
+                                       type: Hash,
+                                       optional: true,
+                                       sensitive: true,
+                                       conflicting_options: [:api_key_path]),
           FastlaneCore::ConfigItem.new(key: :initial_build_number,
                                        env_name: "INITIAL_BUILD_NUMBER",
                                        description: "sets the build number to given value if no build is in current train",
@@ -193,6 +221,14 @@ module Fastlane
             live: false,
             app_identifier: "app.identifier",
             version: "1.2.9"
+          )',
+          'api_key = app_store_connect_api_key(
+            key_id: "MyKeyID12345",
+            issuer_id: "00000000-0000-0000-0000-000000000000",
+            key_filepath: "./AuthKey.p8"
+          )
+          build_num = app_store_build_number(
+            api_key: api_key
           )'
         ]
       end

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

@@ -1,3 +1,5 @@
+require 'base64'
+
 module Fastlane
   module Actions
     module SharedValues
@@ -9,6 +11,7 @@ module Fastlane
         key_id = options[:key_id]
         issuer_id = options[:issuer_id]
         key_content = options[:key_content]
+        is_key_content_base64 = options[:is_key_content_base64]
         key_filepath = options[:key_filepath]
         duration = options[:duration]
         in_house = options[:in_house]
@@ -17,17 +20,22 @@ module Fastlane
           UI.user_error!(":key_content or :key_filepath is required")
         end
 
+        # New lines don't get read properly when coming from an ENV
+        # Replacing them literal version with a new line
+        key_content = key_content.gsub('\n', "\n") if key_content
+
         # 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),
+          is_key_content_base64: is_key_content_base64,
           duration: duration,
           in_house: in_house
         }
 
-        Actions.lane_context[SharedValues::APP_STORE_CONNECT_API_KEY] = key
+        Actions.lane_context.set_sensitive(SharedValues::APP_STORE_CONNECT_API_KEY, key)
 
         return key
       end
@@ -55,8 +63,14 @@ module Fastlane
           FastlaneCore::ConfigItem.new(key: :key_content,
                                        env_name: "APP_STORE_CONNECT_API_KEY_KEY",
                                        description: "The content of the key p8 file",
+                                       sensitive: true,
                                        optional: true,
                                        conflicting_options: [:filepath]),
+          FastlaneCore::ConfigItem.new(key: :is_key_content_base64,
+                                       env_name: "APP_STORE_CONNECT_API_KEY_IS_KEY_CONTENT_BASE64",
+                                       description: "Whether :key_content is Base64 encoded or not",
+                                       type: Boolean,
+                                       default_value: false),
           FastlaneCore::ConfigItem.new(key: :duration,
                                        env_name: "APP_STORE_CONNECT_API_KEY_DURATION",
                                        description: "The token session duration",