fastlane-plugin-wpmreleasetoolkit 12.5.0 → 13.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 54ad163793f5102f88dd8a4a82408cd73bd5bb5d084354f4ea8d21f90cb994b5
-  data.tar.gz: 7d627bd253b7b2c9be0b990108caffb1a0b1a9056466afa98628fe4e27b79c2a
+  metadata.gz: 812b207092ef802b165390e74ba296566e70a3e406c7e1a50572a6bd7b6da761
+  data.tar.gz: 9266eec38e720af58e54413e649b2451e0f88100f4621bfab25daa05912663ee
 SHA512:
-  metadata.gz: 545ce35d03805a5deb7c30ed22e01f55106d0a8420a89a355f2ff8047ddddef2b433294da5a86d6a5c1ca460c0d3f1c08215396b637faa50d9aca7be5823c2f2
-  data.tar.gz: fc4d77d82c952c610f73c823d4b8548a83627ceac6ba79101e8a235e3851e16fefbc4bdd7f1c87cc0f89ee68194b95c4570bb798923006aa1121de66b57ca6ab
+  metadata.gz: 45a5b7aceb10ac90eaf7bf81e3c8cf07d1ed67691d558c610d8393db098e699f20f8ed63dcaf97f3af44f70433ee70f278ac0ee7185a1374642c4b4504ac51df
+  data.tar.gz: 8a8f7296d5458082034650d8675a17e4144f3d9c5cfc45e7482101c69ab1cdcadc645109b5151a65099167b0b910b5b4f092e92f717dcd210e37c9d5e7780e3a

data/lib/fastlane/plugin/wpmreleasetoolkit/actions/common/create_release_backmerge_pull_request_action.rb

@@ -9,6 +9,7 @@ module Fastlane
       DEFAULT_BRANCH = 'trunk'
 
       def self.run(params)
+        api_url = params[:api_url]
         token = params[:github_token]
         repository = params[:repository]
         source_branch = params[:source_branch]
