fastlane 2.149.1 → 2.150.0.rc1

data/deliver/lib/deliver/upload_price_tier.rb

@@ -1,23 +1,30 @@
 require_relative 'module'
+require 'spaceship'
 
 module Deliver
   # Set the app's pricing
   class UploadPriceTier
     def upload(options)
       return unless options[:price_tier]
-      app = options[:app]
 
-      # just to be sure, the user might have passed an int (which is fine with us)
-      options[:price_tier] = options[:price_tier].to_s
+      price_tier = options[:price_tier].to_s
 
-      old_price = app.price_tier
-      if options[:price_tier] == old_price
-        UI.success("Price Tier unchanged (tier #{options[:price_tier]})")
+      legacy_app = options[:app]
+      app_id = legacy_app.apple_id
+      app = Spaceship::ConnectAPI::App.get(app_id: app_id)
+
+      app_prices = app.fetch_app_prices
+      if app_prices.first
+        old_price = app_prices.first.id
+      end
+
+      if price_tier == old_price
+        UI.success("Price Tier unchanged (tier #{old_price})")
         return
       end
 
-      app.update_price_tier!(options[:price_tier])
-      UI.success("Successfully updated the pricing from #{old_price} to #{options[:price_tier]}")
+      app.update_app_price_tier(app_price_tier_id: price_tier)
+      UI.success("Successfully updated the pricing from #{old_price} to #{price_tier}")
     end
   end
 end

data/deliver/lib/deliver/upload_screenshots.rb

@@ -11,69 +11,118 @@ module Deliver
       return if options[:skip_screenshots]
       return if options[:edit_live]
 
-      app = options[:app]
+      legacy_app = options[:app]
+      app_id = legacy_app.apple_id
+      app = Spaceship::ConnectAPI::App.get(app_id: app_id)
 
-      v = app.edit_version(platform: options[:platform])
-      UI.user_error!("Could not find a version to edit for app '#{app.name}'") unless v
+      platform = Spaceship::ConnectAPI::Platform.map(options[:platform])
+      version = app.get_edit_app_store_version(platform: platform)
+      UI.user_error!("Could not find a version to edit for app '#{app.name}' for '#{platform}'") unless version
+
+      UI.important("Will begin uploading snapshots for '#{version.version_string}' on App Store Connect")
 
       UI.message("Starting with the upload of screenshots...")
       screenshots_per_language = screenshots.group_by(&:language)
 
+      localizations = version.get_app_store_version_localizations
+
       if options[:overwrite_screenshots]
-        UI.message("Removing all previously uploaded screenshots...")
-        # First, clear all previously uploaded screenshots
-        screenshots_per_language.keys.each do |language|
-          # We have to nil check for languages not activated
-          next if v.screenshots[language].nil?
-          v.screenshots[language].each_with_index do |t, index|
-            v.upload_screenshot!(nil, t.sort_order, t.language, t.device_type, t.is_imessage)
+        # Get localizations on version
+        localizations.each do |localization|
+          # Only delete screenshots if trying to upload
+          next unless screenshots_per_language.keys.include?(localization.locale)
+
+          # Iterate over all screenshots for each set and delete
+          screenshot_sets = localization.get_app_screenshot_sets
+          screenshot_sets.each do |screenshot_set|
+            UI.message("Removing all previously uploaded screenshots for '#{localization.locale}' '#{screenshot_set.screenshot_display_type}'...")
+            screenshot_set.app_screenshots.each do |screenshot|
+              UI.verbose("Deleting screenshot - #{localization.locale} #{screenshot_set.screenshot_display_type} #{screenshot.id}")
+              screenshot.delete!
+            end
           end
         end
       end
 
-      # Now, fill in the new ones
-      indized = {} # per language and device type
+      # Finding languages to enable
+      languages = screenshots_per_language.keys
+      locales_to_enable = languages - localizations.map(&:locale)
 
-      enabled_languages = screenshots_per_language.keys
-      if enabled_languages.count > 0
-        v.create_languages(enabled_languages)
+      if locales_to_enable.count > 0
         lng_text = "language"
