fastlane-plugin-wpmreleasetoolkit 2.3.0 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a9f3fcba792147f476a814f8f67f2620b5c6740497754eb033e2919e25dd3168
-  data.tar.gz: 25077b056c019d26adad929b9fffbf942c23f22a60f66892905de241b624b2bb
+  metadata.gz: 9e6b39530c08effa688004cbc0c5d8fa8f4fcf3ae5795cb028ca7b60d84f25e0
+  data.tar.gz: bccb8c68d90bbb681f2fc41e896f1af775bf141ccd28d83eb3aac1f7ba40e28a
 SHA512:
-  metadata.gz: d81b6b46eb930e0d15922c08eeea4314e9af06ef356b8dad207a6c76bec0793c1cf4e3c00507c16666170d3f6fe56960c9b3883ca567890e867fb1b50d064adf
-  data.tar.gz: a92daf218f3ec9094a0d26edd0f6be4a6062c83609618ccdae26980afe9efd8b10ec6e4192f73290526106f93b6b352c94e55e3944053806ea0d06548ed155c7
+  metadata.gz: 2d5324c615ca08aba37682e1cd6d613e885245f75f1cea5b459c644f083e8cd43af6ba6e6f93932ee7ce8e2a6bb21ed75a12f655610784494955226e2119fb54
+  data.tar.gz: d2fbbaeb3d7b753b400d77f33f8bf863a8eafc0dccdab8c4e36886f32af1b7791ca02a9dee75ad9ff09b29659d7af2887c4840d029411f6bc71be098378b8410

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

@@ -36,12 +36,17 @@ module Fastlane
           FastlaneCore::ConfigItem.new(key: :app_strings_path,
                                        description: 'The path of the main strings file',
                                        optional: false,
-                                       is_string: true),
+                                       type: String),
+          # The name of this parameter is a bit misleading due to legacy. In practice it's expected to be an Array of Hashes, each describing a library to merge.
+          # See `Fastlane::Helper::Android::LocalizeHelper.merge_lib`'s YARD doc for more details on the keys expected for each Hash.
           FastlaneCore::ConfigItem.new(key: :libs_strings_path,
                                        env_name: 'LOCALIZE_LIBS_STRINGS_PATH',
-                                       description: 'The list of libs to merge',
+                                       description: 'The list of libs to merge. ' \
+                                         + 'Each item in the provided array must be a Hash with the keys `:library` (The library display name),' \
+                                         + '`:strings_path` (The path to the `strings.xml` file of the library) and ' \
+                                         + '`:exclusions` (Array of string keys to exclude from merging)',
                                        optional: false,
-                                       is_string: false),
+                                       type: Array),
         ]
       end
 

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

@@ -0,0 +1,90 @@
+module Fastlane
+  module Actions
+    class BuildkiteTriggerBuildAction < Action
+      def self.run(params)
+        require 'buildkit'
+
+        UI.message "Triggering build on branch #{params[:branch]}, commit #{params[:commit]}, using pipeline from #{params[:pipeline_file]}"
+
+        pipeline_name = {
+          PIPELINE: params[:pipeline_file]
+        }
+
+        client = Buildkit.new(token: params[:buildkite_token])
+        response = client.create_build(
+          params[:buildkite_organization],
+          params[:buildkite_pipeline],
+          {
+            branch: params[:branch],
+            commit: params[:commit],
+            env: params[:environment].merge(pipeline_name)
+          }
+        )
+
+        response.state == 'scheduled' ? UI.message('Done!') : UI.crash!("Failed to start job\nError: [#{response}]")
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        'Triggers a job on Buildkite'
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(
+            key: :buildkite_token,
+            env_name: 'BUILDKITE_TOKEN',
+            description: 'Buildkite Personal Access Token',
+            type: String,
+            sensitive: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :buildkite_organization,
+            env_name: 'BUILDKITE_ORGANIZTION',
+            description: 'The Buildkite organization that contains your pipeline',
+            type: String
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :buildkite_pipeline,
+            env_name: 'BUILDKITE_PIPELINE',
+            description: %(The Buildkite pipeline you'd like to build),
+            type: String
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :branch,
+            description: 'The branch you want to build',
+            type: String
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :commit,
+            description: 'The commit hash you want to build',
+            type: String,
+            default_value: 'HEAD'
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :pipeline_file,
+            description: 'The name of the pipeline file in the project',
+            type: String
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :environment,
+            description: 'Any additional environment variables to provide to the job',
+            type: Hash,
+            default_value: {}
+          ),
+        ]
+      end
+
+      def self.authors
+        ['Automattic']
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

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