@@ -41,6 +42,7 @@ module Fastlane
           Fastlane::Helper::GitHelper.checkout_and_pull(source_branch)
 
           create_backmerge_pr(
+            api_url: api_url,
             token: token,
             repository: repository,
             title: "Merge #{source_branch} into #{target_branch}",
@@ -76,6 +78,7 @@ module Fastlane
 
       # Creates a backmerge pull request using the `create_pull_request` Fastlane Action.
       #
+      # @param api_url [String] the GitHub API URL to use for creating the pull request
       # @param token [String] the GitHub token for authentication.
       # @param repository [String] the repository where the pull request will be created.
       # @param title [String] the title of the pull request.
@@ -90,7 +93,7 @@ module Fastlane
       #
       # @return [String] The URL of the created Pull Request, or `nil` if no PR was created.
       #
-      def self.create_backmerge_pr(token:, repository:, title:, head_branch:, base_branch:, labels:, milestone:, reviewers:, team_reviewers:, intermediate_branch_created_callback:)
+      def self.create_backmerge_pr(api_url:, token:, repository:, title:, head_branch:, base_branch:, labels:, milestone:, reviewers:, team_reviewers:, intermediate_branch_created_callback:) # rubocop:disable Metrics/ParameterLists
         # Do an early pre-check to see if the PR would be valid, but only if no callback (as a callback might add new commits on intermediate branch)
         if intermediate_branch_created_callback.nil? && !can_merge?(head_branch, into: base_branch)
           UI.error("Nothing to merge from #{head_branch} into #{base_branch}. Skipping PR creation.")
@@ -108,7 +111,9 @@ module Fastlane
 
         # Call the callback if one was provided to allow the use to add commits on the intermediate branch (e.g. solve conflicts)
         unless intermediate_branch_created_callback.nil?
-          intermediate_branch_created_callback.call(base_branch, intermediate_branch)
+          Dir.chdir(FastlaneCore::FastlaneFolder.path) do
+            intermediate_branch_created_callback.call(base_branch, intermediate_branch)
+          end
           # Make sure the callback block didn't switch branches
           other_action.ensure_git_branch(branch: "^#{intermediate_branch}$")
 
@@ -120,7 +125,7 @@ module Fastlane
           end
         end
 
-        other_action.push_to_git_remote(tags: false)
+        other_action.push_to_git_remote(tags: false, remote_branch: intermediate_branch, set_upstream: true)
 
         pr_body = <<~BODY
           Merging `#{head_branch}` into `#{base_branch}`.
@@ -136,6 +141,7 @@ module Fastlane
         BODY
 
         other_action.create_pull_request(
+          api_url: api_url,
           api_token: token,
           repo: repository,
           title: title,
@@ -191,50 +197,63 @@ module Fastlane
       end
 
       def self.available_options
+        # Parameters we want to forward from Fastlane's create_pull_request action
+        forwarded_param_keys = %i[
+          api_url
+          labels
+          assignees
+          reviewers
+          team_reviewers
+        ].freeze
+
+        forwarded_params = Fastlane::Actions::CreatePullRequestAction.available_options.select do |opt|
+          forwarded_param_keys.include?(opt.key)
+        end
+
         [
-          FastlaneCore::ConfigItem.new(key: :repository,
-                                       env_name: 'GHHELPER_REPOSITORY',
-                                       description: 'The remote path of the GH repository on which we work',
-                                       optional: false,
-                                       type: String),
-          FastlaneCore::ConfigItem.new(key: :source_branch,
-                                       description: 'The source branch to create a backmerge PR from, in the format `release/x.y.z`',
-                                       optional: false,
-                                       type: String),
-          FastlaneCore::ConfigItem.new(key: :default_branch,
-                                       description: 'The default branch to target if no newer release branches exist',
-                                       optional: true,
-                                       default_value: DEFAULT_BRANCH,
-                                       type: String),
-          FastlaneCore::ConfigItem.new(key: :target_branches,
-                                       description: 'Array of target branches for the backmerge. If empty, the action will determine target branches by finding all `release/x.y.z` branches with a `x.y.z` version greater than the version in source branch\'s name. If none are found, it will target `default_branch`', # rubocop:disable Layout/LineLength
-                                       optional: true,
-                                       default_value: [],
-                                       type: Array),
-          FastlaneCore::ConfigItem.new(key: :labels,
-                                       description: 'The labels that should be assigned to the backmerge PRs',
-                                       optional: true,
-                                       default_value: [],
-                                       type: Array),
-          FastlaneCore::ConfigItem.new(key: :milestone_title,
-                                       description: 'The title of the milestone to assign to the created PRs',
-                                       optional: true,
-                                       type: String),
-          FastlaneCore::ConfigItem.new(key: :reviewers,
-                                       description: 'An array of GitHub users that will be assigned to the pull request',
-                                       optional: true,
-                                       type: Array),
-          FastlaneCore::ConfigItem.new(key: :team_reviewers,
-                                       description: 'An array of GitHub team slugs that will be assigned to the pull request',
-                                       optional: true,
-                                       type: Array),
-          FastlaneCore::ConfigItem.new(key: :intermediate_branch_created_callback,
-                                       description: 'Callback to allow for the caller to perform operations on the intermediate branch (e.g. pushing new commits to pre-solve conflicts) before creating the PR. ' \
-                                        + 'The callback receives two parameters: the base (target) branch for the PR and the intermediate branch name that has been created.' \
-                                        + 'Note that if you use the callback to add new commits to the intermediate branch, you are responsible for git-pushing them too',
-                                       optional: true,
-                                       type: Proc),
-          Fastlane::Helper::GithubHelper.github_token_config_item,
+          *forwarded_params,
+          Fastlane::Helper::GithubHelper.github_token_config_item, # we forward `github_token` to `api_token` in the `create_pull_request` action
+          FastlaneCore::ConfigItem.new(
+            key: :repository,
+            env_name: 'GHHELPER_REPOSITORY',
+            description: 'The remote path of the GH repository on which we work',
+            optional: false,
+            type: String
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :source_branch,
+            description: 'The source branch to create a backmerge PR from, in the format `release/x.y.z`',
+            optional: false,
+            type: String
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :default_branch,
+            description: 'The default branch to target if no newer release branches exist',
+            optional: true,
+            default_value: DEFAULT_BRANCH,
+            type: String
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :target_branches,
+            description: 'Array of target branches for the backmerge. If empty, the action will determine target branches by finding all `release/x.y.z` branches with a `x.y.z` version greater than the version in source branch\'s name. If none are found, it will target `default_branch`',
+            optional: true,
+            default_value: [],
+            type: Array
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :milestone_title,
+            description: 'The title of the milestone to assign to the created PRs',
+            optional: true,
+            type: String
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :intermediate_branch_created_callback,
+            description: 'Callback to allow for the caller to perform operations on the intermediate branch (e.g. pushing new commits to pre-solve conflicts) before creating the PR. ' \
+             + 'The callback receives two parameters: the base (target) branch for the PR and the intermediate branch name that has been created.' \
+             + 'Note that if you use the callback to add new commits to the intermediate branch, you are responsible for git-pushing them too',
+            optional: true,
+            type: Proc
+          ),
         ]
       end
 

data/lib/fastlane/plugin/wpmreleasetoolkit/actions/common/prototype_build_details_comment_action.rb

@@ -1,26 +1,35 @@
 # frozen_string_literal: true
 
+require 'cgi'
+require 'uri'
+
 module Fastlane
   module Actions
     class PrototypeBuildDetailsCommentAction < Action
       def self.run(params)
         app_display_name = params[:app_display_name]
-        app_center_info = AppCenterInfo.from_params(params)
-        metadata = consolidate_metadata(params, app_center_info)
+        download_url = params[:download_url]
+        release_info = FirebaseReleaseInfo.from_lane_context
 
-        qr_code_url, extra_metadata = build_install_links(app_center_info, params[:download_url])
+        # Merge explicit extra metadata passed from params with ones derived from FirebaseReleaseInfo
+        metadata = generate_metadata_hash(params: params, release_info: release_info)
+        # Build the installation link, QR code URL and extra metadata for download links from the available info
+        qr_code_url, extra_metadata = install_links(release_info: release_info, download_url: download_url)
         metadata.merge!(extra_metadata)
 
-        # Build the comment parts
-        icon_img_tag = img_tag(params[:app_icon] || app_center_info.icon, alt: app_display_name)
+        # Build the comment parts and body
+        app_icon = params[:app_icon]
+        app_icon ||= ':firebase:' if !release_info.nil? || (download_url && is_firebase_url?(download_url))
+        intro = "#{img_tag(app_icon)}📲 You can test the changes from this Pull Request in <b>#{CGI.escape_html(app_display_name)}</b> by scanning the QR code below to install the corresponding build."
         metadata_rows = metadata.compact.map { |key, value| "<tr><td><b>#{key}</b></td><td>#{value}</td></tr>" }
-        intro = "#{icon_img_tag}📲 You can test the changes from this Pull Request in <b>#{app_display_name}</b> by scanning the QR code below to install the corresponding build."
-        footnote = params[:footnote] || (app_center_info.org_name.nil? ? '' : DEFAULT_APP_CENTER_FOOTNOTE)
-        body = <<~COMMENT_BODY
+        footnote = params[:footnote]
+        footnote ||= DEFAULT_FOOTNOTE if !release_info.nil? || (download_url && is_firebase_url?(download_url))
+
+        body = <<~COMMENT_BODY.chomp('')
           <table>
           <tr>
             <td rowspan='#{metadata_rows.count + 1}' width='260px'><img src='#{qr_code_url}' width='250' height='250' /></td>
-            <td><b>App Name</b></td><td>#{icon_img_tag} #{app_display_name}</td>
+            <td><b>App Name</b></td><td>#{CGI.escape_html(app_display_name)}</td>
           </tr>
           #{metadata_rows.join("\n")}
           </table>
@@ -28,9 +37,9 @@ module Fastlane
         COMMENT_BODY
 
         if params[:fold]
-          "<details><summary>#{intro}</summary>\n#{body}</details>\n"
+          "<details><summary>#{intro}</summary>\n#{body}\n</details>\n"
         else
-          "<p>#{intro}</p>\n#{body}"
+          "<p>#{intro}</p>\n#{body}\n"
         end
       end
 
@@ -40,76 +49,126 @@ module Fastlane
 
       NO_INSTALL_URL_ERROR_MESSAGE = <<~NO_URL_ERROR
         No URL provided to download or install the app.
-         - Either use this action right after using `appcenter_upload` and provide an `app_center_org_name` (so that this action can use the link to the App Center build)
+         - Either use this action right after using `firebase_app_distribution` so this action can extract the download URL from the `lane_context`
          - Or provide an explicit value for the `download_url` parameter
       NO_URL_ERROR
 
-      DEFAULT_APP_CENTER_FOOTNOTE = '<em>Automatticians: You can use our internal self-serve MC tool to give yourself access to App Center if needed.</em>'
+      DEFAULT_FOOTNOTE = '<em>Automatticians: You can use our internal self-serve MC tool to give yourself access to those builds if needed.</em>'
 
-      # A small model struct to consolidate and pack all the values related to App Center
+      # Parse and validate a URL string
+      #
+      # @param [String] url The URL string to parse and validate
+      # @return [URI] The parsed URI object
+      # @raise [FastlaneCore::Interface::FastlaneError] if the URL is invalid
       #
-      AppCenterInfo = Struct.new(:org_name, :app_name, :display_name, :release_id, :icon, :version, :short_version, :os, :bundle_id) do
-        # A method to construct an AppCenterInfo instance from the action params, and infer the rest from the `lane_context` if available
-        def self.from_params(params)
-          org_name = params[:app_center_org_name]
-          ctx = if org_name && defined?(SharedValues::APPCENTER_BUILD_INFORMATION)
-                  Fastlane::Actions.lane_context[SharedValues::APPCENTER_BUILD_INFORMATION] || {}
-                else
-                  {}
-                end
-          app_name = params[:app_center_app_name] || ctx['app_name']
+      def self.parse_url!(url)
+        URI.parse(url).tap do |uri|
+          raise URI::InvalidURIError unless uri.is_a?(URI::HTTP) || uri.is_a?(URI::HTTPS)
+        end
+      rescue URI::InvalidURIError
+        UI.user_error!("Invalid URL: #{url}")
+      end
+
+      # A small model/struct representing values exposed by Firebase App Distribution for a given release
+      #
+      FirebaseReleaseInfo = Struct.new(:display_version, :build_version, :testing_url, :os, :bundle_id, :release_id, keyword_init: true) do
+        def self.from_lane_context
+          return nil unless defined?(SharedValues::FIREBASE_APP_DISTRO_RELEASE)
+
+          ctx = Fastlane::Actions.lane_context[SharedValues::FIREBASE_APP_DISTRO_RELEASE]
+          return nil if ctx.nil?
+
+          # Extract platform info from Firebase Console URI
+          if ctx[:firebaseConsoleUri]
+            uri = URI(ctx[:firebaseConsoleUri])
+            os, bundle_id, release_id = uri.path.match(%r{project/.*/appdistribution/app/([^:]*):([^/]*)/releases/(.*)})&.captures
+          end
+
           new(
-            org_name,
-            app_name,
-            ctx['app_display_name'] || app_name,
-            params[:app_center_release_id] || ctx['id'],
-            ctx['app_icon_url'],
-            ctx['version'],
-            ctx['short_version'],
-            ctx['app_os'],
-            ctx['bundle_identifier']
+            display_version: ctx[:displayVersion],
+            build_version: ctx[:buildVersion],
+            testing_url: ctx[:testingUri],
+            os: os,
+            bundle_id: bundle_id,
+            release_id: release_id
           )
         end
       end
 
-      # Builds the installation link, QR code URL and extra metadata for download links from the available info
+      # Constructs the Hash of metadata, based on the explicit ones passed by the user as parameter + the implicit ones from `FirebaseReleaseInfo`
+      #
+      # @param [Hash<Symbol, Any>] params The action's parameters, as received by `self.run`
+      # @param [FirebaseReleaseInfo?] release_info The information about the Firebase Release extracted from the `lane_context`
+      # @return [Hash<String, String>] A hash of all the metadata, consolidated from both the explicit and the implicit ones
+      #
+      def self.generate_metadata_hash(params:, release_info:)
+        # Add explicit metadata provided by the caller
+        metadata = params[:metadata]&.transform_keys(&:to_s) || {}
+
+        # Add Firebase-specific metadata if available
+        unless release_info.nil?
+          metadata['Build Number'] ||= "<code>#{release_info.build_version}</code>"
+          metadata['Version'] ||= "<code>#{release_info.display_version}</code>"
+          metadata[release_info.os == 'ios' ? 'Bundle ID' : 'Application ID'] ||= "<code>#{release_info.bundle_id}</code>"
+        end
+
+        # Add git metadata
+        metadata['Commit'] ||= ENV.fetch('BUILDKITE_COMMIT', nil) || other_action.last_git_commit[:abbreviated_commit_hash]
+        metadata
+      end
+
+      # Constructs the installation link, QR code URL and extra metadata for download links from the available info
       #
-      # @param [AppCenterInfo] app_center_info The struct containing all the values related to App Center info
-      # @param [String] download_url The `download_url` parameter passed to the action, if one exists
+      # @param [FirebaseReleaseInfo?] release_info The information about the Firebase Release extracted from the `lane_context`
+      # @param [String] download_url The `download_url` parameter passed to the action, if one was provided
       # @return [(String, Hash<String,String>)] A tuple containing:
       #   - The URL for the QR Code
       #   - A Hash of the extra metadata key/value pairs to add to the existing metadata, to enrich them with download/install links
+      # @raise [FastlaneCore::Interface::FastlaneError] if no valid installation URL could be determined
       #
-      def self.build_install_links(app_center_info, download_url)
+      def self.install_links(release_info:, download_url:)
         install_url = nil
         extra_metadata = {}
+        firebase_release_id = nil
+
+        # Validate and process direct download URL if provided
         if download_url
+          uri = parse_url!(download_url)
           install_url = download_url
-          extra_metadata['Direct Download'] = "<a href='#{install_url}'><code>#{File.basename(install_url)}</code></a>"
+
+          if is_firebase_url?(uri)
+            firebase_release_id = File.basename(uri.path)
+          else
+            filename = File.basename(uri.path)
+            extra_metadata['Direct Download'] = "<a href='#{CGI.escape_html(install_url)}'><code>#{CGI.escape_html(filename)}</code></a>"
+          end
         end
-        if app_center_info.org_name && app_center_info.app_name
-          install_url = "https://install.appcenter.ms/orgs/#{app_center_info.org_name}/apps/#{app_center_info.app_name}/releases/#{app_center_info.release_id}"
-          extra_metadata['App Center Build'] = "<a href='#{install_url}'>#{app_center_info.display_name} ##{app_center_info.release_id}</a>"
+
+        # Process Firebase testing URL if available from release_info
+        if release_info&.testing_url
+          install_url = release_info.testing_url
+          firebase_release_id = release_info.release_id
         end
+
         UI.user_error!(NO_INSTALL_URL_ERROR_MESSAGE) if install_url.nil?
+
+        # Add Installation URL metadata if we have a release_id
+        extra_metadata['Installation URL'] = "<a href='#{CGI.escape_html(install_url)}'>#{CGI.escape_html(firebase_release_id)}</a>" if firebase_release_id
+
+        # Generate QR code URL with proper escaping
         qr_code_url = "https://api.qrserver.com/v1/create-qr-code/?size=500x500&qzone=4&data=#{CGI.escape(install_url)}"
         [qr_code_url, extra_metadata]
       end
 
-      # A method to build the Hash of metadata, based on the explicit ones passed by the user as parameter + the implicit ones from `AppCenterInfo`
+      # Determines if a given URI is a Firebase App Distribution URL
       #
-      # @param [Hash<Symbol, Any>] params The action's parameters, as received by `self.run`
-      # @param [AppCenterInfo] app_center_info The model object containing all the values related to App Center information
-      # @return [Hash<String, String>] A hash of all the metadata, gathered from both the explicit and the implicit ones
+      # @param [String, URI] url The URL to check, either as a String or an already-parsed URI
+      # @return [Boolean] true if the URL is a Firebase App Distribution URL
+      # @raise [FastlaneCore::Interface::FastlaneError] if the URL is invalid
       #
-      def self.consolidate_metadata(params, app_center_info)
-        metadata = params[:metadata]&.transform_keys(&:to_s) || {}
-        metadata['Build Number'] ||= app_center_info.version
-        metadata['Version'] ||= app_center_info.short_version
-        metadata[app_center_info.os == 'Android' ? 'Application ID' : 'Bundle ID'] ||= app_center_info.bundle_id
-        # (Feel free to add more CI-specific env vars in the line below to support other CI providers if you need)
-        metadata['Commit'] ||= ENV.fetch('BUILDKITE_COMMIT', nil) || other_action.last_git_commit[:abbreviated_commit_hash]
-        metadata
+      def self.is_firebase_url?(url)
+        uri = url.is_a?(URI) ? url : parse_url!(url)
+        uri.host == 'appdistribution.firebase.google.com' && uri.path.start_with?('/testerapps/')
       end
 
       # Creates an HTML `<img>` tag for an icon URL or the image URL to represent a given Buildkite emoji
@@ -117,19 +176,19 @@ module Fastlane
       # @param [String] url_or_emoji A `String` which can be:
       #  - Either a valid URI to an image
       #  - Or a string formatted like `:emojiname:`, using a valid Buildite emoji name as defined in https://github.com/buildkite/emojis
-      # @param [String] alt The alt text to use for the `<img>` tag
       # @return [String] The `<img …>` tag with the proper image and alt tag
+      # @raise [FastlaneCore::Interface::FastlaneError] if the URL is invalid
       #
-      def self.img_tag(url_or_emoji, alt: '')
+      def self.img_tag(url_or_emoji)
         return nil if url_or_emoji.nil?
 
         emoji = url_or_emoji.match(/:(.*):/)&.captures&.first
         app_icon_url = if emoji
                          "https://raw.githubusercontent.com/buildkite/emojis/main/img-buildkite-64/#{emoji}.png"
-                       elsif URI(url_or_emoji)
-                         url_or_emoji
+                       else
+                         url_or_emoji.tap { parse_url!(url_or_emoji) }
                        end
-        app_icon_url ? "<img alt='#{alt}' align='top' src='#{app_icon_url}' width='20px' />" : ''
+        app_icon_url ? "<img align='top' src='#{app_icon_url}' width='20px' alt='App Icon' />" : ''
       end
 
       #####################################################
@@ -145,98 +204,72 @@ module Fastlane
           Generates a string providing all the details of a prototype build, nicely-formatted as HTML.
           The returned string will typically be subsequently used by the `comment_on_pr` action to post that HTML as comment on a PR.
 
-          If you used the `appcenter_upload` lane (to upload the Prototype build to App Center) before calling this action, and pass
-          a value to the `app_center_org_name` parameter, then many of the parameters and metadata will be automatically extracted
-          from the `lane_context` provided by `appcenter_upload`, including:
+          If you used the `firebase_app_distribution` action (to upload the Prototype build to Firebase App Distribution) before calling this action,
+          then many of the metadata will be automatically extracted from the `lane_context` it exposed:
 
-           - The `app_center_app_name`, `app_center_release_id` and installation URL to use for the QR code to point to that release in App Center
-           - The `app_icon`
-           - The app's Build Number / versionCode
-           - The app's Version / versionName
-           - The app's Bundle ID / Application ID
-           - A `footnote` mentioning the MC tool for Automatticians to add themselves to App Center
+          - "Version" (from `:displayVersion`) and "Build Number" (from `:buildVersion`)
+          - "Bundle ID" (extracted from `:firebaseConsoleUri`)
+          - "Commit" (from `BUILDKITE_COMMIT` environment variable or last git commit)
+          - "Installation URL" (from `:testingUri`)
 
-          This means that if you are using App Center to distribute your Prototype Build, the only parameters you *have* to provide
-          to this action are `app_display_name` and `app_center_org_name`; plus, for `metadata` most of the interesting values will already be pre-filled.
+          You can also pass additional metadata to this action via the `metadata` parameter, and they will also be included in the HTML table of the comment.
 
-          Any of those implicit default values/metadata can of course be overridden by passing an explicit value to the appropriate parameter(s).
+          This means that if you are using Firebase App Distribution to distribute your Prototype Build, the can just provide
+          `app_display_name` and optionally `app_icon`, and the rest will be automatically inferred from the `lane_context`.
+
+          If you are not using Firebase App Distribution, you can pass an explicit value for the `download_url` parameter,
+          and the action will use it to generate the installation link and QR code.
         DESC
       end
 
       def self.available_options
-        app_center_auto = '(will be automatically extracted from `lane_context if you used `appcenter_upload` to distribute your Prototype build)'
         [
           FastlaneCore::ConfigItem.new(
             key: :app_display_name,
-            env_name: 'FL_PROTOTYPE_BUILD_DETAILS_COMMENT_APP_DISPLAY_NAME',
             description: 'The display name to use for the app in the comment message',
             optional: false,
             type: String
           ),
-          FastlaneCore::ConfigItem.new(
-            key: :app_center_org_name,
-            env_name: 'APPCENTER_OWNER_NAME', # Intentionally the same as the one used by the `appcenter_upload` action
-            description: 'The name of the organization in App Center (if you used `appcenter_upload` to distribute your Prototype build)',
-            type: String,
-            optional: true
-          ),
-          FastlaneCore::ConfigItem.new(
-            key: :app_center_app_name,
-            env_name: 'APPCENTER_APP_NAME', # Intentionally the same as the one used by the `appcenter_upload` action
-            description: "The name of the app in App Center #{app_center_auto}",
-            type: String,
-            optional: true,
-            default_value_dynamic: true # As it will be extracted from the `lane_context`` if you used `appcenter_upload``
-          ),
-          FastlaneCore::ConfigItem.new(
-            key: :app_center_release_id,
-            env_name: 'APPCENTER_RELEASE_ID',
-            description: "The release ID/Number in App Center #{app_center_auto}",
-            type: String,
-            optional: true,
-            default_value_dynamic: true # As it will be extracted from the `lane_context`` if you used `appcenter_upload``
-          ),
           FastlaneCore::ConfigItem.new(
             key: :app_icon,
-            env_name: 'FL_PROTOTYPE_BUILD_DETAILS_COMMENT_APP_ICON',
-            description: "The name of an emoji from the https://github.com/buildkite/emojis list or the full image URL to use for the icon of the app in the message. #{app_center_auto}",
+            description: 'The name of an emoji from the https://github.com/buildkite/emojis list or the full image URL to use for the icon of the app in the message',
             type: String,
             optional: true,
-            default_value_dynamic: true # As it will be extracted from the `lane_context`` if you used `appcenter_upload``
+            default_value_dynamic: true # Defaults to `:firebase:` only if `firebase_app_distribution` was used
           ),
           FastlaneCore::ConfigItem.new(
             key: :download_url,
-            env_name: 'FL_PROTOTYPE_BUILD_DETAILS_COMMENT_DOWNLOAD_URL',
-            description: 'The URL to download the build as a direct download. ' \
-             + 'If you uploaded the build to App Center, we recommend leaving this nil (the comment will use the URL to the App Center build for the QR code)',
+            description: <<~DESC,
+              The URL to use to download/install the build.
+              - If you used `firebase_app_distribution` to upload the build during the same `fastlane` run, you should leave this nil
+              - If you used `firebase_app_distribution` during a separate CI job, you can store the `:testingUri` of that call's returned hash (in e.g. Buildkite metadata), then pass that URI to this parameter
+              - Otherwise, you can provide a direct download URL for the build (e.g. link to Cloudfront or AppsCDN URL)
+            DESC
             type: String,
             optional: true,
             default_value: nil
           ),
           FastlaneCore::ConfigItem.new(
             key: :fold,
-            env_name: 'FL_PROTOTYPE_BUILD_DETAILS_COMMENT_FOLD',
             description: 'If true, will wrap the HTML table inside a <details> block (hidden by default)',
             type: Boolean,
             default_value: false
           ),
           FastlaneCore::ConfigItem.new(
             key: :metadata,
-            env_name: 'FL_PROTOTYPE_BUILD_DETAILS_COMMENT_METADATA',
             description: 'All additional metadata (as key/value pairs) you want to include in the HTML table of the comment. ' \
-             + 'If you are running this action after `appcenter_upload`, some metadata will automatically be added to this list too',
+             + 'If you are running this action after `firebase_app_distribution`, some metadata will automatically be added and merged with this list',
             type: Hash,
             optional: true,
-            default_value_dynamic: true # As some metadata will be auto-filled if you used `appcenter_upload`
+            default_value_dynamic: true # As some metadata will be auto-filled if you used `firebase_app_distribution`
           ),
           FastlaneCore::ConfigItem.new(
             key: :footnote,
-            env_name: 'FL_PROTOTYPE_BUILD_DETAILS_COMMENT_FOOTNOTE',
             description: 'Optional footnote to add below the HTML table of the comment. ' \
-             + 'If you are running this action after `appcenter_upload`, a default footnote for Automatticians will be used unless you provide an explicit value',
+             + 'If you are running this action after `firebase_app_distribution`, a default footnote for Automatticians will be used unless you provide an explicit value',
             type: String,
             optional: true,
-            default_value_dynamic: true # We have a default footnote for the case when you used App Center
+            default_value_dynamic: true # We have a default footnote for the case when you used Firebase App Distribution
           ),
         ]
       end

data/lib/fastlane/plugin/wpmreleasetoolkit/actions/common/upload_build_to_apps_cdn.rb

@@ -0,0 +1,320 @@
+# frozen_string_literal: true
+
+require 'fastlane/action'
+require 'net/http'
+require 'uri'
+require 'json'
+
+module Fastlane
+  module Actions
+    module SharedValues
+      APPS_CDN_UPLOADED_FILE_URL = :APPS_CDN_UPLOADED_FILE_URL
+      APPS_CDN_UPLOADED_FILE_ID = :APPS_CDN_UPLOADED_FILE_ID
+      APPS_CDN_UPLOADED_POST_ID = :APPS_CDN_UPLOADED_POST_ID
+      APPS_CDN_UPLOADED_POST_URL = :APPS_CDN_UPLOADED_POST_URL
+    end
+
+    class UploadBuildToAppsCdnAction < Action
+      RESOURCE_TYPE = 'Build'
+      VALID_POST_STATUS = %w[publish draft].freeze
+      VALID_BUILD_TYPES = %w[Alpha Beta Nightly Production Prototype].freeze
+      VALID_PLATFORMS = ['Android', 'iOS', 'Mac - Silicon', 'Mac - Intel', 'Mac - Any', 'Windows'].freeze
+
+      def self.run(params)
+        UI.message('Uploading build to Apps CDN...')
+
+        file_path = params[:file_path]
+        UI.user_error!("File not found at path '#{file_path}'") unless File.exist?(file_path)
+
+        api_endpoint = "https://public-api.wordpress.com/rest/v1.1/sites/#{params[:site_id]}/media/new"
+        uri = URI.parse(api_endpoint)
+
+        # Create the request body and headers
+        parameters = {
+          product: params[:product],
+          build_type: params[:build_type],
+          visibility: params[:visibility].to_s.capitalize,
+          platform: params[:platform],
+          resource_type: RESOURCE_TYPE,
+          version: params[:version],
+          build_number: params[:build_number], # Optional: may be nil
+          minimum_system_version: params[:minimum_system_version], # Optional: may be nil
+          post_status: params[:post_status], # Optional: may be nil
+          release_notes: params[:release_notes], # Optional: may be nil
+          error_on_duplicate: params[:error_on_duplicate] # defaults to false
+        }.compact
+        request_body, content_type = build_multipart_request(parameters: parameters, file_path: file_path)
+
+        # Create and send the HTTP request
+        request = Net::HTTP::Post.new(uri.request_uri)
+        request.body = request_body
+        request['Content-Type'] = content_type
+        request['Accept'] = 'application/json'
+        request['Authorization'] = "Bearer #{params[:api_token]}"
+
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
+          http.request(request)
+        end
+
+        # Handle the response
+        case response
+        when Net::HTTPSuccess
+          result = parse_successful_response(response.body)
+
+          Actions.lane_context[SharedValues::APPS_CDN_UPLOADED_POST_ID] = result[:post_id]
+          Actions.lane_context[SharedValues::APPS_CDN_UPLOADED_POST_URL] = result[:post_url]
+          Actions.lane_context[SharedValues::APPS_CDN_UPLOADED_FILE_ID] = result[:media_id]
+          Actions.lane_context[SharedValues::APPS_CDN_UPLOADED_FILE_URL] = result[:media_url]
+
+          UI.success('Build successfully uploaded to Apps CDN')
+          UI.message("Post ID: #{result[:post_id]}")
+          UI.message("Post URL: #{result[:post_url]}")
+
+          result
+        else
+          UI.error("Failed to upload build to Apps CDN: #{response.code} #{response.message}")
+          UI.error(response.body)
+          UI.user_error!('Upload to Apps CDN failed')
+        end
+      end
+
+      # Builds a multipart request body for the WordPress.com Media API
+      #
+      # @param parameters [Hash] The parameters to include in the request as top-level form fields
+      # @param file_path [String] The path to the file to upload
+      # @return [Array] An array containing the request body and the content-type header
+      #
+      def self.build_multipart_request(parameters:, file_path:)
+        boundary = "----WebKitFormBoundary#{SecureRandom.hex(10)}"
+        content_type = "multipart/form-data; boundary=#{boundary}"
+        post_body = []
+
+        # Add the file first
+        post_body << "--#{boundary}"
+        post_body << "Content-Disposition: form-data; name=\"media[]\"; filename=\"#{File.basename(file_path)}\""
+        post_body << 'Content-Type: application/octet-stream'
+        post_body << ''
+        post_body << File.binread(file_path)
+
+        # Add each parameter as a separate form field
+        parameters.each do |key, value|
+          post_body << "--#{boundary}"
+          post_body << "Content-Disposition: form-data; name=\"#{key}\""
+          post_body << ''
+          post_body << value.to_s
+        end
+
+        # Add the closing boundary
+        post_body << "--#{boundary}--"
+
+        [post_body.join("\r\n"), content_type]
+      end
+
+      # Parse the successful response and return a hash with the upload details
+      #
+      # @param response_body [String] The raw response body from the API
+      # @return [Hash] A hash containing the upload details
+      def self.parse_successful_response(response_body)
+        json_response = JSON.parse(response_body)
+        media = json_response['media'].first
+        media_id = media['ID']
+        media_url = media['URL']
+        post_id = media['post_ID']
+
+        # Compute the post URL using the same base URL as media_url
+        post_url = URI.parse(media_url)
+        post_url.path = '/'
+        post_url.query = "p=#{post_id}"
+        post_url = post_url.to_s
+
+        {
+          post_id: post_id,
+          post_url: post_url,
+          media_id: media_id,
+          media_url: media_url,
+          mime_type: media['mime_type']
+        }
+      end
+
+      def self.description
+        'Uploads a build binary to the Apps CDN'
+      end
+
+      def self.authors
+        ['Automattic']
+      end
+
+      def self.return_value
+        'Returns a Hash containing the upload result: { post_id:, post_url:, media_id:, media_url:, mime_type: }. On error, raises a FastlaneError.'
+      end
+
+      def self.details
+        <<~DETAILS
+          Uploads a build binary file to a WordPress blog that has the Apps CDN plugin enabled.
+          See PCYsg-15tP-p2 internal a8c documentation for details about the Apps CDN plugin.
+        DETAILS
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(
+            key: :site_id,
+            env_name: 'APPS_CDN_SITE_ID',
+            description: 'The WordPress.com CDN site ID to upload the media to',
+            optional: false,
+            type: String,
+            verify_block: proc do |value|
+              UI.user_error!('Site ID cannot be empty') if value.to_s.empty?
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :product,
+            env_name: 'APPS_CDN_PRODUCT',
+            # Valid values can be found at https://github.a8c.com/Automattic/wpcom/blob/trunk/wp-content/lib/a8c/cdn/src/enums/enum-product.php
+            description: 'The product the build belongs to (e.g. \'WordPress.com Studio\')',
+            optional: false,
+            type: String,
+            verify_block: proc do |value|
+              UI.user_error!('Product cannot be empty') if value.to_s.empty?
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :platform,
+            env_name: 'APPS_CDN_PLATFORM',
+            # Valid values can be found at https://github.a8c.com/Automattic/wpcom/blob/trunk/wp-content/lib/a8c/cdn/src/enums/enum-platform.php
+            description: "The platform the build runs on. One of: #{VALID_PLATFORMS.join(', ')}",
+            optional: false,
+            type: String,
+            verify_block: proc do |value|
+              UI.user_error!('Platform cannot be empty') if value.to_s.empty?
+              UI.user_error!("Platform must be one of: #{VALID_PLATFORMS.join(', ')}") unless VALID_PLATFORMS.include?(value)
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :file_path,
+            description: 'The path to the build file to upload',
+            optional: false,
+            type: String,
+            verify_block: proc do |value|
+              UI.user_error!("File not found at path '#{value}'") unless File.exist?(value)
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :build_type,
+            # Valid values can be found at https://github.a8c.com/Automattic/wpcom/blob/trunk/wp-content/lib/a8c/cdn/src/enums/enum-build-type.php
+            description: "The type of the build. One of: #{VALID_BUILD_TYPES.join(', ')}",
+            optional: false,
+            type: String,
+            verify_block: proc do |value|
+              UI.user_error!('Build type cannot be empty') if value.to_s.empty?
+              UI.user_error!("Build type must be one of: #{VALID_BUILD_TYPES.join(', ')}") unless VALID_BUILD_TYPES.include?(value)
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :visibility,
+            description: 'The visibility of the build (:internal or :external)',
+            optional: false,
+            type: Symbol,
+            verify_block: proc do |value|
+              UI.user_error!('Visibility must be either :internal or :external') unless %i[internal external].include?(value)
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :post_status,
+            description: 'The post status (defaults to \'publish\')',
+            optional: true,
+            default_value: 'publish',
+            type: String,
+            verify_block: proc do |value|
+              UI.user_error!("Post status must be one of: #{VALID_POST_STATUS.join(', ')}") unless VALID_POST_STATUS.include?(value)
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :version,
+            description: 'The version string for the build (e.g. \'20.0\', \'17.8.1\')',
+            optional: false,
+            type: String,
+            verify_block: proc do |value|
+              UI.user_error!('Version cannot be empty') if value.to_s.empty?
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :build_number,
+            description: 'The build number for the build (e.g. \'42\')',
+            optional: true,
+            type: String
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :minimum_system_version,
+            description: 'The minimum version for the provided platform (e.g. \'13.0\' for macOS Ventura)',
+            optional: true,
+            type: String
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :release_notes,
+            description: 'The release notes to show with the build on the blog frontend',
+            optional: true,
+            type: String
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :error_on_duplicate,
+            description: 'If true, the action will error if a build matching the same metadata already exists. If false, any potential existing build matching the same metadata will be updated to replace the build with the new file',
+            default_value: false,
+            type: Boolean
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :api_token,
+            env_name: 'WPCOM_API_TOKEN',
+            description: 'The WordPress.com API token for authentication',
+            optional: false,
+            type: String,
+            verify_block: proc do |value|
+              UI.user_error!('API token cannot be empty') if value.to_s.empty?
+            end
+          ),
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.output
+        [
+          ['APPS_CDN_UPLOADED_FILE_URL', 'The URL of the uploaded file'],
+          ['APPS_CDN_UPLOADED_FILE_ID', 'The ID of the uploaded file'],
+          ['APPS_CDN_UPLOADED_POST_ID', 'The ID of the post / page created for the uploaded build'],
+          ['APPS_CDN_UPLOADED_POST_URL', 'The URL of the post / page created for the uploaded build'],
+        ]
+      end
+
+      def self.example_code
+        [
+          'upload_build_to_apps_cdn(
+            site_id: "12345678",
+            api_token: ENV["WPCOM_API_TOKEN"],
+            product: "WordPress.com Studio",
+            build_type: "Beta",
+            visibility: :internal,
+            platform: "Mac - Any",
+            version: "20.0",
+            build_number: "42",
+            file_path: "path/to/app.zip"
+          )',
+          'upload_build_to_apps_cdn(
+            site_id: "12345678",
+            api_token: ENV["WPCOM_API_TOKEN"],
+            product: "WordPress.com Studio",
+            build_type: "Beta",
+            visibility: :external,
+            platform: "Android",
+            version: "20.0",
+            build_number: "42",
+            file_path: "path/to/app.apk",
+            error_on_duplicate: true
+          )',
+        ]
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/helper/android/android_localize_helper.rb

