fastlane-plugin-wpmreleasetoolkit 5.5.0 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 858fcaeb7ccaa13b2b3990d36aa1c9aa15f9f9cb90c7ee7bb6941442f2c97847
-  data.tar.gz: '067942032d28224600deae4333b427e3eda6af56d65fb83eefb5ef4e3c07b868'
+  metadata.gz: c16be217cbd668e4fbd9da107edcdba4b5be149f0d64d4dadb6a0d5697cde006
+  data.tar.gz: e736842ca7df0e1ff50fc0a7114e39555570c03c8e58b41fa265999f267f0ec2
 SHA512:
-  metadata.gz: eb6a9f16072c66b7458d4a0787b300cdddd0d87ae99cc886ecc5d64a733d11f046a27c6167b7150fd73c358d9f6c3c85e03b10d4b5c76202fa5273560b5b523e
-  data.tar.gz: ca606aef9d929fe6ae3c1f821575e07fc4b672929b61ad7174a1f7e43dea8c2698ed63c696c62506beca226581f726fccadc01930e15b5e8088aa7908e2f0a6c
+  metadata.gz: 739938930d2cfd9238590f6b58b7031923f5f6b325c53246058f77dc47c7e302180f2d088b8c764106d50e45f7bca265d915a3d671bbf09c6a45e9309fcb1e3e
+  data.tar.gz: 0741aeff083cab3060b8b4f46259ad091217eef34fd013370fca26289b5c2279c325632dd7935699772e293e81e87ffcbd71bc7b8905da5fffbb4e04543f61e5

data/lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_create_avd_action.rb

@@ -0,0 +1,90 @@
+module Fastlane
+  module Actions
+    class AndroidCreateAvdAction < Action
+      def self.run(params)
+        device_model = params[:device_model]
+        api_level = params[:api_level]
+        avd_name = params[:avd_name]
+        sdcard = params[:sdcard]
+
+        helper = Fastlane::Helper::Android::EmulatorHelper.new
+
+        # Ensure we have the system image needed for creating the AVD with this API level
+        system_image = params[:system_image] || helper.install_system_image(api: api_level)
+
+        # Create the AVD for device, API and system image we need
+        helper.create_avd(
+          api: api_level,
+          device: device_model,
+          system_image: system_image,
+          name: avd_name,
+          sdcard: sdcard
+        )
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        'Creates a new Android Virtual Device (AVD) for a specific device model and API level'
+      end
+
+      def self.details
+        <<~DESC
+          Creates a new Android Virtual Device (AVD) for a specific device model and API level.
+          By default, it also installs the necessary system image (using `sdkmanager`) if needed before creating the AVD
+        DESC
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :device_model,
+                                       env_name: 'FL_ANDROID_CREATE_AVD_DEVICE_MODEL',
+                                       description: 'The device model code to use to create the AVD. Valid values can be found using `avdmanager list devices`',
+                                       type: String,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :api_level,
+                                       env_name: 'FL_ANDROID_CREATE_AVD_API_LEVEL',
+                                       description: 'The API level to use to install the necessary system-image and create the AVD',
+                                       type: Integer,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :avd_name,
+                                       env_name: 'FL_ANDROID_CREATE_AVD_AVD_NAME',
+                                       description: 'The name to give to the created AVD. If not provided, will be derived from device model and API level',
+                                       type: String,
+                                       optional: true,
+                                       default_value: nil),
+          FastlaneCore::ConfigItem.new(key: :sdcard,
+                                       env_name: 'FL_ANDROID_CREATE_AVD_SDCARD',
+                                       description: 'The size of the SD card to use for the AVD',
+                                       type: String,
+                                       optional: true,
+                                       default_value: '512M'),
+          FastlaneCore::ConfigItem.new(key: :system_image,
+                                       env_name: 'FL_ANDROID_CREATE_AVD_SYSTEM_IMAGE',
+                                       description: 'The system image to use (as used/listed by `sdkmanager`). Defaults to the appropriate system image given the API level requested and the current machine\'s architecture',
+                                       type: String,
+                                       optional: true,
+                                       default_value_dynamic: true,
+                                       default_value: nil),
+        ]
+      end
+
+      def self.output
+      end
+
+      def self.return_value
+        'Returns the name of the created AVD'
+      end
+
+      def self.authors
+        ['Automattic']
+      end
+
+      def self.is_supported?(platform)
+        platform == :android
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_download_file_by_version.rb

@@ -9,7 +9,8 @@ module Fastlane
         UI.user_error!("Can't find any reference for key #{params[:import_key]}") if version.nil?
         UI.message "Downloading #{params[:file_path]} from #{params[:repository]} at version #{version} to #{params[:download_folder]}"
 
-        Fastlane::Helper::GithubHelper.download_file_from_tag(
+        github_helper = Fastlane::Helper::GithubHelper.new(github_token: params[:github_token])
+        github_helper.download_file_from_tag(
           repository: params[:repository],
           tag: "#{params[:github_release_prefix]}#{version}",
           file_path: params[:file_path],
@@ -57,6 +58,7 @@ module Fastlane
                                        description: 'The prefix which is used in the GitHub release title',
                                        type: String,
                                        optional: true),
+          Fastlane::Helper::GithubHelper.github_token_config_item,
         ]
       end
 

data/lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_launch_emulator_action.rb

@@ -0,0 +1,61 @@
+module Fastlane
+  module Actions
+    class AndroidLaunchEmulatorAction < Action
+      def self.run(params)
+        helper = Fastlane::Helper::Android::EmulatorHelper.new
+        helper.launch_avd(
+          name: params[:avd_name],
+          cold_boot: params[:cold_boot],
+          wipe_data: params[:wipe_data]
+        )
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        'Boots an Android emulator using the given AVD name'
+      end
+
+      def self.details
+        description
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :avd_name,
+                                       env_name: 'FL_ANDROID_LAUNCH_EMULATOR_AVD_NAME',
+                                       description: 'The name of the AVD to boot',
+                                       type: String,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :cold_boot,
+                                       env_name: 'FL_ANDROID_LAUNCH_EMULATOR_COLD_BOOT',
+                                       description: 'Indicate if we want a cold boot (true) of if we prefer booting from a snapshot (false)',
+                                       type: Fastlane::Boolean,
+                                       default_value: true),
+          FastlaneCore::ConfigItem.new(key: :wipe_data,
+                                       env_name: 'FL_ANDROID_LAUNCH_EMULATOR_WIPE_DATA',
+                                       description: 'Indicate if we want to wipe the device data before booting the AVD, so it is like it were a brand new device',
+                                       type: Fastlane::Boolean,
+                                       default_value: true),
+        ]
+      end
+
+      def self.output
+      end
+
+      def self.return_value
+        'The serial of the emulator that was created after booting the AVD (e.g. `emulator-5554`)'
+      end
+
+      def self.authors
+        ['Automattic']
+      end
+
+      def self.is_supported?(platform)
+        platform == :android
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_send_app_size_metrics.rb