-        lng_text += "s" if enabled_languages.count != 1
-        Helper.show_loading_indicator("Activating #{lng_text} #{enabled_languages.join(', ')}...")
-        v.save!
-        # This refreshes the app version from iTC after enabling a localization
-        v = app.edit_version(platform: options[:platform])
+        lng_text += "s" if locales_to_enable.count != 1
+        Helper.show_loading_indicator("Activating #{lng_text} #{locales_to_enable.join(', ')}...")
+
+        locales_to_enable.each do |locale|
+          version.create_app_store_version_localization(attributes: {
+            locale: locale
+          })
+        end
+
         Helper.hide_loading_indicator
+
+        # Refresh version localizations
+        localizations = version.get_app_store_version_localizations
       end
 
+      # Upload screenshots
+      indized = {} # per language and device type
+
       screenshots_per_language.each do |language, screenshots_for_language|
+        # Find localization to upload screenshots to
+        localization = localizations.find do |l|
+          l.locale == language
+        end
+
+        unless localization
+          UI.error("Couldn't find localization on version for #{language}")
+          next
+        end
+
+        indized[localization.locale] ||= {}
+
+        # Create map to find screenshot set to add screenshot to
+        app_screenshot_sets_map = {}
+        app_screenshot_sets = localization.get_app_screenshot_sets
+        app_screenshot_sets.each do |app_screenshot_set|
+          app_screenshot_sets_map[app_screenshot_set.screenshot_display_type] = app_screenshot_set
+
+          # Set initial screnshot count
+          indized[localization.locale][app_screenshot_set.screenshot_display_type] ||= app_screenshot_set.app_screenshots.size
+        end
+
         UI.message("Uploading #{screenshots_for_language.length} screenshots for language #{language}")
         screenshots_for_language.each do |screenshot|
-          indized[screenshot.language] ||= {}
-          indized[screenshot.language][screenshot.formatted_name] ||= 0
-          indized[screenshot.language][screenshot.formatted_name] += 1 # we actually start with 1... wtf iTC
+          display_type = screenshot.device_type
+          set = app_screenshot_sets_map[display_type]
 
-          index = indized[screenshot.language][screenshot.formatted_name]
+          if display_type.nil?
+            UI.error("Error... Screenshot size #{screenshot.screen_size} not valid for App Store Connect")
+            next
+          end
 
-          if index > 10
+          unless set
+            set = localization.create_app_screenshot_set(attributes: {
+              screenshotDisplayType: display_type
+            })
+            app_screenshot_sets_map[display_type] = set
+
+            indized[localization.locale][set.screenshot_display_type] = 0
+          end
+
+          index = indized[localization.locale][set.screenshot_display_type]
+
+          if index >= 10
             UI.error("Too many screenshots found for device '#{screenshot.formatted_name}' in '#{screenshot.language}', skipping this one (#{screenshot.path})")
             next
           end
 
+          indized[localization.locale][set.screenshot_display_type] += 1
+
+          # Also.. what is the messages type even for?
           UI.message("Uploading '#{screenshot.path}'...")
-          v.upload_screenshot!(screenshot.path,
-                               index,
-                               screenshot.language,
-                               screenshot.device_type,
-                               screenshot.is_messages?)
+          set.upload_screenshot(path: screenshot.path)
         end
-        # ideally we should only save once, but itunes server can't cope it seems
-        # so we save per language. See issue #349
-        Helper.show_loading_indicator("Saving changes")
-        v.save!
-        # Refresh app version to start clean again. See issue #9859
-        v = app.edit_version
-        Helper.hide_loading_indicator
       end
       UI.success("Successfully uploaded screenshots to App Store Connect")
     end

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

@@ -364,7 +364,7 @@ snapshot(launch_arguments: ["SKIP_ANIMATIONS"])
 ```
 
 By default, _snapshot_ will wait for a short time for the animations to finish.
-If you're skipping the animations, this is wait time is unnecessary and can be skipped:
+If you're skipping the animations, this wait time is unnecessary and can be skipped:
 
 ```swift
 setupSnapshot(app, waitForAnimations: false)

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

@@ -467,7 +467,7 @@ _deliver_ allows for metadata to be set through `.txt` files in the metadata fol
 
 Key | Editable While Live | Directory | Filename
 ----|--------|--------|--------