@@ -342,7 +342,10 @@ module Fastlane
         #
         def self.post_process_xml!(translated_xml, locale_code:, original_xml:)
           copy_orig_attributes = lambda do |node, xpath|
-            orig_attributes = original_xml.xpath(xpath)&.first&.attribute_nodes&.to_h do |attr|
+            found_node = original_xml.xpath(xpath)&.first
+            return unless found_node
+
+            orig_attributes = found_node.attribute_nodes&.to_h do |attr|
               [[attr.namespace&.prefix, attr.name].compact.join(':'), attr.value]
             end
             orig_attributes&.each { |k, v| node[k] = v unless k == 'name' }

data/lib/fastlane/plugin/wpmreleasetoolkit/helper/buildkite_aware_log_groups.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'fastlane'
+
+# This monkey-patch adds Buildkite-aware logs to fastlane so it generates a collapsible log group in Buildkite for each action execution.
+#
+# @env `FASTLANE_DISABLE_ACTIONS_BUILDKITE_LOG_GROUPS`
+#     Set this variable to '1' to disable the auto-application of the monkey patch.
+
+unless !ENV.key?('BUILDKITE') || FastlaneCore::Env.truthy?('FASTLANE_DISABLE_ACTIONS_BUILDKITE_LOG_GROUPS')
+  FastlaneCore::UI.verbose('Monkey-patching fastlane to add Buildkite-aware log groups for each action execution')
+
+  module Fastlane
+    module Actions
+      module SharedValues
+        # This differs from the existing `SharedValues::LANE_NAME`, which always contains the name of the **top-level** lane
+        CURRENTLY_RUNNING_LANE_NAME = :CURRENTLY_RUNNING_LANE_NAME
+      end
+
+      module BuildkiteLogActionsAsCollapsibleGroups
+        def execute_action(action_name, &)
+          unless %w[is_ci? is_ci].include?(action_name)
+            current_lane = lane_context[SharedValues::CURRENTLY_RUNNING_LANE_NAME]
+            lane_name_prefix = (current_lane || '').empty? ? '' : "[lane :#{current_lane}]"
+            puts "~~~ :fastlane: #{lane_name_prefix} #{action_name}"
+          end
+          super
+        end
+      end
+
+      class << self
+        prepend BuildkiteLogActionsAsCollapsibleGroups
+      end
+    end
+
+    class Runner
+      prepend(Module.new do
+        def current_lane=(lane_name)
+          super
+          Fastlane::Actions.lane_context[Fastlane::Actions::SharedValues::CURRENTLY_RUNNING_LANE_NAME] = lane_name
+        end
+      end)
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/helper/ios/ios_adc_app_sizes_helper.rb