@@ -71,31 +71,26 @@ module Fastlane
         end
 
         # The path where the `apkanalyzer` binary was found, after searching it:
-        #  - in priority in `$ANDROID_SDK_ROOT` (or `$ANDROID_HOME` for legacy setups), under `cmdline-tools/latest/bin/` or `cmdline-tools/tools/bin`
+        #  - in priority in `$ANDROID_HOME` (or `$ANDROID_SDK_ROOT` for legacy setups), under `cmdline-tools/latest/bin/` or `cmdline-tools/tools/bin`
         #  - and falling back by trying to find it in `$PATH`
         #
         # @return [String,Nil] The path to `apkanalyzer`, or `nil` if it wasn't found in any of the above tested paths.
         #
         def find_apkanalyzer_binary
-          sdk_root = ENV['ANDROID_SDK_ROOT'] || ENV['ANDROID_HOME']
-          if sdk_root
-            pattern = File.join(sdk_root, 'cmdline-tools', '{latest,tools}', 'bin', 'apkanalyzer')
-            apkanalyzer_bin = Dir.glob(pattern).find { |path| File.executable?(path) }
-          end
-          apkanalyzer_bin || Action.sh('command', '-v', 'apkanalyzer', print_command_output: false) { |_| nil }
+          @tools ||= Fastlane::Helper::Android::ToolsPathHelper.new
+          @tools.find_tool_path(binary: 'apkanalyzer', search_paths: @tools.cmdline_tools_search_paths)
         end
 
         # The path where the `apkanalyzer` binary was found, after searching it:
-        #  - in priority in `$ANDROID_SDK_ROOT` (or `$ANDROID_HOME` for legacy setups), under `cmdline-tools/latest/bin/` or `cmdline-tools/tools/bin`
+        #  - in priority in `$ANDROID_HOME` (or `$ANDROID_SDK_ROOT` for legacy setups), under `cmdline-tools/latest/bin/` or `cmdline-tools/tools/bin`
         #  - and falling back by trying to find it in `$PATH`
         #
         # @return [String] The path to `apkanalyzer`
         # @raise [FastlaneCore::Interface::FastlaneError] if it wasn't found in any of the above tested paths.
         #
         def find_apkanalyzer_binary!
-          apkanalyzer_bin = find_apkanalyzer_binary
-          UI.user_error!('Unable to find `apkanalyzer` executable in either `$PATH` or `$ANDROID_SDK_ROOT`. Make sure you installed the Android SDK Command-line Tools') if apkanalyzer_bin.nil?
-          apkanalyzer_bin
+          @tools ||= Fastlane::Helper::Android::ToolsPathHelper.new
+          @tools.find_tool_path!(binary: 'apkanalyzer', search_paths: @tools.cmdline_tools_search_paths)
         end
 
         # Add the `file-size` and `download-size` values of an APK to the helper, as reported by the corresponding `apkanalyzer apk …` commands

data/lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_shutdown_emulator_action.rb

@@ -0,0 +1,48 @@
+module Fastlane
+  module Actions
+    class AndroidShutdownEmulatorAction < Action
+      def self.run(params)
+        helper = Fastlane::Helper::Android::EmulatorHelper.new
+        helper.shut_down_emulators!(serials: params[:serials])
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        'Shuts down Android emulators'
+      end
+
+      def self.details
+        description
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :serials,
+                                       env_name: 'FL_ANDROID_SHUTDOWN_EMULATOR_SERIALS',
+                                       description: 'The serial(s) of the emulators to shut down. If not provided (nil), will shut them all down',
+                                       type: Array,
+                                       optional: true,
+                                       default_value: nil),
+        ]
+      end
+
+      def self.output
+      end
+
+      def self.return_value
+        # If you method provides a return value, you can describe here what it does
+      end
+
+      def self.authors
+        ['Automattic']
+      end
+
+      def self.is_supported?(platform)
+        platform == :android
+      end
+    end
+  end
+end

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

@@ -10,10 +10,12 @@ module Fastlane
         repository = params[:repository]
         milestone_title = params[:milestone]
 
-        milestone = Fastlane::Helper::GithubHelper.get_milestone(repository, milestone_title)
+        github_helper = Fastlane::Helper::GithubHelper.new(github_token: params[:github_token])
+        milestone = github_helper.get_milestone(repository, milestone_title)
+
         UI.user_error!("Milestone #{milestone_title} not found.") if milestone.nil?
 
-        Fastlane::Helper::GithubHelper.github_client().update_milestone(repository, milestone[:number], state: 'closed')
+        github_helper.update_milestone(repository: repository, number: milestone[:number], state: 'closed')
       end
 
       def self.description
@@ -45,6 +47,7 @@ module Fastlane
                                        description: 'The GitHub milestone',
                                        optional: false,
                                        type: String),
+          Fastlane::Helper::GithubHelper.github_token_config_item,
         ]
       end
 

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

@@ -10,7 +10,8 @@ module Fastlane
       def self.run(params)
         require_relative '../../helper/github_helper'
 