-<%- (Deliver::UploadMetadata::NON_LOCALISED_VERSION_VALUES + Deliver::UploadMetadata::NON_LOCALISED_APP_VALUES).each do |value| -%>
+<%- (Deliver::UploadMetadata::NON_LOCALISED_VERSION_VALUES.keys + Deliver::UploadMetadata::NON_LOCALISED_APP_VALUES).each do |value| -%>
   `<%= value %>` | <%= Deliver::UploadMetadata::NON_LOCALISED_LIVE_VALUES.include?(value) ? 'Yes' : 'No' %> | `<metadata_path>` | `<%= value %>.txt`
 <%- end %>
 
@@ -475,23 +475,15 @@ Key | Editable While Live | Directory | Filename
 
 Key | Editable While Live | Directory | Filename
 ----|--------|--------|--------
-<%- (Deliver::UploadMetadata::LOCALISED_APP_VALUES + Deliver::UploadMetadata::LOCALISED_VERSION_VALUES).each do |value| -%>
+<%- (Deliver::UploadMetadata::LOCALISED_APP_VALUES.keys + Deliver::UploadMetadata::LOCALISED_VERSION_VALUES.keys).each do |value| -%>
   `<%= value %>` | <%= Deliver::UploadMetadata::LOCALISED_LIVE_VALUES.include?(value) ? 'Yes' : 'No' %> | `<metadata_path>/<lang>/` | `<%= value %>.txt`
 <%- end %>
 
-### Trade Representative Contact Information Metadata
-
-Key | Editable While Live | Directory | Filename
-----|--------|--------|--------
-<%- Deliver::UploadMetadata::TRADE_REPRESENTATIVE_CONTACT_INFORMATION_VALUES.each do |key, value| -%>
-  `<%= value %>` | Yes | `<metadata_path>/<%= Deliver::UploadMetadata::TRADE_REPRESENTATIVE_CONTACT_INFORMATION_DIR %>` | `<%= value %>.txt`
-<%- end %>
-
 ### Review Information Metadata
 
 Key | Editable While Live | Directory | Filename
 ----|--------|--------|--------
-<%- Deliver::UploadMetadata::REVIEW_INFORMATION_VALUES.each do |key, value| -%>
+<%- Deliver::UploadMetadata::REVIEW_INFORMATION_VALUES_LEGACY.each do |key, value| -%>
   `<%= value %>` | Yes | `<metadata_path>/<%= Deliver::UploadMetadata::REVIEW_INFORMATION_DIR %>` | `<%= value %>.txt`
 <%- end %>
 

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

@@ -171,9 +171,10 @@ A common Play publishing scenario might involve uploading an APK version to a te
 
 This can be done using the `--track_promote_to` parameter. The `--track_promote_to` parameter works with the `--track` parameter to command the Play API to promote existing Play track APK version(s) (those active on the track identified by the `--track` param value) to a new track (`--track_promote_to` value).
 
-## Retrieve Track Version Codes
+## Retrieve Track Release Names & Version Codes
 
-Before performing a new APK upload you may want to check existing track version codes, or you may simply want to provide an informational lane that displays the currently promoted version codes for the production track. You can use the `google_play_track_version_codes` action to retrieve existing version codes for a package and track. For more information, see `fastlane action google_play_track_version_codes` help output.
+Before performing a new APK upload you may want to check existing track version codes or release names, or you may simply want to provide an informational lane that displays the currently promoted version codes or release name for the production track. You can use the `google_play_track_version_codes` action to retrieve existing version codes for a package and track. You can use the `google_play_track_release_names` action to retrieve existing release names for a package and track.
+For more information, see the `fastlane action google_play_track_version_codes` and `fastlane action google_play_track_release_names` help output.
 
 ## Migration from AndroidPublisherV2 to AndroidPublisherV3 in _fastlane_ 2.135.0
 

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

@@ -164,7 +164,13 @@ module Fastlane
 
       def self.download_file(url)
         uri = URI.parse(url)