@@ -58,7 +58,7 @@ module Fastlane
                                        is_string: false),
           FastlaneCore::ConfigItem.new(key: :locales,
                                        env_name: 'FL_DOWNLOAD_METADATA_LOCALES',
-                                       description: 'The hash with the GLotPress locale and the project locale association',
+                                       description: 'The hash with the GlotPress locale and the project locale association',
                                        is_string: false),
           FastlaneCore::ConfigItem.new(key: :source_locale,
                                        env_name: 'FL_DOWNLOAD_METADATA_SOURCE_LOCALE',

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

@@ -0,0 +1,112 @@
+require 'fastlane/action'
+require 'digest/sha1'
+
+module Fastlane
+  module Actions
+    module SharedValues
+      S3_UPLOADED_FILE_PATH = :S3_UPLOADED_FILE_PATH
+    end
+
+    class UploadToS3Action < Action
+      def self.run(params)
+        file_path = params[:file]
+        file_name = File.basename(file_path)
+
+        bucket = params[:bucket]
+        key = params[:key] || file_name
+
+        if params[:auto_prefix] == true
+          file_name_hash = Digest::SHA1.hexdigest(file_name)
+          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)
+
+        UI.message("Uploading #{file_path} to: #{key}")
+
+        File.open(file_path, 'rb') do |file|
+          Aws::S3::Client.new().put_object(
+            body: file,
+            bucket: bucket,
+            key: key
+          )
+        rescue Aws::S3::Errors::ServiceError => e
+          UI.crash!("Unable to upload file to S3: #{e.message}")
+        end
+
+        UI.success('Upload Complete')
+
+        Actions.lane_context[SharedValues::S3_UPLOADED_FILE_PATH] = key
+
+        return key
+      end
+
+      def self.file_is_already_uploaded?(bucket, key)
+        response = Aws::S3::Client.new().head_object(
+          bucket: bucket,
+          key: key
+        )
+        return response[:content_length].positive?
+      rescue Aws::S3::Errors::NotFound
+        return false
+      end
+
+      def self.description
+        'Uploads a given file to S3'
+      end
+
+      def self.authors
+        ['Automattic']
+      end
+
+      def self.return_value
+        'Returns the object\'s derived S3 key'
+      end
+
+      def self.details
+        'Uploads a file to S3, and makes a pre-signed URL available in the lane context'
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(
+            key: :bucket,
+            description: 'The bucket that will store the file',
+            optional: false,
+            type: String,
+            verify_block: proc { |bucket| UI.user_error!('You must provide a valid bucket name') if bucket.empty? }
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :key,
+            description: 'The path to the file within the bucket. If `nil`, will default to the `file\'s basename',
+            optional: true,
+            type: String,
+            verify_block: proc { |key|
+              next if key.is_a?(String) && !key.empty?
+
+              UI.user_error!('The provided key must not be empty. Use nil instead if you want to default to the file basename')
+            }
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :file,
+            description: 'The path to the local file on disk',
+            optional: false,
+            type: String,
+            verify_block: proc { |f| UI.user_error!("Path `#{f}` does not exist.") unless File.file?(f) }
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :auto_prefix,
+            description: 'Generate a derived prefix based on the filename that makes it harder to guess the URL of the uploaded object',
+            optional: true,
+            default_value: true,
+            type: Boolean
+          ),
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,114 @@
+module Fastlane
+  module Actions
+    class IosDownloadStringsFilesFromGlotpressAction < Action
+      def self.run(params)
+        # TODO: Once we introduce the `Locale` POD via #296, check if the param is an array of locales and if so convert it to Hash{glotpress=>lproj}
+        locales = params[:locales]
+        download_dir = params[:download_dir]
+
+        UI.user_error!("The parent directory `#{download_dir}` (which contains all the `*.lproj` subdirectories) must already exist") unless Dir.exist?(download_dir)
+
+        locales.each do |glotpress_locale, lproj_name|
+          # Download the export in the proper `.lproj` directory
+          UI.message "Downloading translations for '#{lproj_name}' from GlotPress (#{glotpress_locale}) [#{params[:filters]}]..."
+          lproj_dir = File.join(download_dir, "#{lproj_name}.lproj")
+          destination = File.join(lproj_dir, "#{params[:table_basename]}.strings")
+          FileUtils.mkdir(lproj_dir) unless Dir.exist?(lproj_dir)
+
+          Fastlane::Helper::Ios::L10nHelper.download_glotpress_export_file(
+            project_url: params[:project_url],
+            locale: glotpress_locale,
+            filters: params[:filters],
+            destination: destination
+          )
+          # Do a quick check of the downloaded `.strings` file to ensure it looks valid
+          validate_strings_file(destination) unless params[:skip_file_validation]
+        end
+      end
+
+      # Validate that a `.strings` file downloaded from GlotPress seems valid and does not contain empty translations
+      def self.validate_strings_file(destination)
+        return unless File.exist?(destination) # If the file failed to download, don't try to validate an non-existing file. We'd already have a separate error for the download failure anyway.
+
+        translations = Fastlane::Helper::Ios::L10nHelper.read_strings_file_as_hash(path: destination)
+        empty_keys = translations.select { |_, value| value.nil? || value.empty? }.keys.sort
+        unless empty_keys.empty?
+          UI.error(
+            "Found empty translations in `#{destination}` for the following keys: #{empty_keys.inspect}.\n" \
+              + "This is likely a GlotPress bug, and will lead to copies replaced by empty text in the UI.\n" \
+              + 'Please report this to the GlotPress team, and fix the file locally before continuing.'
+          )
+        end
+      rescue StandardError => e
+        UI.error("Error while validating the file exported from GlotPress (`#{destination}`) - #{e.message.chomp}")
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        'Downloads the `.strings` files from GlotPress for the various locales'
+      end
+
+      def self.details
+        <<~DETAILS
+          Downloads the `.strings` files from GlotPress for the various locales,
+          validates them, and saves them in the relevant `*.lproj` directories for each locale
+        DETAILS
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :project_url,
+                                       env_name: 'FL_IOS_DOWNLOAD_STRINGS_FILES_FROM_GLOTPRESS_PROJECT_URL',
+                                       description: 'URL to the GlotPress project',
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :locales,
+                                       env_name: 'FL_IOS_DOWNLOAD_STRINGS_FILES_FROM_GLOTPRESS_LOCALES',
+                                       description: 'The map of locales to download, each entry of the Hash corresponding to a { glotpress-locale-code => lproj-folder-basename } pair',
+                                       type: Hash), # TODO: also support an Array of `Locale` POD/struct type when we introduce it later (see #296)
+          FastlaneCore::ConfigItem.new(key: :download_dir,
+                                       env_name: 'FL_IOS_DOWNLOAD_STRINGS_FILES_FROM_GLOTPRESS_DOWNLOAD_DIR',
+                                       description: 'The parent directory containing all the `*.lproj` subdirectories in which the downloaded files will be saved',
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :table_basename,
+                                       env_name: 'FL_IOS_DOWNLOAD_STRINGS_FILES_FROM_GLOTPRESS_TABLE_BASENAME',
+                                       description: 'The basename to save the `.strings` files under',
+                                       type: String,
+                                       optional: true,
+                                       default_value: 'Localizable'),
+          FastlaneCore::ConfigItem.new(key: :filters,
+                                       env_name: 'FL_IOS_DOWNLOAD_STRINGS_FILES_FROM_GLOTPRESS_FILTERS',
+                                       description: 'The GlotPress filters to use when requesting the translations export',
+                                       type: Hash,
+                                       optional: true,
+                                       default_value: { status: 'current' }),
+          FastlaneCore::ConfigItem.new(key: :skip_file_validation,
+                                       env_name: 'FL_IOS_DOWNLOAD_STRINGS_FILES_FROM_GLOTPRESS_SKIP_FILE_VALIDATION',
+                                       description: 'If true, skips the validation of `.strings` files after download',
+                                       type: Fastlane::Boolean,
+                                       optional: true,
+                                       default_value: false),
+        ]
+      end
+
+      def self.return_type
+        # Describes what type of data is expected to be returned
+        # see RETURN_TYPES in https://github.com/fastlane/fastlane/blob/master/fastlane/lib/fastlane/action.rb
+      end
+
+      def self.return_value
+        # Textual description of what the return value is
+      end
+
+      def self.authors
+        ['Automattic']
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,136 @@
+module Fastlane
+  module Actions
+    class IosExtractKeysFromStringsFilesAction < Action
+      def self.run(params)
+        source_parent_dir = params[:source_parent_dir]
+        target_original_files = params[:target_original_files].keys # Array [original-file-paths]
+        keys_to_extract_per_target_file = keys_list_per_target_file(target_original_files) # Hash { original-file-path => [keys] }
+        prefix_to_remove_per_target_file = params[:target_original_files] # Hash { original-file-path => prefix }
+
+        UI.message("Extracting keys from `#{source_parent_dir}/*.lproj/#{params[:source_tablename]}.strings` into:")
+        target_original_files.each { |f| UI.message(' - ' + replace_lproj_in_path(f, with_lproj: '*.lproj')) }
+
+        updated_files_list = []
+
+        # For each locale, extract the right translations from `<source_tablename>.strings` into each target `.strings` file
+        Dir.glob('*.lproj', base: source_parent_dir).each do |lproj_dir_name|
+          source_strings_file = File.join(source_parent_dir, lproj_dir_name, "#{params[:source_tablename]}.strings")
+          translations = Fastlane::Helper::Ios::L10nHelper.read_strings_file_as_hash(path: source_strings_file)
+
+          target_original_files.each do |target_original_file|
+            target_strings_file = replace_lproj_in_path(target_original_file, with_lproj: lproj_dir_name)
+            next if target_strings_file == target_original_file # do not generate/overwrite the original locale itself
+
+            keys_prefix = prefix_to_remove_per_target_file[target_original_file] || ''
+            keys_to_extract = keys_to_extract_per_target_file[target_original_file].map { |k| "#{keys_prefix}#{k}" }
+            extracted_translations = translations.slice(*keys_to_extract).transform_keys { |k| k.delete_prefix(keys_prefix) }
+            UI.verbose("Extracting #{extracted_translations.count} keys (out of #{keys_to_extract.count} expected) into #{target_strings_file}...")
+
+            FileUtils.mkdir_p(File.dirname(target_strings_file)) # Ensure path up to parent dir exists, create it if not.
+            Fastlane::Helper::Ios::L10nHelper.generate_strings_file_from_hash(translations: extracted_translations, output_path: target_strings_file)
+            updated_files_list.append(target_strings_file)
+          rescue StandardError => e
+            UI.user_error!("Error while writing extracted translations to `#{target_strings_file}`: #{e.message}")
+          end
+        rescue StandardError => e
+          UI.user_error!("Error while reading the translations from source file `#{source_strings_file}`: #{e.message}")
+        end
+
+        updated_files_list
+      end
+
+      # Pre-load the list of keys to extract for each target file.
+      #
+      # @param [Array<String>] original_files array of paths to the originals of target files
+      # @return [Hash<String, Array<String>>] The hash listing the keys to extract for each target file
+      #
+      def self.keys_list_per_target_file(original_files)
+        original_files.map do |original_file|
+          keys = Fastlane::Helper::Ios::L10nHelper.read_strings_file_as_hash(path: original_file).keys
+          [original_file, keys]
+        end.to_h
+      rescue StandardError => e
+        UI.user_error!("Failed to read the keys to extract from originals file: #{e.message}")
+      end
+
+      # Replaces the `*.lproj` component of the path to a `.strings` file with a different `.lproj` folder
+      #
+      # @param [String] path The path the the `.strings` file, assumed to be in a `.lproj` parent folder
+      # @param [String] with_lproj The new name of the `.lproj` parent folder to point to
+      #
+      def self.replace_lproj_in_path(path, with_lproj:)
+        File.join(File.dirname(File.dirname(path)), with_lproj, File.basename(path))
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        'Extracts a subset of keys from a `.strings` file into separate `.strings` file(s)'
+      end
+
+      def self.details
+        <<~DETAILS
+          Extracts a subset of keys from a `.strings` file into separate `.strings` file(s), for each `*.lproj` subdirectory.
+
+          This is especially useful to extract, for each locale, the translations for files like `InfoPlist.strings` or
+          `<SomeIntentDefinitionFile>.strings` from the `Localizable.strings` file that we exported/downloaded back from GlotPress.
+
+          Since we typically merge all `*.strings` original files (e.g. `en.lproj/Localizable.strings` + `en.lproj/InfoPlist.strings` + …)
+          via `ios_merge_strings_file` before sending the originals to translations, we then need to extract the relevant keys and
+          translations back into the `*.lproj/InfoPlist.strings` after we pull those translations back from GlotPress
+          (`ios_download_strings_files_from_glotpress`). This is what this `ios_extract_keys_from_strings_files` action is for.
+        DETAILS
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :source_parent_dir,
+                                       env_name: 'FL_IOS_EXTRACT_KEYS_FROM_STRINGS_FILES_SOURCE_PARENT_DIR',
+                                       description: 'The parent directory containing all the `*.lproj` subdirectories in which the source `.strings` files reside',
+                                       type: String,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("`source_parent_dir` should be a path to an existing directory, but found `#{value}`.") unless File.directory?(value)
+                                         UI.user_error!("`source_parent_dir` should contain at least one `.lproj` subdirectory, but `#{value}` does not contain any.") if Dir.glob('*.lproj', base: value).empty?
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :source_tablename,
+                                       env_name: 'FL_IOS_EXTRACT_KEYS_FROM_STRINGS_FILES_SOURCE_TABLENAME',
+                                       description: 'The basename of the `.strings` file (without the extension) to extract the keys and translations from for each locale',
+                                       type: String,
+                                       default_value: 'Localizable'),
+          FastlaneCore::ConfigItem.new(key: :target_original_files,
+                                       env_name: 'FL_IOS_EXTRACT_KEYS_FROM_STRINGS_FILES_TARGET_ORIGINAL_FILES',
+                                       description: 'The path(s) to the `<base-locale>.lproj/<target-tablename>.strings` file(s) for which we want to extract the keys to, and the prefix to remove from their keys. ' \
+                                        + 'Each key in the Hash should point to a file containing the original strings (typically `en` or `Base` locale), and will be used to determine which keys to extract from the `source_tablename`. ' \
+                                        + 'For each key, the associated value is an optional prefix to remove from the keys (which can be useful if you used a prefix during `ios_merge_strings_files` to avoid duplicates). Can be nil or empty if no prefix was used during merge for that file.' \
+                                        + 'Note: For each entry, the path(s) in which the translations will be extracted to will be the files with the same basename as the key in each of the other `*.lproj` sibling folders. ',
+                                       type: Hash,
+                                       verify_block: proc do |values|
+                                         UI.user_error!('`target_original_files` must contain at least one path to an original `.strings` file.') if values.empty?
+                                         values.each do |path, _|
+                                           UI.user_error!("Path `#{path}` (found in `target_original_files`) does not exist.") unless File.exist?(path)
+                                           UI.user_error! "Expected `#{path}` (found in `target_original_files`) to be a path ending in a `*.lproj/*.strings`." unless File.extname(path) == '.strings' && File.extname(File.dirname(path)) == '.lproj'
+                                         end
+                                       end),
+        ]
+      end
+
+      def self.return_type
+        :array_of_strings
+      end
+
+      def self.return_value
+        'The list of files which have been generated and written to disk by the action'
+      end
+
+      def self.authors
+        ['Automattic']
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+    end
+  end
+end

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