-        reuse_identifier = Fastlane::Helper::GithubHelper.comment_on_pr(
+        github_helper = Fastlane::Helper::GithubHelper.new(github_token: params[:github_token])
+        reuse_identifier = github_helper.comment_on_pr(
           project_slug: params[:project],
           pr_number: params[:pr_number],
           body: params[:body],
@@ -41,12 +42,7 @@ module Fastlane
 
       def self.available_options
         [
-          FastlaneCore::ConfigItem.new(
-            key: :access_token,
-            env_name: 'GITHUB_TOKEN',
-            description: 'The GitHub token to use for posting the comment',
-            type: String
-          ),
+          Fastlane::Helper::GithubHelper.github_token_config_item,
           FastlaneCore::ConfigItem.new(
             key: :reuse_identifier,
             description: 'If provided, the reuse identifier can identify an existing comment to overwrite',

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

@@ -9,15 +9,29 @@ module Fastlane
       def self.run(params)
         repository = params[:repository]
 
-        last_stone = Fastlane::Helper::GithubHelper.get_last_milestone(repository)
+        github_helper = Fastlane::Helper::GithubHelper.new(github_token: params[:github_token])
+        last_stone = github_helper.get_last_milestone(repository)
+
         UI.message("Last detected milestone: #{last_stone[:title]} due on #{last_stone[:due_on]}.")
+
         milestone_duedate = last_stone[:due_on]
         milestone_duration = params[:milestone_duration]
         newmilestone_duedate = (milestone_duedate.to_datetime.next_day(milestone_duration).to_time).utc
         newmilestone_number = Fastlane::Helper::Ios::VersionHelper.calc_next_release_version(last_stone[:title])
         number_of_days_from_code_freeze_to_release = params[:number_of_days_from_code_freeze_to_release]
+        # Because of the app stores review process, we submit the binary 3 days before the intended release date.
+        # Using 3 days is mostly for historical reasons, for a long time, we've been submitting apps on Friday and releasing them on Monday.
+        days_until_submission = params[:need_appstore_submission] ? (number_of_days_from_code_freeze_to_release - 3) : milestone_duration
+
         UI.message("Next milestone: #{newmilestone_number} due on #{newmilestone_duedate}.")
-        Fastlane::Helper::GithubHelper.create_milestone(repository, newmilestone_number, newmilestone_duedate, milestone_duration, number_of_days_from_code_freeze_to_release, params[:need_appstore_submission])
+
+        github_helper.create_milestone(
+          repository: repository,
+          title: newmilestone_number,
+          due_date: newmilestone_duedate,
+          days_until_submission: days_until_submission,
+          days_until_release: number_of_days_from_code_freeze_to_release
+        )
       end
 
       def self.description
@@ -62,6 +76,7 @@ module Fastlane
                                        optional: true,
                                        is_string: false,
                                        default_value: 14),
+          Fastlane::Helper::GithubHelper.github_token_config_item,
         ]
       end
 

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

@@ -21,7 +21,8 @@ module Fastlane
           UI.user_error!("Can't find file #{file_path}!") unless File.exist?(file_path)
         end
 
-        Fastlane::Helper::GithubHelper.create_release(
+        github_helper = Fastlane::Helper::GithubHelper.new(github_token: params[:github_token])
+        github_helper.create_release(
           repository: repository,
           version: version,
           target: params[:target],
@@ -82,6 +83,7 @@ module Fastlane
                                        optional: true,
                                        default_value: false,
                                        is_string: false),
+          Fastlane::Helper::GithubHelper.github_token_config_item,
         ]
       end
 

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

@@ -10,7 +10,8 @@ module Fastlane
         milestone = params[:milestone]
 
         # Get commit list
-        pr_list = Fastlane::Helper::GithubHelper.get_prs_for_milestone(repository, milestone)
+        github_helper = Fastlane::Helper::GithubHelper.new(github_token: params[:github_token])
+        pr_list = github_helper.get_prs_for_milestone(repository, milestone)
 
         File.open(report_path, 'w') do |file|
           pr_list.each do |data|
@@ -53,6 +54,7 @@ module Fastlane
                                        description: 'The name of the milestone we want to fetch the list of PRs for (e.g.: `16.9`)',
                                        optional: false,
                                        is_string: true),
+          Fastlane::Helper::GithubHelper.github_token_config_item,
         ]
       end
 

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

@@ -7,14 +7,19 @@ module Fastlane
       def self.run(params)
         repository = params[:repository]
         branch_name = params[:branch]
-        branch_prot = {}
 
         branch_url = "https://api.github.com/repos/#{repository}/branches/#{branch_name}"
-        branch_prot[:restrictions] = { url: "#{branch_url}/protection/restrictions", users_url: "#{branch_url}/protection/restrictions/users", teams_url: "#{branch_url}/protection/restrictions/teams", users: [], teams: [] }
-        branch_prot[:enforce_admins] = nil
-        branch_prot[:required_pull_request_reviews] = { url: "#{branch_url}/protection/required_pull_request_reviews", dismiss_stale_reviews: false, require_code_owner_reviews: false }
-
-        Fastlane::Helper::GithubHelper.github_client().unprotect_branch(repository, branch_name, branch_prot)
+        restrictions = { url: "#{branch_url}/protection/restrictions", users_url: "#{branch_url}/protection/restrictions/users", teams_url: "#{branch_url}/protection/restrictions/teams", users: [], teams: [] }
+        required_pull_request_reviews = { url: "#{branch_url}/protection/required_pull_request_reviews", dismiss_stale_reviews: false, require_code_owner_reviews: false }
+
+        github_helper = Fastlane::Helper::GithubHelper.new(github_token: params[:github_token])
+        github_helper.remove_branch_protection(
+          repository: repository,
+          branch: branch_name,
+          restrictions: restrictions,
+          enforce_admins: nil,
+          required_pull_request_reviews: required_pull_request_reviews
+        )
       end
 
       def self.description
@@ -46,6 +51,7 @@ module Fastlane
                                        description: 'The branch to unprotect',
                                        optional: false,
                                        type: String),
+          Fastlane::Helper::GithubHelper.github_token_config_item,
         ]
       end
 

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

@@ -7,13 +7,19 @@ module Fastlane
       def self.run(params)
         repository = params[:repository]
         branch_name = params[:branch]
-        branch_prot = {}
 
         branch_url = "https://api.github.com/repos/#{repository}/branches/#{branch_name}"
-        branch_prot[:restrictions] = { url: "#{branch_url}/protection/restrictions", users_url: "#{branch_url}/protection/restrictions/users", teams_url: "#{branch_url}/protection/restrictions/teams", users: [], teams: [] }
-        branch_prot[:enforce_admins] = nil
-        branch_prot[:required_pull_request_reviews] = { url: "#{branch_url}/protection/required_pull_request_reviews", dismiss_stale_reviews: false, require_code_owner_reviews: false }
-        Fastlane::Helper::GithubHelper.github_client().protect_branch(repository, branch_name, branch_prot)
+        restrictions = { url: "#{branch_url}/protection/restrictions", users_url: "#{branch_url}/protection/restrictions/users", teams_url: "#{branch_url}/protection/restrictions/teams", users: [], teams: [] }
+        required_pull_request_reviews = { url: "#{branch_url}/protection/required_pull_request_reviews", dismiss_stale_reviews: false, require_code_owner_reviews: false }
+
+        github_helper = Fastlane::Helper::GithubHelper.new(github_token: params[:github_token])
+        github_helper.set_branch_protection(
+          repository: repository,
+          branch: branch_name,
+          restrictions: restrictions,
+          enforce_admins: nil,
+          required_pull_request_reviews: required_pull_request_reviews
+        )
       end
 
       def self.description
@@ -45,6 +51,7 @@ module Fastlane
                                        description: 'The branch to protect',
                                        optional: false,
                                        type: String),
+          Fastlane::Helper::GithubHelper.github_token_config_item,
         ]
       end
 

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

@@ -9,7 +9,9 @@ module Fastlane
         milestone_title = params[:milestone]
         freeze = params[:freeze]
 
-        milestone = Fastlane::Helper::GithubHelper.get_milestone(repository, milestone_title)
+        github_helper = Fastlane::Helper::GithubHelper.new(github_token: params[:github_token])
+        milestone = github_helper.get_milestone(repository, milestone_title)
+
         UI.user_error!("Milestone #{milestone_title} not found.") if milestone.nil?
 
         mile_title = milestone[:title]