-        http = Net::HTTP.new(uri.host, uri.port)
+        if ENV['http_proxy']
+          UI.verbose("Found 'http_proxy' environment variable so connect via proxy")
+          proxy_uri = URI.parse(ENV['http_proxy'])
+          http = Net::HTTP.new(uri.host, uri.port, proxy_uri.host, proxy_uri.port)
+        else
+          http = Net::HTTP.new(uri.host, uri.port)
+        end
         http.use_ssl = (uri.scheme == "https")
         res = http.get(uri.request_uri)
         res.body

data/fastlane/lib/fastlane/actions/google_play_track_release_names.rb

@@ -0,0 +1,74 @@
+module Fastlane
+  module Actions
+    class GooglePlayTrackReleaseNamesAction < Action
+      # Supply::Options.available_options keys that apply to this action.
+      OPTIONS = [
+        :package_name,
+        :track,
+        :key,
+        :issuer,
+        :json_key,
+        :json_key_data,
+        :root_url,
+        :timeout
+      ]
+
+      def self.run(params)
+        require 'supply'
+        require 'supply/options'
+        require 'supply/reader'
+
+        Supply.config = params
+
+        release_names = Supply::Reader.new.track_release_names || []
+        return release_names.compact
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Retrieves release names for a Google Play track"
+      end
+
+      def self.details
+        "More information: [https://docs.fastlane.tools/actions/supply/](https://docs.fastlane.tools/actions/supply/)"
+      end
+
+      def self.available_options
+        require 'supply'
+        require 'supply/options'
+
+        Supply::Options.available_options.select do |option|
+          OPTIONS.include?(option.key)
+        end
+      end
+
+      def self.output
+      end
+
+      def self.return_value
+        "Array of strings representing the release names for the given Google Play track"
+      end
+
+      def self.authors
+        ["raldred"]
+      end
+
+      def self.is_supported?(platform)
+        platform == :android
+      end
+
+      def self.example_code
+        [
+          'google_play_track_release_names'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/slack.rb

@@ -159,7 +159,7 @@ module Fastlane
               "Build Date" => Time.new.to_s,
               "Built by" => "Jenkins",
             },
-            default_payloads: [:git_branch, :git_author], # Optional, lets you specify a whitelist of default payloads to include. Pass an empty array to suppress all the default payloads.
+            default_payloads: [:git_branch, :git_author], # Optional, lets you specify an allowlist of default payloads to include. Pass an empty array to suppress all the default payloads.
                                                           # Don\'t add this key, or pass nil, if you want all the default payloads. The available default payloads are: `lane`, `test_result`, `git_branch`, `git_author`, `last_git_commit`, `last_git_commit_hash`.
             attachment_properties: { # Optional, lets you specify any other properties available for attachments in the slack API (see https://api.slack.com/docs/attachments).
                                      # This hash is deep merged with the existing properties set using the other properties above. This allows your own fields properties to be appended to the existing fields that were created using the `payload` property for instance.

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

@@ -8,6 +8,7 @@ module Fastlane
         cmd << "--build-path #{params[:build_path]}" if params[:build_path]
         cmd << "--package-path #{params[:package_path]}" if params[:package_path]
         cmd << "--configuration #{params[:configuration]}" if params[:configuration]
+        cmd << "--disable-sandbox" if params[:disable_sandbox]
         cmd << "--verbose" if params[:verbose]
         cmd << params[:command] if package_commands.include?(params[:command])
         if params[:xcconfig]
@@ -63,6 +64,12 @@ module Fastlane
                                        verify_block: proc do |value|
                                          UI.user_error!("Please pass a valid configuration: (debug|release)") unless valid_configurations.include?(value)
                                        end),