@@ -54,7 +54,7 @@ module Fastlane
           csv = "Version\t#{devices.join("\t")}\n"
           app_sizes.each do |details|
             build_number = details['cfBundleVersion']
-            sizes = details['sizesInBytes'].select { |name, _| devices.include?(name) }
+            sizes = details['sizesInBytes'].slice(*devices)
             csv += "#{build_number}\t" + devices.map { |d| sz(sizes[d]['compressed']) }.join("\t") + "\n"
           end
           csv
@@ -64,7 +64,7 @@ module Fastlane
           devices = DEFAULT_DEVICES if devices.nil? || devices.empty?
           app_sizes.map do |details|
             build_number = details['cfBundleVersion']
-            sizes = details['sizesInBytes'].select { |name, _| devices.include?(name) }
+            sizes = details['sizesInBytes'].slice(*devices)
             col_size = devices.map(&:length).max
             table = "| #{build_number.ljust(col_size)} | Download | Install  |\n"
             table += "|:#{'-' * col_size}-|---------:|---------:|\n"

data/lib/fastlane/plugin/wpmreleasetoolkit/helper/ios/ios_strings_file_validation_helper.rb

@@ -65,10 +65,10 @@ module Fastlane
         # Inspects the given `.strings` file for duplicated keys, returning them if any.
         #
         # @param [String] file The path to the file to inspect.