@@ -27,7 +29,7 @@ module Fastlane
         end
 
         UI.message("New milestone: #{mile_title}")
-        Fastlane::Helper::GithubHelper.github_client().update_milestone(repository, milestone[:number], title: mile_title)
+        github_helper.update_milestone(repository: repository, number: milestone[:number], title: mile_title)
       end
 
       def self.is_frozen(milestone)
@@ -70,6 +72,7 @@ module Fastlane
                                        optional: false,
                                        default_value: true,
                                        is_string: false),
+          Fastlane::Helper::GithubHelper.github_token_config_item,
         ]
       end
 

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

@@ -20,7 +20,15 @@ module Fastlane
           key = [file_name_hash, key].join('/')
         end
 
-        UI.user_error!("File already exists in S3 bucket #{bucket} at #{key}") if file_is_already_uploaded?(bucket, key)
+        if file_is_already_uploaded?(bucket, key)
+          message = "File already exists in S3 bucket #{bucket} at #{key}"
+          if params[:skip_if_exists]
+            UI.important("#{message}. Skipping upload.")
+            return key
+          else
+            UI.user_error!(message)
+          end
+        end
 
         UI.message("Uploading #{file_path} to: #{key}")
 
@@ -101,6 +109,13 @@ module Fastlane
             default_value: true,
             type: Boolean
           ),
+          FastlaneCore::ConfigItem.new(
+            key: :skip_if_exists,
+            description: 'If the file already exists in the S3 bucket, skip the upload (and report it in the logs), instead of failing with `user_error!`',
+            optional: true,
+            default_value: false,
+            type: Boolean
+          ),
         ]
       end
 

data/lib/fastlane/plugin/wpmreleasetoolkit/actions/ios/ios_lint_localizations.rb

@@ -2,12 +2,11 @@ module Fastlane
   module Actions
     class IosLintLocalizationsAction < Action
       def self.run(params)
-        violations = Hash.new([])
+        violations = nil
 
         loop do
-          # If we did `violations = self.run...` we'd lose the default value for missing key being `[]` that we set above with `Hash.new`.
-          # We want that default value so that we can use `+=` when adding the duplicate keys violations below.
-          violations = violations.merge(self.run_linter(params))
+          violations = self.run_linter(params)
+          violations.default = [] # Set the default value for when querying a missing key
 
           if params[:check_duplicate_keys]
             find_duplicated_keys(params).each do |language, duplicates|
@@ -49,18 +48,21 @@ module Fastlane
       def self.find_duplicated_keys(params)
         duplicate_keys = {}
 
-        files_to_lint = Dir.chdir(params[:input_dir]) do
-          Dir.glob('*.lproj/Localizable.strings').map do |file|
-            {
-              language: File.basename(File.dirname(file), '.lproj'),
-              path: File.join(params[:input_dir], file)
-            }
-          end
-        end
-
+        files_to_lint = Dir.glob('*.lproj/Localizable.strings', base: params[:input_dir])
         files_to_lint.each do |file|
-          duplicates = Fastlane::Helper::Ios::StringsFileValidationHelper.find_duplicated_keys(file: file[:path])
-          duplicate_keys[file[:language]] = duplicates.map { |key, value| "`#{key}` was found at multiple lines: #{value.join(', ')}" } unless duplicates.empty?
+          language = File.basename(File.dirname(file), '.lproj')
+          path = File.join(params[:input_dir], file)
+
+          file_type = Fastlane::Helper::Ios::L10nHelper.strings_file_type(path: path)
+          if file_type == :text
+            duplicates = Fastlane::Helper::Ios::StringsFileValidationHelper.find_duplicated_keys(file: path)
+            duplicate_keys[language] = duplicates.map { |key, value| "`#{key}` was found at multiple lines: #{value.join(', ')}" } unless duplicates.empty?
+          else
+            UI.important <<~WRONG_FORMAT
+              File `#{path}` is in #{file_type} format, while finding duplicate keys only make sense on files that are in ASCII-plist format.
+              Since your files are in #{file_type} format, you should probably disable the `check_duplicate_keys` option from this `#{self.action_name}` call.
+            WRONG_FORMAT
+          end
         end
 
         duplicate_keys

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

