fastlane-plugin-wpmreleasetoolkit 11.0.2 → 11.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1a01dbbf909c6d6ae5a683e4d4261e44ef7dda1f9b896e0f49529de45ffb8c58
-  data.tar.gz: 5b6343174100d8167d85b7a31fe2484988877eb249d4ee527469fc025d201a26
+  metadata.gz: 1f9d86b44058a8ff2f28f2c56bdb81230395e36eac41f6e4d0761140f9694177
+  data.tar.gz: cc234c6029919a63d4d9ed2114d390bb58ad79e67f7ae1650e94b23cfac92bc9
 SHA512:
-  metadata.gz: 10035929825ca4d666f3a75d184feba49720233b0a57a0e00ac7f9cf92097f332f2554a3e9f811ebdb5dda83a9d6b750dc22568bf3cddd992509f12ca551ee2b
-  data.tar.gz: 0a67262b02fbf58244a5c779a6e517a27aa869c2e872c10f298a4c2621837e46206a78e4ec4c292df5f2086eb02054ea86470062435c7683f44a1a97bf278aec
+  metadata.gz: e2e86d40c624300445ddc600e19b8b16a560e86725c82344719bbbadb69ad0c1552fff4f951cdb5411d892973fa37b524b47bcc99b0d14a23bff56607d44f676
+  data.tar.gz: faf08e93483cced02d83d705b9cff2843e07244c708312bdf8dfb86131b2990d4e5ba94397aa71aadd8a3cb6d485da2007b5743950e15486ff81243f8a956b35

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