-        # @return [Hash<String, Array<Int>] Hash with the dublipcated keys.
+        # @return [Hash<String, Array<Int>] Hash with the duplicated keys.
         #         Each element has the duplicated key (from the `.strings`) as key and an array of line numbers where the key occurs as value.
         def self.find_duplicated_keys(file:)
-          keys_with_lines = Hash.new([])
+          keys_with_lines = Hash.new { |h, k| h[k] = [] }
 
           state = State.new(context: :root, buffer: StringIO.new, in_escaped_ctx: false, found_key: nil)
 

data/lib/fastlane/plugin/wpmreleasetoolkit/version.rb

@@ -2,6 +2,6 @@
 
 module Fastlane
   module Wpmreleasetoolkit
-    VERSION = '12.5.0'
+    VERSION = '13.1.0'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-wpmreleasetoolkit
 version: !ruby/object:Gem::Version
-  version: 12.5.0
+  version: 13.1.0
 platform: ruby
 authors:
 - Automattic
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-02-19 00:00:00.000000000 Z
+date: 2025-03-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -431,6 +431,7 @@ files:
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/common/set_branch_protection_action.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/common/set_milestone_frozen_marker_action.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/common/update_assigned_milestone_action.rb
+- lib/fastlane/plugin/wpmreleasetoolkit/actions/common/upload_build_to_apps_cdn.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/common/upload_to_s3.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/configure/configure_add_files_to_copy_action.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/configure/configure_apply_action.rb
@@ -456,6 +457,7 @@ files:
 - lib/fastlane/plugin/wpmreleasetoolkit/helper/android/android_tools_path_helper.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/helper/android/android_version_helper.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/helper/app_size_metrics_helper.rb
+- lib/fastlane/plugin/wpmreleasetoolkit/helper/buildkite_aware_log_groups.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/helper/ci_helper.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/helper/configure_helper.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/helper/encryption_helper.rb