@@ -36,7 +36,7 @@ module Fastlane
       #####################################################
 
       def self.description
-        'Generate the .strings files from your Objective-C and Swift code'
+        'Generate the `.strings` files from your Objective-C and Swift code'
       end
 
       def self.details

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

@@ -17,8 +17,8 @@ module Fastlane
       def self.run_linter(params)
         UI.message 'Linting localizations for parameter placeholders consistency...'
 
-        require_relative '../../helper/ios/ios_l10n_helper'
-        helper = Fastlane::Helper::Ios::L10nHelper.new(
+        require_relative '../../helper/ios/ios_l10n_linter_helper'
+        helper = Fastlane::Helper::Ios::L10nLinterHelper.new(
           install_path: resolve_path(params[:install_path]),
           version: params[:version]
         )
@@ -92,7 +92,7 @@ module Fastlane
             description: 'The path where to install the SwiftGen tooling needed to run the linting process. If a relative path, should be relative to your repo_root',
             type: String,
             optional: true,
-            default_value: "vendor/swiftgen/#{Fastlane::Helper::Ios::L10nHelper::SWIFTGEN_VERSION}"
+            default_value: "vendor/swiftgen/#{Fastlane::Helper::Ios::L10nLinterHelper::SWIFTGEN_VERSION}"
           ),
           FastlaneCore::ConfigItem.new(
             key: :version,
@@ -100,7 +100,7 @@ module Fastlane
             description: 'The version of SwiftGen to install and use for linting',
             type: String,
             optional: true,
-            default_value: Fastlane::Helper::Ios::L10nHelper::SWIFTGEN_VERSION
+            default_value: Fastlane::Helper::Ios::L10nLinterHelper::SWIFTGEN_VERSION
           ),
           FastlaneCore::ConfigItem.new(
             key: :input_dir,
@@ -115,7 +115,7 @@ module Fastlane
             description: 'The language that should be used as the base language that every other language will be compared against',
             type: String,
             optional: true,
-            default_value: Fastlane::Helper::Ios::L10nHelper::DEFAULT_BASE_LANG
+            default_value: Fastlane::Helper::Ios::L10nLinterHelper::DEFAULT_BASE_LANG
           ),
           FastlaneCore::ConfigItem.new(
             key: :only_langs,

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

@@ -16,11 +16,11 @@ module Fastlane
       #####################################################
 
       def self.description
-        'Gathers the string to localise'
+        'Gathers the strings to localise. Deprecated'
       end
 
       def self.details
-        'Gathers the string to localise. Deprecated in favor of the new `ios_generate_strings_file_from_code`'
+        'Gathers the strings to localise. Deprecated in favor of the new `ios_generate_strings_file_from_code`'
       end
 
       def self.category

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

@@ -0,0 +1,79 @@
+module Fastlane
+  module Actions
+    class IosMergeStringsFilesAction < Action
+      def self.run(params)
+        destination = params[:destination]
+        # Include the destination as the first of the files (without key prefixes) to be included in the merged result
+        all_paths_list = { destination => nil }.merge(params[:paths_to_merge])
+
+        UI.message "Merging strings files #{all_paths_list.inspect}"
+
+        File.write(destination, '') unless File.exist?(destination) # Create empty destination file if it does not exist yet
+        duplicates = Fastlane::Helper::Ios::L10nHelper.merge_strings(paths: all_paths_list, output_path: params[:destination])
+        duplicates.each do |dup_key|
+          UI.important "Duplicate key found while merging the `.strings` files: `#{dup_key}`"
+        end
+        UI.important 'Tip: To avoid those key conflicts, you might want to consider providing different prefixes in the `Hash` you used for the `paths:` parameter.' unless duplicates.empty?
+        duplicates
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        'Merge multiple `.strings` files into one'
+      end
+
+      def self.details
+        <<~DETAILS
+          Merge multiple `.strings` files into another one.
+
+          Especially useful to prepare a single `.strings` file merging string files like `InfoPlist.strings` — whose
+          content are typically manually maintained by developers — within the main `Localizable.strings` file — which
+          would have typically been previously generated from the codebase via `ios_generate_strings_file_from_code`.
+
+          The action only supports merging files which are in the OpenStep (`"key" = "value";`) text format (which is
+          the most common format for `.strings` files, and the one generated by `genstrings`), but can handle the case
+          of different files using different encodings (UTF8 vs UTF16) and is able to detect and report duplicates.
+          It does not handle `.strings` files in XML or binary-plist formats (which are valid but more rare)
+        DETAILS
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(
+            key: :paths_to_merge,
+            env_name: 'FL_IOS_MERGE_STRINGS_FILES_PATHS_TO_MERGE',
+            description: 'A hash of the paths of all the `.strings` files to merge into the `destination`, with the prefix to be used for their keys as associated value',
+            type: Hash,
+            optional: false
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :destination,
+            env_name: 'FL_IOS_MERGE_STRINGS_FILES_DESTINATION',
+            description: 'The path of the `.strings` file to merge the other ones into',
+            type: String,
+            optional: false
+          ),
+        ]
+      end
+
+      def self.return_type
+        :array_of_strings
+      end
+
+      def self.return_value
+        'The list of duplicate keys (after prefix has been added to each) found while merging the various `.strings` files'
+      end
+
+      def self.authors
+        ['automattic']
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include? platform
+      end
+    end
+  end
+end