@@ -0,0 +1,215 @@
+require 'fastlane/action'
+require_relative '../../helper/github_helper'
+
+module Fastlane
+  module Actions
+    class CreateReleaseBackmergePullRequestAction < Action
+      DEFAULT_BRANCH = 'trunk'.freeze
+
+      def self.run(params)
+        token = params[:github_token]
+        repository = params[:repository]
+        source_branch = params[:source_branch]
+        default_branch = params[:default_branch]
+        target_branches = params[:target_branches]
+        labels = params[:labels]
+        milestone_title = params[:milestone_title]
+        reviewers = params[:reviewers]
+        team_reviewers = params[:team_reviewers]
+        intermediate_branch_created_callback = params[:intermediate_branch_created_callback]
+
+        if target_branches.include?(source_branch)
+          UI.user_error!('`target_branches` must not contain `source_branch`')
+        end
+
+        github_helper = Fastlane::Helper::GithubHelper.new(github_token: params[:github_token])
+        target_milestone = milestone_title.nil? ? nil : github_helper.get_milestone(repository, milestone_title)
+
+        final_target_branches = if target_branches.empty?
+                                  unless source_branch.start_with?('release/')
+                                    UI.user_error!('`source_branch` must start with `release/`')
+                                  end
+
+                                  determine_target_branches(source_release_version: source_branch.delete('release/'), default_branch: default_branch)
+                                else
+                                  target_branches
+                                end
+
+        final_target_branches.map do |target_branch|
+          Fastlane::Helper::GitHelper.checkout_and_pull(source_branch)
+
+          create_backmerge_pr(
+            token: token,
+            repository: repository,
+            title: "Merge #{source_branch} into #{target_branch}",
+            head_branch: source_branch,
+            base_branch: target_branch,
+            labels: labels,
+            milestone: target_milestone&.number,
+            reviewers: reviewers,
+            team_reviewers: team_reviewers,
+            intermediate_branch_created_callback: intermediate_branch_created_callback
+          )
+        end.compact
+      end
+
+      # Determines the target branches for a release version.
+      #
+      # @param source_release_version [String] the source release version to compare against other release branches.
+      # @param default_branch [String] the default branch to use if no target branches are found.
+      # @return [Array<String>] the list of target branches greater than the release version.
+      def self.determine_target_branches(source_release_version:, default_branch:)
+        release_branches = Actions.sh('git', 'branch', '-r', '-l', 'origin/release/*').strip.split("\n")
+
+        all_release_branches_versions = release_branches
+                                        .map { |branch| branch.match(%r{origin/release/([0-9.]*)})&.captures&.first }
+                                        .compact
+
+        target_branches = all_release_branches_versions.select { |branch| Gem::Version.new(branch) > Gem::Version.new(source_release_version) }
+                                                       .map { |v| "release/#{v}" }
+        target_branches = [default_branch] if target_branches.empty?
+
+        target_branches
+      end
+
+      # Creates a backmerge pull request using the `create_pull_request` Fastlane Action.
+      #
+      # @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.
+      # @param head_branch [String] the source branch for the pull request.
+      # @param base_branch [String] the target branch for the pull request.
+      # @param labels [Array<String>] the labels to add to the pull request.
+      # @param milestone [String] the milestone to associate with the pull request.
+      # @param reviewers [Array<String>] the individual reviewers for the pull request.
+      # @param team_reviewers [Array<String>] the team reviewers for the pull request.
+      # @param intermediate_branch_created_callback [Proc] A callback to call after having created the intermediate branch
+      #        to allow the caller to e.g. add new commits on it before the PR is created. The callback takes two parameters: the base branch and the intermediate branch
+      #
+      # @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:)
+        intermediate_branch = "merge/#{head_branch.gsub('/', '-')}-into-#{base_branch.gsub('/', '-')}"
+
+        if Fastlane::Helper::GitHelper.branch_exists_on_remote?(branch_name: intermediate_branch)
+          UI.user_error!("The intermediate branch `#{intermediate_branch}` already exists. Please check if there is an existing Pull Request that needs to be merged or closed first, or delete the branch.")
+          return nil
+        end
+
+        Fastlane::Helper::GitHelper.create_branch(intermediate_branch)
+
+        intermediate_branch_created_callback&.call(base_branch, intermediate_branch)
+
+        # if there's a callback, make sure it didn't switch branches
+        other_action.ensure_git_branch(branch: "^#{intermediate_branch}/") unless intermediate_branch_created_callback.nil?
+
+        if Fastlane::Helper::GitHelper.point_to_same_commit?(base_branch, head_branch)
+          UI.error("No differences between #{head_branch} and #{base_branch}. Skipping PR creation.")
+          return nil
+        end
+
+        other_action.push_to_git_remote(tags: false)
+
+        pr_body = <<~BODY
+          Merging `#{head_branch}` into `#{base_branch}`.
+
+          Via intermediate branch `#{intermediate_branch}`, to help fix conflicts if any:
+          ```
+          #{head_branch.rjust(40)}  ----o-- - - -
+          #{' ' * 40}       \\
+          #{intermediate_branch.rjust(40)}        `---.
+          #{' ' * 40}             \\
+          #{base_branch.rjust(40)}  ------------x- - -
+          ```
+        BODY
+
+        other_action.create_pull_request(
+          api_token: token,
+          repo: repository,
+          title: title,
+          body: pr_body,
+          head: intermediate_branch,
+          base: base_branch,
+          labels: labels,
+          milestone: milestone,
+          reviewers: reviewers,
+          team_reviewers: team_reviewers
+        )
+      end
+
+      def self.description
+        'Creates backmerge PRs for a release branch into target branches'
+      end
+
+      def self.authors
+        ['Automattic']
+      end
+
+      def self.return_type
+        :array_of_strings
+      end
+
+      def self.return_value
+        'The list of the created backmerge Pull Request URLs'
+      end
+
+      def self.details
+        <<~DETAILS
+          This action creates backmerge Pull Requests from a release branch into one or more target branches.
+
+          It can be used to ensure that changes from a release branch are merged back into other branches, such as newer release branches or the main development branch (e.g., `trunk`).
+        DETAILS
+      end
+
+      def self.available_options
+        [
+          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 before pushing. The call back receives two parameters: the base (target) branch for the PR and the intermediate branch name',
+                                       optional: true,
+                                       type: Proc),
+          Fastlane::Helper::GithubHelper.github_token_config_item,
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

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

@@ -152,6 +152,13 @@ module Fastlane
           (added_count + updated_count) != 0
         end
 
+        ########
+        # @!group Verify diff of library vs main strings matches
+        #
+        # @note This set of methods is used by `an_validate_lib_strings_action`
+        #       (which doesn't seem to be used by any of our Android projects nowadays?)
+        ########
+
         def self.verify_diff(diff_string, main_strings, lib_strings, library)
           return unless diff_string.start_with?('name=')
 
@@ -198,6 +205,8 @@ module Fastlane
           end
         end
 
+        # @!endgroup
+
         ########
         # @!group Downloading translations from GlotPress
         ########
@@ -223,7 +232,7 @@ module Fastlane
         #
         # @param [String] res_dir The relative path to the `…/src/main/res` directory.
         # @param [String] glotpress_project_url The base URL to the glotpress project to download the strings from.
-        # @param [Hash{String=>String}, Array] glotpress_filters
+        # @param [Hash{Symbol=>String}, Array] glotpress_filters
         #        The filters to apply when exporting strings from GlotPress.
         #        Typical examples include `{ status: 'current' }` or `{ status: 'review' }`.
         #        If an array of Hashes is provided instead of a single Hash, this method will perform as many
@@ -235,10 +244,8 @@ module Fastlane
         def self.download_from_glotpress(res_dir:, glotpress_project_url:, locales_map:, glotpress_filters: { status: 'current' })
           glotpress_filters = [glotpress_filters] unless glotpress_filters.is_a?(Array)
 
-          attributes_to_copy = %w[formatted] # Attributes that we want to replicate into translated `string.xml` files
           orig_file = File.join(res_dir, 'values', 'strings.xml')
           orig_xml = File.open(orig_file) { |f| Nokogiri::XML(f, nil, Encoding::UTF_8.to_s) }
-          orig_attributes = orig_xml.xpath('//string').to_h { |tag| [tag['name'], tag.attributes.select { |k, _| attributes_to_copy.include?(k) }] }
 
           locales_map.each do |lang_codes|
             all_xml_documents = glotpress_filters.map do |filters|
@@ -250,13 +257,7 @@ module Fastlane
             # Merge all XMLs together
             merged_xml = merge_xml_documents(all_xml_documents)
 
-            # Process XML (text substitutions, replicate attributes, quick-lint string)
-            merged_xml.xpath('//string').each do |string_tag|
-              apply_substitutions(string_tag)
-              orig_attributes[string_tag['name']]&.each { |k, v| string_tag[k] = v }
-              quick_lint(string_tag, lang_codes[:android])
-            end
-            merged_xml.xpath('//string-array/item').each { |item_tag| apply_substitutions(item_tag) }
+            post_process_xml!(merged_xml, locale_code: lang_codes[:android], original_xml: orig_xml)
 
             # Save
             lang_dir = File.join(res_dir, "values-#{lang_codes[:android]}")
@@ -266,8 +267,10 @@ module Fastlane
           end
         end
 
+        # @!endgroup
+
         #####################
-        # Private Helpers
+        # @!group Private Helpers
         #####################
 
         # Downloads the export from GlotPress for a given locale and given filters
@@ -276,7 +279,7 @@ module Fastlane
         # @param [String] locale The GlotPress locale code to download strings for.
         # @param [Hash{Symbol=>String}] filters The hash of filters to apply when exporting from GlotPress.
         #                               Typical examples include `{ status: 'current' }` or `{ status: 'review' }`.
-        # @return [Nokogiri::XML] the download XML document, parsed as a Nokogiri::XML object
+        # @return [Nokogiri::XML::Document] the download XML document, parsed as a Nokogiri::XML object
         #
         def self.download_glotpress_export_file(project_url:, locale:, filters:)
           query_params = filters.transform_keys { |k| "filters[#{k}]" }.merge(format: 'android')
@@ -297,6 +300,9 @@ module Fastlane
 
         # Merge multiple Nokogiri::XML `strings.xml` documents together
         #
+        # Used especially when we provided multiple GlotPress filters to `download_from_glotpress`,
+        # as in this case we'd trigger one export per filter, then merge the result in a single XML
+        #
         # @param [Array<Nokogiri::XML::Document>] all_xmls Array of the Nokogiri XML documents to merge together
         # @return [Nokogiri::XML::Document] The merged document.
         #
@@ -323,11 +329,53 @@ module Fastlane
         end
         private_class_method :merge_xml_documents
 
-        # Apply some common text substitutions to tag contents
+        # Process a downloaded XML (in-place), to apply the following
+        #  - replicate attributes from the nodes of the original XML (`translatable`, `tools:ignore`, …) to the translated XML
+        #  - text substitutions for common special characters
+        #  - quick-lint string by searching for common issue patterns (using `%%` in a `formatted=false` string, etc)
+        #
+        # @param [Nokogiri::XML::Document] translated_xml The downloaded XML to post-process
+        # @param [String] locale_code The android locale code associated with the translated_xml
+        # @param [Nokogiri::XML::Document] original_xml The original `values/strings.xml` to use as reference
+        #
+        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|
+              [[attr.namespace&.prefix, attr.name].compact.join(':'), attr.value]
+            end
+            orig_attributes&.each { |k, v| node[k] = v unless k == 'name' }
+          end
+
+          # 1. Replicate namespaces on the document (especially `xmlns:tools` if present)
+          original_xml.namespaces.each { |k, v| translated_xml.root&.add_namespace(k.delete_prefix('xmlns:'), v) }
+          # 2. Replicate attributes on any node with `@name` attribute (`string`, `string-array`, `plurals`)
+          translated_xml.xpath('//*[@name]').each do |node|
+            copy_orig_attributes.call(node, "//#{node.name}[@name = '#{node['name']}']")
+          end
+          # 3. Process copies for `string` nodes
+          translated_xml.xpath('//string[@name]').each do |string_node|
+            apply_substitutions!(string_node)
+            quick_lint(string_node, locale_code)
+          end
+          # 4. Process copies for `string-array/item` nodes
+          translated_xml.xpath('//string-array[@name]/item').each do |item_node|
+            apply_substitutions!(item_node)
+            quick_lint(item_node, locale_code)
+          end
+          # 5. Replicate attributes + Process copies for `plurals/item` nodes
+          translated_xml.xpath('//plurals[@name]/item[@quantity]').each do |item_node|
+            copy_orig_attributes.call(item_node, "//plurals[@name = '#{item_node.parent['name']}']/item[@quantity = '#{item_node['quantity']}']")
+            apply_substitutions!(item_node)
+            quick_lint(item_node, locale_code)
+          end
+        end
+        private_class_method :post_process_xml!
+
+        # Apply some common text substitutions to tag contents, like `... => …` or en-dash instead of regular dash for ranges of numbers
         #
         # @param [Nokogiri::XML::Node] tag The XML tag/node to apply substitutions to
         #
-        def self.apply_substitutions(tag)
+        def self.apply_substitutions!(tag)
           tag.content = tag.content.gsub('...', '…')
 
           # Typography en-dash
@@ -339,17 +387,28 @@ module Fastlane
             is_negative_number ? str : "#{match[1]}\u{2013}#{match[2]}"
           end
         end
-        private_class_method :apply_substitutions
+        private_class_method :apply_substitutions!
 
-        # Perform some quick basic checks about an individual `<string>` tag and print warnings accordingly
+        # Perform some quick basic checks about an individual `<string>` tag and print warnings accordingly:
+        #  - detect the use of `%%` in the string even if `formatted=false` is set
+        #  - detect the presence of `\@string/` in translated XML, which suggests the original key that referenced `@string/…` did not set `translatable=false`
+        #    and thus that `@string/…` copy was sent to GlotPress for translation, then escaped during exporting it back.
         #
-        # @param [Nokogiri::XML::Node] string_tag The XML tag/node to check
+        # @param [Nokogiri::XML::Node] node The XML tag/node to check the content of
         # @param [String] lang The language we are currently processing. Used for providing context during logging / warning message
         #
-        def self.quick_lint(string_tag, lang)
-          return unless string_tag['formatted'] == 'false' && string_tag.content.include?('%%')
-
-          UI.important "Warning: [#{lang}] translation for '#{string_tag['name']}' has attribute formatted=false, but still contains escaped '%%' in translation."
+        def self.quick_lint(node, lang)
+          named_node = node.has_attribute?('name') ? node : node.parent
+          if named_node['formatted'] == 'false' && node.content.include?('%%')
+            UI.important "Warning: [#{lang}] translation for '#{named_node['name']}' has attribute formatted=false, but still contains escaped '%%' in translation."
+          end
+          # rubocop:disable Style/GuardClause
+          if node.content.include?('\\@string/')
+            UI.important "Warning: [#{lang}] exported translation for '#{named_node['name']}' contains `\\@string/`. This is a sign that this entry was not marked as `translatable=false` " \
+              + 'in the original `values/strings.xml`, and was thus sent to GlotPress, which added the backslash when exporting it back.'
+            node.content = node.content.gsub('\\@string/', '@string/')
+          end
+          # rubocop:enable Style/GuardClause
         end
         private_class_method :quick_lint
 

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

@@ -179,6 +179,21 @@ module Fastlane
         Action.sh('git', 'fetch', '--tags')
       end
 
+      # Checks if two git references point to the same commit.
+      #
+      # @param ref1 [String] the first git reference to check.
+      # @param ref2 [String] the second git reference to check.
+      #
+      # @return [Boolean] true if the two references point to the same commit, false otherwise.
+      #
+      def self.point_to_same_commit?(ref1, ref2)
+        git_repo = Git.open(Dir.pwd)
+        ref1_commit = git_repo.gcommit(ref1)
+        ref2_commit = git_repo.gcommit(ref2)
+
+        ref1_commit.sha == ref2_commit.sha
+      end
+
       # Returns the current git branch, or "HEAD" if it's not checked out to any branch
       # Can NOT be replaced using the environment variables such as `GIT_BRANCH` or `BUILDKITE_BRANCH`
       #
@@ -206,6 +221,17 @@ module Fastlane
         !Action.sh('git', 'branch', '--list', branch_name).empty?
       end
 
+      # Checks if a branch exists on the repository's remote.
+      #
+      # @param branch_name [String] the name of the branch to check.
+      # @param remote_name [String] the name of the remote repository (default is 'origin').
+      #
+      # @return [Boolean] true if the branch exists on remote, false otherwise.
+      #
+      def self.branch_exists_on_remote?(branch_name:, remote_name: 'origin')
+        !Action.sh('git', 'ls-remote', '--heads', remote_name, branch_name).empty?
+      end
+
       # Ensure that we are on the expected branch, and abort if not.
       #
       # @param [String] branch_name The name of the branch we expect to be on

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

@@ -2,6 +2,6 @@
 
 module Fastlane
   module Wpmreleasetoolkit
-    VERSION = '11.0.2'
+    VERSION = '11.1.0'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-wpmreleasetoolkit
 version: !ruby/object:Gem::Version
-  version: 11.0.2
+  version: 11.1.0
 platform: ruby
 authors:
 - Automattic
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-06-04 00:00:00.000000000 Z
+date: 2024-07-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -449,6 +449,7 @@ files:
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/common/copy_branch_protection_action.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/common/create_new_milestone_action.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/common/create_release_action.rb
+- lib/fastlane/plugin/wpmreleasetoolkit/actions/common/create_release_backmerge_pull_request_action.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/common/extract_release_notes_for_version_action.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/common/find_previous_tag.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/common/firebase_login.rb