@@ -0,0 +1,198 @@
+module Fastlane
+  module Helper
+    module Android
+      # Helper methods to manipulate System Images, AVDs and Android Emulators
+      #
+      class EmulatorHelper
+        BOOT_WAIT = 2
+        BOOT_TIMEOUT = 60
+
+        SHUTDOWN_WAIT = 2
+        SHUTDOWN_TIMEOUT = 60
+
+        def initialize
+          @tools = Fastlane::Helper::Android::ToolsPathHelper.new
+        end
+
+        # Installs the system-image suitable for a given Android `api`, with Google APIs, and for the current machine's architecture
+        #
+        # @param [Integer] api The Android API level to use
+        #
+        # @return [String] The `sdkmanager` package specifier that has been installed
+        #
+        def install_system_image(api:)
+          package = system_image_package(api: api)
+
+          UI.message("Installing System Image for Android #{api} (#{package})")
+          Actions.sh(@tools.sdkmanager, '--install', package)
+          UI.success("System Image #{package} successfully installed.")
+          package
+        end
+
+        # Create an emulator (AVD) for a given `api` number and `device` model
+        #
+        # @param [Integer] api The Android API level to use for this AVD
+        # @param [String] device The Device Model to use for this AVD. Valid values can be found using `avdmanager list devices`
+        # @param [String] name The name to give for the created AVD. Defaults to `<device>_API_<api>`.
+        # @param [String] sdcard The size of the SD card for this device. Defaults to `512M`.
+        #
+        # @return [String] The device name (i.e. either `name` if provided, or the derived `<device>_API_<api>` if provided `name` was `nil``)
+        #
+        def create_avd(api:, device:, system_image: nil, name: nil, sdcard: '512M')
+          package = system_image || system_image_package(api: api)
+          device_name = name || "#{device.gsub(' ', '_').capitalize}_API_#{api}"
+
+          UI.message("Creating AVD `#{device_name}` (#{device}, API #{api})")
+
+          Actions.sh(
+            @tools.avdmanager, 'create', 'avd',
+            '--force',
+            '--package', package,
+            '--device', device,
+            '--sdcard', sdcard,
+            '--name', device_name
+          )
+
+          UI.success("AVD `#{device_name}` successfully created.")
+
+          device_name
+        end
+
+        # Launch the emulator for the given AVD, then return the emulator serial
+        #
+        # @param [String] name name of the AVD to launch
+        # @param [Int] port the TCP port to use to connect to the emulator via adb. If nil (default), will let `emulator` pick the first free one.
+        # @param [Boolean] cold_boot if true, will do a cold boot, if false will try to use a previous snapshot of the device
+        # @param [Boolean] wipe_data if true, will wipe the emulator (i.e. reset the user data image)
+        #
+        # @return [String] emulator serial number corresponding to the launched AVD
+        #
+        def launch_avd(name:, port: nil, cold_boot: true, wipe_data: true)
+          UI.message("Launching emulator for #{name}")
+
+          params = ['-avd', name]
+          params << ['-port', port.to_s] unless port.nil?
+          params << '-no-snapshot' if cold_boot
+          params << '-wipe-data' if wipe_data
+
+          UI.command([@tools.emulator, *params].shelljoin)
+          # We want to launch emulator in the background to not block the rest of the code, so we can't use `Actions.sh` here
+          # We also want to filter the `stdout`+`stderr` emitted by the `emulator` process in the background,
+          # to limit verbosity and only print error lines, and also prefix those clearly (because they might happen
+          # at any moment in the background, so in parallel/the middle of other fastlane logs).
+          t = Thread.new do
+            Open3.popen2e(@tools.emulator, *params) do |i, oe, wait_thr|
+              i.close
+              until oe.eof?
+                line = oe.readline
+                UI.error("📱 [emulator]: #{line}") if line.start_with?(/ERROR|PANIC/)
+                next unless line.include?('PANIC: Broken AVD system path')
+
+                UI.user_error! <<~HINT
+                  #{line}
+                  Verify that your `sdkmanager/avdmanager` tools are not installed in a different SDK root than your `emulator` tool
+                  (which can happen if you installed Android's command-line tools via `brew`, but the `emulator` via Android Studio, or vice-versa)
+                HINT
+              end
+              UI.error("📱 [emulator]: exited with non-zero status code: #{wait_thr.value.exitstatus}") unless wait_thr.value.success?
+            end
+          end
+          t.abort_on_exception = true # To bubble up any exception like `UI.user_error!` back to the main thread here
+
+          UI.message('Waiting for emulator to start...')
+          # Loop until the emulator has started and shows up in `adb devices -l` so we can find its serial
+          serial = nil
+          retry_loop(time_between_retries: BOOT_WAIT, timeout: BOOT_TIMEOUT, description: 'waiting for emulator to start') do
+            serial = find_serial(avd_name: name)
+            !serial.nil?
+          end
+          UI.message("Found device `#{name}` with serial `#{serial}`")
+
+          # Once the emulator has started, wait for the device in the emulator to finish booting
+          UI.message('Waiting for device to finish booting...')
+          retry_loop(time_between_retries: BOOT_WAIT, timeout: BOOT_TIMEOUT, description: 'waiting for device to finish booting') do
+            Actions.sh(@tools.adb, '-s', serial, 'shell', 'getprop', 'sys.boot_completed').chomp == '1'
+          end
+
+          UI.success("Emulator #{name} successfully booted as `#{serial}`.")
+
+          serial
+        end
+
+        # @return [Array<Fastlane::Helper::AdbDevice>] List of currently booted emulators
+        #
+        def running_emulators
+          helper = Fastlane::Helper::AdbHelper.new(adb_path: @tools.adb)
+          helper.load_all_devices.select { |device| device.serial.include?('emulator') }
+        end
+
+        def find_serial(avd_name:)
+          running_emulators.find do |candidate|
+            command = [@tools.adb, '-s', candidate.serial, 'emu', 'avd', 'name']
+            UI.command(command.shelljoin)
+            candidate_name = Actions.sh(*command, log: false).split("\n").first.chomp
+            candidate_name == avd_name
+          end&.serial
+        end
+
+        # Trigger a shutdown for all running emulators, and wait until there is no more emulators running.
+        #
+        # @param [Array<String>] serials List of emulator serials to shut down. Will shut down all of them if `nil`.
+        #
+        def shut_down_emulators!(serials: nil)
+          UI.message("Shutting down #{serials || 'all'} emulator(s)...")
+
+          emulators_list = running_emulators.map(&:serial)
+          # Get the intersection of the set of running emulators with the ones we want to shut down
+          emulators_list &= serials unless serials.nil?
+          emulators_list.each do |e|
+            Actions.sh(@tools.adb, '-s', e, 'emu', 'kill') { |_| } # ignore error if no emulator with specified serial is running
+
+            # NOTE: Alternative way of shutting down emulator would be to call the following command instead, which shuts down the emulator more gracefully:
+            # `adb -s #{e} shell reboot -p` # In case you're wondering, `-p` is for "power-off"
+            # But this alternate command:
+            #  - Requires that `-no-snapshot` was used on boot (to avoid being prompted to save current state on shutdown)
+            #  - Disconnects the emulator from `adb` (and thus disappear from `adb devices -l`) for a short amount of time,
+            #    before reconnecting to it but in an `offline` state, until `emulator` finally completely quits and it disappears
+            #    again (for good) from `adb devices --list`.
+            # This means that so if we used alternative, we couldn't really retry_loop until emulator disappears from `running_emulators` to detect
+            # that the shutdown was really complete, as we might as well accidentally detect the intermediate disconnect instead.
+          end
+
+          # Wait until all emulators are killed
+          retry_loop(time_between_retries: SHUTDOWN_WAIT, timeout: SHUTDOWN_TIMEOUT, description: 'waiting for devices to shutdown') do
+            (emulators_list & running_emulators.map(&:serial)).empty?
+          end
+
+          UI.success('All emulators are now shut down.')
+        end
+
+        # Find the system-images package for the provided `api`, with Google APIs, and matching the current platform/architecture this lane is called from.
+        #
+        # @param [Integer] api The Android API level to use for this AVD
+        # @return [String] The `system-images;android-<N>;google_apis;<platform>` package specifier for `sdkmanager` to use in its install command
+        #
+        # @note Results from this method are memoized, to avoid repeating calls to `sdkmanager` when querying for the same api level multiple times.
+        #
+        def system_image_package(api:)
+          @system_image_packages ||= {}
+          @system_image_packages[api] ||= begin
+            platform = `uname -m`.chomp
+            all_packages = `#{@tools.sdkmanager} --list`
+            package = all_packages.match(/^ *(system-images;android-#{api};google_apis;#{platform}(-[^ ]*)?)/)&.captures&.first
+            UI.user_error!("Could not find system-image for API `#{api}` and your platform `#{platform}` in `sdkmanager --list`. Maybe Google removed it for download and it's time to update to a newer API?") if package.nil?
+            package
+          end
+        end
+
+        def retry_loop(time_between_retries:, timeout:, description:)
+          Timeout.timeout(timeout) do
+            sleep(time_between_retries) until yield
+          end
+        rescue Timeout::Error
+          UI.user_error!("Timed out #{description}")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+require 'fastlane_core/ui/ui'
+
+module Fastlane
+  module Helper
+    module Android
+      # Helper to find the paths of common Android build and SDK tools on the current machine
+      # Based on `$ANDROID_HOME` and the common relative paths those tools are installed in.
+      #
+      class ToolsPathHelper
+        attr_reader :android_home
+
+        def initialize(sdk_root: nil)
+          @android_home = sdk_root || ENV['ANDROID_HOME'] || ENV['ANDROID_SDK_ROOT'] || ENV['ANDROID_SDK']
+        end
+
+        # @param [String] binary The name of the binary to search for
+        # @param [Array<String>] search_paths The search paths, relative to `@android_home`, in which to search for the tools.
+        #        If `android_home` is `nil` or the binary wasn't found in any of the `search_paths`, will fallback to searching in `$PATH`.
+        # @return [String] The absolute path of the tool if found, `nil` if not found.
+        def find_tool_path(binary:, search_paths:)
+          bin_path = unless android_home.nil?
+                       search_paths
+                         .map { |path| File.join(android_home, path, binary) }
+                         .find { |path| File.executable?(path) }
+                     end
+
+          # If not found in any of the `search_paths`, try to look for it in $PATH
+          bin_path ||= Actions.sh('command', '-v', binary) { |err, res, _| res if err&.success? }&.chomp
+
+          # Normalize return value to `nil` if it was not found, empty, or is not an executable
+          bin_path = nil if !bin_path.nil? && (bin_path.empty? || !File.executable?(bin_path))
+
+          bin_path
+        end
+
+        # @param [String] binary The name of the binary to search for
+        # @param [Array<String>] search_paths The search paths, relative to `@android_home`, in which to search for the tools.
+        #        If `android_home` is `nil` or the binary wasn't found in any of the `search_paths`, will fallback to searching in `$PATH`.
+        # @return [String] The absolute path of the tool if found.
+        # @raise [FastlaneCore::Interface::FastlaneError] If the tool couldn't be found.
+        def find_tool_path!(binary:, search_paths:)
+          bin_path = find_tool_path(binary: binary, search_paths: search_paths)
+          UI.user_error!("Unable to find path for #{binary} in #{search_paths.inspect}. Verify you installed the proper Android tools.") if bin_path.nil?
+          bin_path
+        end
+
+        def cmdline_tools_search_paths
+          # It appears that depending on the machines and versions of Android SDK, some versions
+          # installed the command line tools in `tools` and not `latest` subdirectory, hence why
+          # we search both (`latest` first, `tools` as fallback) to cover all our bases.
+          [
+            File.join('cmdline-tools', 'latest', 'bin'),
+            File.join('cmdline-tools', 'tools', 'bin'),
+          ]
+        end
+
+        def sdkmanager
+          @sdkmanager ||= find_tool_path!(
+            binary: 'sdkmanager',
+            search_paths: cmdline_tools_search_paths
+          )
+        end
+
+        def avdmanager
+          @avdmanager ||= find_tool_path!(
+            binary: 'avdmanager',
+            search_paths: cmdline_tools_search_paths
+          )
+        end
+
+        def emulator
+          @emulator ||= find_tool_path!(
+            binary: 'emulator',
+            search_paths: [File.join('emulator')]
+          )
+        end
+
+        def adb
+          @adb ||= find_tool_path!(
+            binary: 'adb',
+            search_paths: [File.join('platform-tools')]
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -8,34 +8,25 @@ module Fastlane
 
   module Helper
     class GithubHelper
-      def self.github_token!
-        token = [
-          'GHHELPER_ACCESS', # For historical reasons / backward compatibility
-          'GITHUB_TOKEN',    # Used by the `gh` CLI tool
-        ].map { |key| ENV[key] }
-                .compact
-                .first
-
-        token || UI.user_error!('Please provide a GitHub authentication token via the `GITHUB_TOKEN` environment variable')
-      end
-
-      def self.github_client
-        @@client ||= begin
-          client = Octokit::Client.new(access_token: github_token!)
+      attr_reader :client
 
-          # Fetch the current user
-          user = client.user
-          UI.message("Logged in as: #{user.name}")
+      # Helper for GitHub Actions
+      #
+      # @param [String?] github_token GitHub OAuth access token
+      #
+      def initialize(github_token:)
+        @client = Octokit::Client.new(access_token: github_token)
 
-          # Auto-paginate to ensure we're not missing data
-          client.auto_paginate = true
+        # Fetch the current user
+        user = @client.user
+        UI.message("Logged in as: #{user.name}")
 
-          client
-        end
+        # Auto-paginate to ensure we're not missing data
+        @client.auto_paginate = true
       end
 
-      def self.get_milestone(repository, release)
-        miles = github_client().list_milestones(repository)
+      def get_milestone(repository, release)
+        miles = client.list_milestones(repository)
         mile = nil
 
         miles&.each do |mm|
@@ -51,15 +42,15 @@ module Fastlane
       # @param [String] milestone The name of the milestone we want to fetch the list of PRs for (e.g.: `16.9`)
       # @return [<Sawyer::Resource>] A list of the PRs for the given milestone, sorted by number
       #
-      def self.get_prs_for_milestone(repository, milestone)
-        github_client.search_issues(%(type:pr milestone:"#{milestone}" repo:#{repository}))[:items].sort_by(&:number)
+      def get_prs_for_milestone(repository, milestone)
+        client.search_issues(%(type:pr milestone:"#{milestone}" repo:#{repository}))[:items].sort_by(&:number)
       end
 
-      def self.get_last_milestone(repository)
+      def get_last_milestone(repository)
         options = {}
         options[:state] = 'open'
 
-        milestones = github_client().list_milestones(repository, options)
+        milestones = client.list_milestones(repository, options)
         return nil if milestones.nil?
 
         last_stone = nil
@@ -80,19 +71,42 @@ module Fastlane
         last_stone
       end
 
-      def self.create_milestone(repository, newmilestone_number, newmilestone_duedate, newmilestone_duration, number_of_days_from_code_freeze_to_release, need_submission)
-        # If there is a review process, we want to submit the binary 3 days before its release
-        #
-        # Using 3 days is mostly for historical reasons where we release the apps on Monday and submit them on Friday.
-        days_until_submission = need_submission ? (number_of_days_from_code_freeze_to_release - 3) : newmilestone_duration
-        submission_date = newmilestone_duedate.to_datetime.next_day(days_until_submission)
-        release_date = newmilestone_duedate.to_datetime.next_day(number_of_days_from_code_freeze_to_release)
-        comment = "Code freeze: #{newmilestone_duedate.to_datetime.strftime('%B %d, %Y')} App Store submission: #{submission_date.strftime('%B %d, %Y')} Release: #{release_date.strftime('%B %d, %Y')}"
+      # Creates a new milestone
+      #
+      # @param [String] repository The repository name, including the organization (e.g. `wordpress-mobile/wordpress-ios`)
+      # @param [String] title The name of the milestone we want to create (e.g.: `16.9`)
+      # @param [Time] due_date Milestone due date—which will also correspond to the code freeze date
+      # @param [Integer] days_until_submission Number of days from code freeze to submission to the App Store / Play Store
+      # @param [Integer] days_until_release Number of days from code freeze to release
+      #
+      def create_milestone(repository:, title:, due_date:, days_until_submission:, days_until_release:)
+        UI.user_error!('days_until_release must be greater than zero.') unless days_until_release.positive?
+        UI.user_error!('days_until_submission must be greater than zero.') unless days_until_submission.positive?
+        UI.user_error!('days_until_release must be greater or equal to days_until_submission.') unless days_until_release >= days_until_submission
+
+        submission_date = due_date.to_datetime.next_day(days_until_submission)
+        release_date = due_date.to_datetime.next_day(days_until_release)
+        comment = <<~MILESTONE_DESCRIPTION
+          Code freeze: #{due_date.to_datetime.strftime('%B %d, %Y')}
+          App Store submission: #{submission_date.strftime('%B %d, %Y')}
+          Release: #{release_date.strftime('%B %d, %Y')}
+        MILESTONE_DESCRIPTION
 
         options = {}
-        options[:due_on] = newmilestone_duedate
+        # == Workaround for GitHub API bug ==
+        #
+        # It seems that whatever date we send to the API, GitHub will 'floor' it to the date that seems to be at
+        # 00:00 PST/PDT and then discard the time component of the date we sent.
+        # This means that, when we cross the November DST change date, where the due date of the previous milestone
+        # was e.g. `2022-10-31T07:00:00Z` and `.next_day(14)` returns `2022-11-14T07:00:00Z` and we send that value
+        # for the `due_on` field via the API, GitHub ends up creating a milestone with a due of `2022-11-13T08:00:00Z`
+        # instead, introducing an off-by-one error on that due date.
+        #
+        # This is a bug in the GitHub API, not in our date computation logic.
+        # To solve this, we trick it by forcing the time component of the ISO date we send to be `12:00:00Z`.
+        options[:due_on] = due_date.strftime('%Y-%m-%dT12:00:00Z')
         options[:description] = comment
-        github_client().create_milestone(repository, newmilestone_number, options)
+        client.create_milestone(repository, title, options)
       end
 
       # Creates a Release on GitHub as a Draft
@@ -106,8 +120,8 @@ module Fastlane
       # @param [Array<String>] assets List of file paths to attach as assets to the release
       # @param [TrueClass|FalseClass] prerelease Indicates if this should be created as a pre-release (i.e. for alpha/beta)
       #
-      def self.create_release(repository:, version:, target: nil, description:, assets:, prerelease:)
-        release = github_client().create_release(
+      def create_release(repository:, version:, target: nil, description:, assets:, prerelease:)
+        release = client.create_release(
           repository,
           version, # tag name
           name: version, # release name
@@ -117,7 +131,7 @@ module Fastlane
           body: description
         )
         assets.each do |file_path|
-          github_client().upload_asset(release[:url], file_path, content_type: 'application/octet-stream')
+          client.upload_asset(release[:url], file_path, content_type: 'application/octet-stream')
         end
       end
 
@@ -129,15 +143,14 @@ module Fastlane
       # @param [String] download_folder The folder which the file should be downloaded into
       # @return [String] The path of the downloaded file, or nil if something went wrong
       #
-      def self.download_file_from_tag(repository:, tag:, file_path:, download_folder:)
+      def download_file_from_tag(repository:, tag:, file_path:, download_folder:)
         repository = repository.delete_prefix('/').chomp('/')
         file_path = file_path.delete_prefix('/').chomp('/')
         file_name = File.basename(file_path)
         download_path = File.join(download_folder, file_name)
 
-        download_url = github_client.contents(repository,
-                                              path: file_path,
-                                              ref: tag).download_url
+        download_url = client.contents(repository, path: file_path, ref: tag).download_url
+
         begin
           uri = URI.parse(download_url)
           uri.open do |remote_file|
@@ -151,8 +164,7 @@ module Fastlane
       end
 
       # Creates (or updates an existing) GitHub PR Comment
-      def self.comment_on_pr(project_slug:, pr_number:, body:, reuse_identifier: SecureRandom.uuid)
-        client = github_client
+      def comment_on_pr(project_slug:, pr_number:, body:, reuse_identifier: SecureRandom.uuid)
         comments = client.issue_comments(project_slug, pr_number)
 
         reuse_marker = "<!-- REUSE_ID: #{reuse_identifier} -->"
@@ -172,6 +184,58 @@ module Fastlane
 
         reuse_identifier
       end
+
+      # Update a milestone for a repository
+      #
+      # @param [String] repository The repository name (including the organization)
+      # @param [String] number The number of the milestone we want to fetch
+      # @param options [Hash] A customizable set of options.
+      # @option options [String] :title A unique title.
+      # @option options [String] :state
+      # @option options [String] :description A meaningful description
+      # @option options [Time] :due_on Set if the milestone has a due date
+      # @return [Milestone] A single milestone object
+      # @see http://developer.github.com/v3/issues/milestones/#update-a-milestone
+      #
+      def update_milestone(repository:, number:, **options)
+        client.update_milestone(repository, number, options)
+      end
+
+      # Remove the protection of a single branch from a repository
+      #
+      # @param [String] repository The repository name (including the organization)
+      # @param [String] branch The branch name
+      # @param [Hash] options A customizable set of options.
+      # @see https://docs.github.com/en/rest/branches/branch-protection#update-branch-protection
+      #
+      def remove_branch_protection(repository:, branch:, **options)
+        client.unprotect_branch(repository, branch, options)
+      end
+
+      # Protects a single branch from a repository
+      #
+      # @param [String] repository The repository name (including the organization)
+      # @param [String] branch The branch name
+      # @param options [Hash] A customizable set of options.
+      # @see https://docs.github.com/en/rest/branches/branch-protection#update-branch-protection
+      #
+      def set_branch_protection(repository:, branch:, **options)
+        client.protect_branch(repository, branch, options)
+      end
+
+      # Creates a GithubToken Fastlane ConfigItem
+      #
+      # @return [FastlaneCore::ConfigItem] The Fastlane ConfigItem for GitHub OAuth access token
+      #
+      def self.github_token_config_item
+        FastlaneCore::ConfigItem.new(
+          key: :github_token,
+          env_name: 'GITHUB_TOKEN',
+          description: 'The GitHub OAuth access token',
+          optional: false,
+          type: String
+        )
+      end
     end
   end
 end

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

@@ -36,6 +36,28 @@ module Fastlane
           end
         end
 
+        # Read a file line by line and iterate over it (just like `File.readlines` does),
+        # except that it also detects the encoding used by the file (using the BOM if present) when reading it,
+        # and then convert each line to UTF-8 before yielding it
+        #
+        # This is particularly useful if you need to then use a `RegExp` to match part of the lines you're iterating over,
+        # as the `RegExp` (which will typically be UTF-8) and the string you're matching with it have to use the same encoding
+        # (otherwise we would get a `Encoding::CompatibilityError`)
+        #
+        # @important If you are then using a `RegExp` to match the UTF-8 lines you iterate on,
+        # remember to use the `u` flag on it (`/…/u`) to make it UTF-8-aware too.
+        #
+        # @param [String] file The path to the file to read
+        # @yield each line read from the file, after converting it to the UTF-8 encoding
+        #
+        def self.read_utf8_lines(file)
+          # Be sure to guess file encoding using the Byte-Order-Mark, and fallback to UTF-8 if there's no BOM.
+          File.readlines(file, mode: 'rb:BOM|UTF-8').map do |line|
+            # Ensure the line is re-encoded to UTF-8 regardless of the encoding that was used in the input file
+            line.encode(Encoding::UTF_8)
+          end
+        end
+
         # Merge the content of multiple `.strings` files into a new `.strings` text file.
         #
         # @param [Hash<String, String>] paths The paths of the `.strings` files to merge together, associated with the prefix to prepend to each of their respective keys
@@ -68,11 +90,9 @@ module Fastlane
               all_keys_found += string_keys
 
               tmp_file.write("/* MARK: - #{File.basename(input_file)} */\n\n")
-              # Read line-by-line to reduce memory footprint during content copy; Be sure to guess file encoding using the Byte-Order-Mark.
-              File.readlines(input_file, mode: 'rb:BOM|UTF-8').each do |line|
+              # Read line-by-line to reduce memory footprint during content copy
+              read_utf8_lines(input_file).each do |line|
                 unless prefix.nil? || prefix.empty?
-                  # We need to ensure the line and RegExp are using the same encoding, so we transcode everything to UTF-8.
-                  line.encode!(Encoding::UTF_8)
                   # The `/u` modifier on the RegExps is to make them UTF-8
                   line.gsub!(/^(\s*")/u, "\\1#{prefix}") # Lines starting with a quote are considered to be start of a key; add prefix right after the quote
                   line.gsub!(/^(\s*)([A-Z0-9_]+)(\s*=\s*")/ui, "\\1\"#{prefix}\\2\"\\3") # Lines starting with an identifier followed by a '=' are considered to be an unquoted key (typical in InfoPlist.strings files for example)

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

@@ -11,25 +11,25 @@ module Fastlane
 
         TRANSITIONS = {
           root: {
-            /\s/ => :root,
+            /\s/u => :root,
             '/' => :maybe_comment_start,
             '"' => :in_quoted_key
           },
           maybe_comment_start: {
             '/' => :in_line_comment,
-            /\*/ => :in_block_comment
+            /\*/u => :in_block_comment
           },
           in_line_comment: {
             "\n" => :root,
-            /./ => :in_line_comment
+            /./u => :in_line_comment
           },
           in_block_comment: {
             /\*/ => :maybe_block_comment_end,
-            /./m => :in_block_comment
+            /./mu => :in_block_comment
           },
           maybe_block_comment_end: {
             '/' => :root,
-            /./m => :in_block_comment
+            /./mu => :in_block_comment
           },
           in_quoted_key: {
             '"' => lambda do |state, _|
@@ -37,25 +37,25 @@ module Fastlane
               state.buffer.string = ''
               :after_quoted_key_before_eq
             end,
-            /./ => lambda do |state, c|
+            /./u => lambda do |state, c|
               state.buffer.write(c)
               :in_quoted_key
             end
           },
           after_quoted_key_before_eq: {
-            /\s/ => :after_quoted_key_before_eq,
+            /\s/u => :after_quoted_key_before_eq,
             '=' => :after_quoted_key_and_eq
           },
           after_quoted_key_and_eq: {
-            /\s/ => :after_quoted_key_and_eq,
+            /\s/u => :after_quoted_key_and_eq,
             '"' => :in_quoted_value
           },
           in_quoted_value: {
             '"' => :after_quoted_value,
-            /./m => :in_quoted_value
+            /./mu => :in_quoted_value
           },
           after_quoted_value: {
-            /\s/ => :after_quoted_value,
+            /\s/u => :after_quoted_value,
             ';' => :root
           }
         }.freeze
@@ -70,7 +70,10 @@ module Fastlane
 
           state = State.new(context: :root, buffer: StringIO.new, in_escaped_ctx: false, found_key: nil)
 
-          File.readlines(file).each_with_index do |line, line_no|
+          # Using our `each_utf8_line` helper instead of `File.readlines` ensures we can also read files that are
+          # encoded in UTF-16, yet process each of their lines as a UTF-8 string, so that `RegExp#match?` don't throw
+          # an `Encoding::CompatibilityError` exception. (Note how all our `RegExp`s in `TRANSITIONS` have the `u` flag)
+          Fastlane::Helper::Ios::L10nHelper.read_utf8_lines(file).each_with_index do |line, line_no|
             line.chars.each_with_index do |c, col_no|
               # Handle escaped characters at a global level.
               # This is more straightforward than having to account for it in the `TRANSITIONS` table.

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

@@ -1,5 +1,5 @@
 module Fastlane
   module Wpmreleasetoolkit
-    VERSION = '5.5.0'
+    VERSION = '6.0.0'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-wpmreleasetoolkit
 version: !ruby/object:Gem::Version
-  version: 5.5.0
+  version: 6.0.0
 platform: ruby
 authors:
 - Automattic
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-09-15 00:00:00.000000000 Z
+date: 2022-11-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -260,14 +260,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2'
+        version: '2.210'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2'
+        version: '2.210'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -402,6 +402,7 @@ files:
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_bump_version_release.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_codefreeze_prechecks.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_completecodefreeze_prechecks.rb
+- lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_create_avd_action.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_create_xml_release_notes.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_current_branch_is_hotfix.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_download_file_by_version.rb
@@ -412,7 +413,9 @@ files:
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_get_app_version.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_get_release_version.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_hotfix_prechecks.rb
+- lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_launch_emulator_action.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_send_app_size_metrics.rb
+- lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_shutdown_emulator_action.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_tag_build.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/android/android_update_release_notes.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/common/buildkite_trigger_build_action.rb
@@ -471,8 +474,10 @@ files:
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/ios/ios_update_release_notes.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/ios/ios_validate_ci_build.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/helper/an_metadata_update_helper.rb
+- lib/fastlane/plugin/wpmreleasetoolkit/helper/android/android_emulator_helper.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/helper/android/android_git_helper.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/helper/android/android_localize_helper.rb
+- 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/ci_helper.rb