+          FastlaneCore::ConfigItem.new(key: :disable_sandbox,
+                                       env_name: "FL_SPM_DISABLE_SANDBOX",
+                                       description: "Disable using the sandbox when executing subprocesses",
+                                       optional: true,
+                                       is_string: false,
+                                       default_value: false),
           FastlaneCore::ConfigItem.new(key: :xcpretty_output,
                                        env_name: "FL_SPM_XCPRETTY_OUTPUT",
                                        description: "Specifies the output type for xcpretty. eg. 'test', or 'simple'",

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

@@ -45,44 +45,13 @@ module Fastlane
       # @param current_path this is a path to either a dSYM or a zipped dSYM
       #   this might also be either nested or not, we're flexible
       def self.handle_dsym(params, current_path, max_worker_threads)
-        if current_path.end_with?(".dSYM")
+        if current_path.end_with?(".dSYM", ".zip")
           upload_dsym(params, current_path)
-        elsif current_path.end_with?(".zip")
-          UI.message("Extracting '#{current_path}'...")
-
-          current_path = File.expand_path(current_path)
-          Dir.mktmpdir do |dir|
-            Dir.chdir(dir) do
-              Actions.sh("unzip -qo #{current_path.shellescape}")
-              work_q = Queue.new
-              Dir["*.dSYM"].each do |sub|
-                work_q.push(sub)
-              end
-              execute_uploads(params, max_worker_threads, work_q)
-            end
-          end
         else
           UI.error("Don't know how to handle '#{current_path}'")
         end
       end
 
-      def self.execute_uploads(params, max_worker_threads, work_q)
-        number_of_threads = [max_worker_threads, work_q.size].min
-        workers = (0...number_of_threads).map do
-          Thread.new do
-            begin
-              while work_q.size > 0
-                current_path = work_q.pop(true)
-                upload_dsym(params, current_path)
-              end
-            rescue => ex
-              UI.error(ex.to_s)
-            end
-          end
-        end
-        workers.map(&:join)
-      end
-
       def self.upload_dsym(params, path)
         UI.message("Uploading '#{path}'...")
         command = []

data/fastlane/lib/fastlane/lane.rb

@@ -41,8 +41,8 @@ module Fastlane
     class << self
       # Makes sure the lane name is valid
       def verify_lane_name(name)
-        if self.black_list.include?(name.to_s)
-          UI.error("Lane name '#{name}' is invalid! Invalid names are #{self.black_list.join(', ')}.")
+        if self.deny_list.include?(name.to_s)
+          UI.error("Lane name '#{name}' is invalid! Invalid names are #{self.deny_list.join(', ')}.")
           UI.user_error!("Lane name '#{name}' is invalid")
         end
 
@@ -59,7 +59,7 @@ module Fastlane
         self.ensure_name_not_conflicts(name.to_s)
       end
 
-      def black_list
+      def deny_list
         %w(
           run
           init

data/fastlane/lib/fastlane/swift_fastlane_function.rb

@@ -98,7 +98,11 @@ module Fastlane
       elsif type_override == Float
         return "Float"
       elsif type_override == :string_callback
-        return "((String) -> Void)"
+        # David Hart:
+        # It doesn't make sense to add escaping annotations to optional closures because they aren't function types:
+        # they are basically an enum (Optional) containing a function, the same way you would store a closure in any type:
+        # it's implicitly escaping because it's owned by another type.
+        return "((String) -> Void)?"
       else
         return default_type
       end
@@ -106,7 +110,7 @@ module Fastlane
 
     def override_default_value_if_not_correct_type(param_name: nil, param_type: nil, default_value: nil)
       return "[]" if param_type == "[String]" && default_value == ""
-      return "{_ in }" if param_type == "((String) -> Void)"
+      return "nil" if param_type == "((String) -> Void)?"
 
       return default_value
     end
@@ -121,7 +125,7 @@ module Fastlane
 
       optional_specifier = ""
       # if we are optional and don't have a default value, we'll need to use ?
-      optional_specifier = "?" if (optional && default_value.nil?) && type != "((String) -> Void)"
+      optional_specifier = "?" if (optional && default_value.nil?) && type != "((String) -> Void)?"
 
       # If we have a default value of true or false, we can infer it is a Bool
       if default_value.class == FalseClass
@@ -162,7 +166,7 @@ module Fastlane
             # we can't handle default values for Hashes, yet
             # see method swift_default_implementations for similar behavior
             default_value = "[:]"
-          elsif type != "Bool" && type != "[String]" && type != "Int" && type != "((String) -> Void)" && type != "Float" && type != "Double"
+          elsif type != "Bool" && type != "[String]" && type != "Int" && type != "@escaping ((String) -> Void)" && type != "Float" && type != "Double"
             default_value = "\"#{default_value}\""
           end
         end