fastlane-plugin-wpmreleasetoolkit 3.0.0 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d2f92b2b90c9f077ad4ea0ae25c5c84f0345ca2fb5e186d1c0cdfab70ea40770
-  data.tar.gz: 0c919f8e9ca2af18c3488898efe2fe48f4ca5a3a4c0464991e000681cc6c9546
+  metadata.gz: ee81192aaa403dc7878821f60017e13f9867c549ba84ba2912d1e3ae0623b7b8
+  data.tar.gz: a702bfd98e9134e8d3f4303a1bad07705e6b27c107ead1295f5583a78b40384e
 SHA512:
-  metadata.gz: f0c0797c28da54495d995d856edb238631b70bf0126ae1516638a75e300717dd51a7f97f6fedd5cc3f9e7eef4e9cf328043c9fffcd34233a057338da8055307d
-  data.tar.gz: 17c8536dc94ab2ea0f3b394d3d9768c248683ba78fa4558d7c10ed1cc7fe81fc0aebd1390691282db601297b6f48e67af2dbd546daa3b0a13d16ffacd8c34f4c
+  metadata.gz: 87379c5741f84f94127d0388e24080c9e861a37115c16b5e6116afd7e1e13c143c748624870740ff2c25c82eb450d910219abd9c56bddf9fabfcb5494f826df4
+  data.tar.gz: 51493b07f6a15c38147e7b25607b63d4f5808ee334ff0ec7a3a65d52f33cf8a4d71a46aa189f680324ca67023d1072f2b9a115899b4cecabe0ad90c92ccdfe91

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

@@ -32,6 +32,14 @@ module Fastlane
       end
 
       def self.available_options
+        libs_hash_description = <<~KEYS
+          - `:library`: The library display name.
+          - `:strings_path`: The path to the `strings.xml` file of the library.
+          - `:exclusions`: An optional `Array` of string keys to exclude from merging.
+          - `:source_id`: An optional `String` which will be added as the `a8c-src-lib` XML attribute
+            to strings coming from this library, to help identify their source in the merged file.
+          - `:add_ignore_attr`: If set to true, will add `tools:ignore="UnusedResources"` to merged strings.
+        KEYS
         [
           FastlaneCore::ConfigItem.new(key: :app_strings_path,
                                        description: 'The path of the main strings file',
@@ -41,10 +49,7 @@ module Fastlane
           # 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. ' \
-                                         + '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)',
+                                       description: "The list of libs to merge. Each item in the provided array must be a Hash with the following keys:\n#{libs_hash_description}",
                                        optional: false,
                                        type: Array),
         ]

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/configure/configure_download_action.rb

@@ -17,8 +17,7 @@ module Fastlane
       end
 
       # Ensure the git repository at `~/.mobile-secrets` is up to date.
-      # If the secrets repo is in a detached HEAD state, skip the pull,
-      # since it will fail.
+      # If the secrets repo is in a detached HEAD state, skip the pull, since it will fail.
       def self.update_repository
         secrets_repo_branch = Fastlane::Helper::ConfigureHelper.repo_branch_name
 

data/lib/fastlane/plugin/wpmreleasetoolkit/actions/configure/configure_validate_action.rb

@@ -15,8 +15,8 @@ module Fastlane
         # otherwise, the error messaging isn't as helpful.
         validate_that_secrets_repo_is_clean
 
-        # Update the repository to get the latest version of the configuration secrets – that's
-        # how we'll know if we're behind in subsequent validations
+        # Update the repository to get the latest version of the configuration secrets
+        # – that's how we'll know if we're behind in subsequent validations
         ConfigureDownloadAction.run
 
         validate_that_branches_match

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

@@ -10,6 +10,7 @@ module Fastlane
 
         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)

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

@@ -22,17 +22,17 @@ module Fastlane
           install_path: resolve_path(params[:install_path]),
           version: params[:version]
         )
-        violations = helper.run(
+        all_violations = helper.run(
           input_dir: resolve_path(params[:input_dir]),
           base_lang: params[:base_lang],
           only_langs: params[:only_langs]
         )
 
-        violations.each do |lang, diff|
-          UI.error "Inconsistencies found between '#{params[:base_lang]}' and '#{lang}':\n\n#{diff}\n"
+        all_violations.each do |lang, lang_violations|
+          UI.error "Inconsistencies found between '#{params[:base_lang]}' and '#{lang}':\n\n#{lang_violations.join("\n")}\n"
         end
 
-        violations
+        all_violations
       end
 
       RETRY_MESSAGE = <<~MSG
@@ -148,15 +148,15 @@ module Fastlane
       end
 
       def self.return_type
-        :hash_of_strings
+        :hash
       end
 
       def self.return_value
-        'A hash, keyed by language code, whose values are the diff found for said language'
+        'A hash, keyed by language code, whose values are arrays of violations found for that language'
       end
 
       def self.authors
-        ['AliSoftware']
+        ['Automattic']
       end
 
       def self.is_supported?(platform)

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

@@ -2,12 +2,18 @@ module Fastlane
   module Actions
     class IosMergeStringsFilesAction < Action
       def self.run(params)
-        UI.message "Merging strings files: #{params[:paths].inspect}"
+        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])
 
-        duplicates = Fastlane::Helper::Ios::L10nHelper.merge_strings(paths: params[:paths], output_path: params[:destination])
+        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
 
@@ -21,12 +27,11 @@ module Fastlane
 
       def self.details
         <<~DETAILS
-          Merge multiple `.strings` files into one.
+          Merge multiple `.strings` files into another one.
 
-          Especially useful to prepare a single `.strings` file merging strings from both `Localizable.strings` from
-          the app code — typically previously extracted from `ios_generate_strings_file_from_code` —
-          and string files like `InfoPlist.strings` — which values may not be generated from the codebase but
-          manually maintained by developers.
+          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
@@ -38,19 +43,18 @@ module Fastlane
       def self.available_options
         [
           FastlaneCore::ConfigItem.new(
-            key: :paths,
-            env_name: 'FL_IOS_MERGE_STRINGS_FILES_PATHS',
-            description: 'The paths of all the `.strings` files to merge together',
-            type: Array,
+            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 merged `.strings` file to generate. If nil, the merge will happen in-place in the first file in the `paths:` list',
+            description: 'The path of the `.strings` file to merge the other ones into',
             type: String,
-            optional: true,
-            default_value: nil
+            optional: false
           ),
         ]
       end
@@ -60,7 +64,7 @@ module Fastlane
       end
 
       def self.return_value
-        'The list of duplicate keys found while merging the various `.strings` files'
+        'The list of duplicate keys (after prefix has been added to each) found while merging the various `.strings` files'
       end
 
       def self.authors

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

@@ -9,86 +9,99 @@ module Fastlane
   module Helper
     module Android
       module LocalizeHelper
-        # Checks if string_line has the content_override flag set
-        def self.skip_string_by_tag(string_line)
-          skip = string_line.attr('content_override') == 'true' unless string_line.attr('content_override').nil?
+        LIB_SOURCE_XML_ATTR = 'a8c-src-lib'.freeze
+
+        # Checks if `string_node` has the `content_override` flag set
+        def self.skip_string_by_tag?(string_node)
+          skip = string_node.attr('content_override') == 'true' unless string_node.attr('content_override').nil?
           if skip
-            puts " - Skipping #{string_line.attr('name')} string"
+            UI.message " - Skipping #{string_node.attr('name')} string"
             return true
           end
 
           return false
         end
 
-        # Checks if string_name is in the excluesion list
-        def self.skip_string_by_exclusion_list(library, string_name)
-          return false unless library.key?(:exclusions)
+        # Checks if `string_name` is in the exclusion list
+        def self.skip_string_by_exclusion_list?(library, string_name)
+          return false if library[:exclusions].nil?
 
           skip = library[:exclusions].include?(string_name)
           if skip
-            puts " - Skipping #{string_name} string"
+            UI.message " - Skipping #{string_name} string"
             return true
           end
         end
 
-        # Merge string_line into main_string
-        def self.merge_string(main_strings, library, string_line)
-          string_name = string_line.attr('name')
-          string_content = string_line.content
+        # Adds the appropriate XML attributes to an XML `<string>` node according to library configuration
+        def self.add_xml_attributes!(string_node, library)
+          if library[:add_ignore_attr] == true
+            existing_ignores = (string_node['tools:ignore'] || '').split(',')
+            existing_ignores.append('UnusedResources') unless existing_ignores.include?('UnusedResources')
+            string_node['tools:ignore'] = existing_ignores.join(',')
+          end
+          string_node[LIB_SOURCE_XML_ATTR] = library[:source_id] unless library[:source_id].nil?
+        end
+
+        # Merge a single `lib_string_node` XML node into the `main_strings_xml``
+        def self.merge_string_node(main_strings_xml, library, lib_string_node)
+          string_name = lib_string_node.attr('name')
+          string_content = lib_string_node.content
 
           # Skip strings in the exclusions list
-          return :skipped if skip_string_by_exclusion_list(library, string_name)
+          return :skipped if skip_string_by_exclusion_list?(library, string_name)
 
           # Search for the string in the main file
           result = :added
-          main_strings.xpath('//string').each do |this_string|
-            if this_string.attr('name') == string_name
+          main_strings_xml.xpath('//string').each do |main_string_node|
+            if main_string_node.attr('name') == string_name
               # Skip if the string has the content_override tag
-              return :skipped if skip_string_by_tag(this_string)
+              return :skipped if skip_string_by_tag?(main_string_node)
 
               # If nodes are equivalent, skip
-              return :found if string_line =~ this_string
+              return :found if lib_string_node =~ main_string_node
 
               # The string needs an update
-              result = :updated
-              if this_string.attr('tools:ignore').nil?
-                # It can be updated, so remove the current one and move ahead
-                this_string.remove
-                break
+              if main_string_node.attr('tools:ignore').nil?
+                # No `tools:ignore` attribute; completely replace existing main string node with lib's one
+                add_xml_attributes!(lib_string_node, library)
+                main_string_node.replace lib_string_node
               else
-                # It has the tools:ignore flag, so update the content without touching the other attributes
-                this_string.content = string_content
-                return result
+                # Has the `tools:ignore` flag; update the content without touching the other existing attributes
+                add_xml_attributes!(main_string_node, library)
+                main_string_node.content = string_content
               end
+              return :updated
             end
           end
 
           # String not found, or removed because needing update and not in the exclusion list: add to the main file
-          main_strings.xpath('//string').last().add_next_sibling("\n#{' ' * 4}#{string_line.to_xml().strip}")
+          add_xml_attributes!(lib_string_node, library)
+          main_strings_xml.xpath('//string').last().add_next_sibling("\n#{' ' * 4}#{lib_string_node.to_xml().strip}")
           return result
         end
 
-        # Verify a string
-        def self.verify_string(main_strings, library, string_line)
-          string_name = string_line.attr('name')
-          string_content = string_line.content
+        # Verify a string node from a library has properly been merged into the main one
+        def self.verify_string(main_strings_xml, library, lib_string_node)
+          string_name = lib_string_node.attr('name')
+          string_content = lib_string_node.content
 
           # Skip strings in the exclusions list
-          return if skip_string_by_exclusion_list(library, string_name)
+          return if skip_string_by_exclusion_list?(library, string_name)
 
           # Search for the string in the main file
-          main_strings.xpath('//string').each do |this_string|
-            if this_string.attr('name') == string_name
+          main_strings_xml.xpath('//string').each do |main_string_node|
+            if main_string_node.attr('name') == string_name
               # Skip if the string has the content_override tag
-              return if skip_string_by_tag(this_string)
+              return if skip_string_by_tag?(main_string_node)
 
-              # Update if needed
-              UI.user_error!("String #{string_name} [#{string_content}] has been updated in the main file but not in the library #{library[:library]}.") if this_string.content != string_content
+              # Check if up-to-date
+              UI.user_error!("String #{string_name} [#{string_content}] has been updated in the main file but not in the library #{library[:library]}.") if main_string_node.content != string_content
               return
             end
           end
 
-          # String not found and not in the exclusion list:
+          # String not found and not in the exclusion list
           UI.user_error!("String #{string_name} [#{string_content}] was found in library #{library[:library]} but not in the main file.")
         end
 
@@ -98,27 +111,33 @@ module Fastlane
         # @param [Hash] library Hash describing the library to merge. The Hash should contain the following keys:
         #                       - `:library`: The human readable name of the library, used to display in console messages
         #                       - `:strings_path`: The path to the strings.xml file of the library to merge into the main one
-        #                       - `:exclusions`: An array of strings keys to exclude during merge. Any of those keys from the library's `strings.xml` will be skipped and won't be merged into the main one.
+        #                       - `:exclusions`: An array of strings keys to exclude during merge. Any of those keys from the
+        #                         library's `strings.xml` will be skipped and won't be merged into the main one.
+        #                       - `:source_id`: An optional `String` which will be added as the `a8c-src-lib` XML attribute
+        #                         to strings coming from this library, to help identify their source in the merged file.
+        #                       - `:add_ignore_attr`: If set to `true`, will add `tools:ignore="UnusedResources"` to merged strings.
+        #
         # @return [Boolean] True if at least one string from the library has been added to (or has updated) the main strings file.
+        #
         def self.merge_lib(main, library)
           UI.message("Merging #{library[:library]} strings into #{main}")
-          main_strings = File.open(main) { |f| Nokogiri::XML(f, nil, Encoding::UTF_8.to_s) }
-          lib_strings = File.open(library[:strings_path]) { |f| Nokogiri::XML(f, nil, Encoding::UTF_8.to_s) }
+          main_strings_xml = File.open(main) { |f| Nokogiri::XML(f, nil, Encoding::UTF_8.to_s) }
+          lib_strings_xml = File.open(library[:strings_path]) { |f| Nokogiri::XML(f, nil, Encoding::UTF_8.to_s) }
 
           updated_count = 0
           untouched_count = 0
           added_count = 0
           skipped_count = 0
-          lib_strings.xpath('//string').each do |string_line|
-            res = merge_string(main_strings, library, string_line)
+          lib_strings_xml.xpath('//string').each do |string_node|
+            res = merge_string_node(main_strings_xml, library, string_node)
             case res
             when :updated
-              puts "#{string_line.attr('name')} updated."
+              UI.verbose "#{string_node.attr('name')} updated."
               updated_count = updated_count + 1
             when :found
               untouched_count = untouched_count + 1
             when :added
-              puts "#{string_line.attr('name')} added."
+              UI.verbose "#{string_node.attr('name')} added."
               added_count = added_count + 1
             when :skipped
               skipped_count = skipped_count + 1
@@ -128,7 +147,7 @@ module Fastlane
           end
 
           File.open(main, 'w:UTF-8') do |f|
-            f.write(main_strings.to_xml(indent: 4))
+            f.write(main_strings_xml.to_xml(indent: 4))
           end
 
           UI.message("Done (#{added_count} added, #{updated_count} updated, #{untouched_count} untouched, #{skipped_count} skipped).")
@@ -144,8 +163,8 @@ module Fastlane
 
             diff_string = diff_string.slice(0..(end_index - 1))
 
-            lib_strings.xpath('//string').each do |string_line|
-              res = verify_string(main_strings, library, string_line) if string_line.attr('name') == diff_string
+            lib_strings.xpath('//string').each do |string_node|
+              res = verify_string(main_strings, library, string_node) if string_node.attr('name') == diff_string
             end
           end
         end

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

@@ -8,14 +8,11 @@ module Fastlane
       # Fallback default branch of the client repository.
       DEFAULT_GIT_BRANCH = 'trunk'.freeze
 
-      # Checks if the given path, or current directory if no path is given, is
-      # inside a Git repository
+      # Checks if the given path, or current directory if no path is given, is inside a Git repository
       #
-      # @param [String] path An optional path where to check if a Git repo
-      #        exists.
+      # @param [String] path An optional path where to check if a Git repo exists.
       #
-      # @return [Bool] True if the current directory is the root of a git repo
-      #         (i.e. a local working copy) or a subdirectory of one.
+      # @return [Bool] True if the current directory is the root of a git repo (i.e. a local working copy) or a subdirectory of one.
       #
       def self.is_git_repo?(path: Dir.pwd)
         # If the path doesn't exist, find its first ancestor.
@@ -23,23 +20,19 @@ module Fastlane
         # Get the path's directory, so we can look in it for the Git folder
         dir = path.directory? ? path : path.dirname
 
-        # Recursively look for the Git folder until it's found or we read the
-        # the file system root
+        # Recursively look for the Git folder until it's found or we read the the file system root
         dir = dir.parent until Dir.entries(dir).include?('.git') || dir.root?
 
-        # If we reached the root, we haven't found a repo. (Technically, there
-        # could be a repo in the root of the system, but that's a usecase that
-        # we don't need to support at this time)
+        # If we reached the root, we haven't found a repo.
+        # (Technically, there could be a repo in the root of the system, but that's a usecase that we don't need to support at this time)
         return dir.root? == false
       end
 
-      # Travels back the hierarchy of the given path until it finds an existing
-      # ancestor, or it reaches the root of the file system.
+      # Travels back the hierarchy of the given path until it finds an existing ancestor, or it reaches the root of the file system.
       #
       # @param [String] path The path to inspect
       #
-      # @return [Pathname] The first existing ancestor, or `path` itself if it
-      #         exists
+      # @return [Pathname] The first existing ancestor, or `path` itself if it exists
       #
       def self.first_existing_ancestor_of(path:)
         p = Pathname(path).expand_path
@@ -106,7 +99,7 @@ module Fastlane
       #
       # @param [String] message The commit message to use
       # @param [String|Array<String>] files A file or array of files to git-add before creating the commit.
-      #        use `nil` or `[]` if you already added the files in a separate step and don't wan't this method to add any new file before commit.
+      #        Use `nil` or `[]` if you already added the files in a separate step and don't wan't this method to add any new file before commit.
       #        Also accepts the special symbol `:all` to add all the files (`git commit -a -m …`).
       # @param [Bool] push If true, will `git push` to `origin` after the commit has been created. Defaults to `false`.
       #
@@ -209,8 +202,7 @@ module Fastlane
         UI.user_error!("This command works only on #{branch_name} branch") unless current_branch_name.include?(branch_name)
       end
 
-      # Checks whether a given path is ignored by Git, relying on Git's
-      # `check-ignore` under the hood.
+      # Checks whether a given path is ignored by Git, relying on Git's `check-ignore` under the hood.
       #
       # @param [String] path The path to check against `.gitignore`
       #

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

@@ -19,6 +19,8 @@ module Fastlane
         #         - `nil` if the file does not exist or is neither of those format (e.g. not a `.strings` file at all)
         #
         def self.strings_file_type(path:)
+          return :text if File.empty?(path) # If completely empty file, consider it as a valid `.strings` files in textual format
+
           # Start by checking it seems like a valid property-list file (and not e.g. an image or plain text file)
           _, status = Open3.capture2('/usr/bin/plutil', '-lint', path)
           return nil unless status.success?
@@ -36,8 +38,8 @@ module Fastlane
 
         # Merge the content of multiple `.strings` files into a new `.strings` text file.
         #
-        # @param [Array<String>] paths The paths of the `.strings` files to merge together
-        # @param [String] into The path to the merged `.strings` file to generate as a result.
+        # @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
+        # @param [String] output_path The path to the merged `.strings` file to generate as a result.
         # @return [Array<String>] List of duplicate keys found while validating the merge.
         #
         # @note For now, this method only supports merging `.strings` file in `:text` format
@@ -48,24 +50,35 @@ module Fastlane
         #
         # @raise [RuntimeError] If one of the paths provided is not in text format (but XML or binary instead), or if any of the files are missing.
         #
-        def self.merge_strings(paths:, output_path: nil)
+        def self.merge_strings(paths:, output_path:)
           duplicates = []
           Tempfile.create('wpmrt-l10n-merge-', encoding: 'utf-8') do |tmp_file|
             all_keys_found = []
 
             tmp_file.write("/* Generated File. Do not edit. */\n\n")
-            paths.each do |input_file|
+            paths.each do |input_file, prefix|
+              next if File.empty?(input_file) # Skip existing but totally empty files, to avoid adding useless `MARK:` comment for them
+
               fmt = strings_file_type(path: input_file)
               raise "The file `#{input_file}` does not exist or is of unknown format." if fmt.nil?
               raise "The file `#{input_file}` is in #{fmt} format but we currently only support merging `.strings` files in text format." unless fmt == :text
 
-              string_keys = read_strings_file_as_hash(path: input_file).keys
+              string_keys = read_strings_file_as_hash(path: input_file).keys.map { |k| "#{prefix}#{k}" }
               duplicates += (string_keys & all_keys_found) # Find duplicates using Array intersection, and add those to duplicates list
               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 { |line| tmp_file.write(line) }
+              File.readlines(input_file, mode: 'rb:BOM|UTF-8').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)
+                end
+                tmp_file.write(line)
+              end
               tmp_file.write("\n")
             end
             tmp_file.close # ensure we flush the content to disk
@@ -81,6 +94,8 @@ module Fastlane
         # @raise [RuntimeError] If the file is not a valid strings file or there was an error in parsing its content.
         #
         def self.read_strings_file_as_hash(path:)
+          return {} if File.empty?(path) # Return empty hash if completely empty file
+
           output, status = Open3.capture2e('/usr/bin/plutil', '-convert', 'json', '-o', '-', path)
           raise output unless status.success?
 
@@ -108,7 +123,7 @@ module Fastlane
             xml.comment('Warning: Auto-generated file, do not edit.')
             xml.plist(version: '1.0') do
               xml.dict do
-                translations.each do |k, v|
+                translations.sort.each do |k, v| # NOTE: use `sort` just in order to be deterministic over various runs
                   xml.key(k.to_s)
                   xml.string(v.to_s)
                 end

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

@@ -58,8 +58,7 @@ module Fastlane
         #
         # @param [String] input_dir The path (ideally absolute) to the directory containing the `.lproj` folders to parse
         # @param [String] base_lang The code name (i.e the basename of one of the `.lproj` folders) of the locale to use as the baseline
-        # @return [Hash<String, String>] A hash whose keys are the language codes (basename of `.lproj` folders) for which violations were found,
-        #         and the values are the output of the `diff` showing these violations.
+        # @return [Hash<String, Array<String>>] A hash of violations, keyed by language code, whose values are the list of violation messages for that language
         #
         def run(input_dir:, base_lang: DEFAULT_BASE_LANG, only_langs: nil)
           check_swiftgen_installed || install_swiftgen!
@@ -87,7 +86,7 @@ module Fastlane
           <<~TEMPLATE
             {% macro recursiveBlock table item %}
               {% for string in item.strings %}
-            "{{string.key}}" => [{{string.types|join:","}}]
+            {{string.key}} ==> [{{string.types|join:","}}]
               {% endfor %}
               {% for child in item.children %}
               {% call recursiveBlock table child %}
@@ -139,20 +138,19 @@ module Fastlane
           return [config_file, langs]
         end
 
-        # Because we use English copy verbatim as key names, some keys are the same except for the upper/lowercase.
-        # We need to sort the output again because SwiftGen only sort case-insensitively so that means keys that are
-        # the same except case might be in swapped order for different outputs
+        # Returns a Hash mapping the list of expected parameter types for each of the keys based in the %… placeholders found in their `.strings` files
         #
         # @param [String] dir The temporary directory in which the file to sort lines for is located
         # @param [String] lang The code for the locale we need to sort the output lines for
+        # @return [Hash<String, String>] A hash whose keys are the strings keys, and corresponding value is a String describing the types expected as parameters.
         #
-        def sort_file_lines!(dir, lang)
+        def placeholder_types_for_keys(dir, lang)
           file = File.join(dir, output_filename(lang))
           return nil unless File.exist?(file)
 
-          sorted_lines = File.readlines(file).sort
-          File.write(file, sorted_lines.join)
-          return file
+          File.readlines(file).map do |line|
+            line.match(/^(.*) ==> (\[[A-Za-z,]*\])$/)&.captures
+          end.compact.to_h
         end
 
         # Prepares the template and config files, then run SwiftGen, run `diff` on each generated output against the baseline, and returns a Hash of the violations found.
@@ -160,7 +158,7 @@ module Fastlane
         # @param [String] input_dir The directory where the `.lproj` folders to scan are located
         # @param [String] base_lang The base language used as source of truth that all other languages will be compared against
         # @param [Array<String>] only_langs The list of languages to limit the generation for. Useful to focus only on a couple of issues or just one language
-        # @return [Hash<String, String>] A hash of violations, keyed by language code, whose values are the diff output.
+        # @return [Hash<String, Array<String>>] A hash of violations, keyed by language code, whose values are the list of violation messages for that language
         #
         # @note The returned Hash contains keys only for locales with violations. Locales parsed but without any violations found will not appear in the resulting hash.
         #
@@ -172,34 +170,22 @@ module Fastlane
             Action.sh(swiftgen_bin, 'config', 'run', '--config', config_file)
 
             # Run diffs
-            base_file = sort_file_lines!(tmpdir, base_lang)
+            params_for_base_lang = placeholder_types_for_keys(tmpdir, base_lang)
             langs.delete(base_lang)
             return langs.map do |lang|
-              file = sort_file_lines!(tmpdir, lang)
+              params_for_lang = placeholder_types_for_keys(tmpdir, lang)
+
               # If the lang ends up not having any translation at all (e.g. a `.lproj` without any `.strings` file in it but maybe just a storyboard or assets catalog), ignore it
-              next nil if file.nil? || only_empty_lines?(file)
-
-              # Compute the diff
-              diff = `diff -U0 "#{base_file}" "#{file}"`
-              # Remove the lines starting with `---`/`+++` which contains the file names (which are temp files we don't want to expose in the final diff to users)
-              # Note: We still keep the `@@ from-file-line-numbers to-file-line-numbers @@` lines to help the user know the index of the key to find it faster,
-              #       and also to serve as a clear visual separator between diff entries in the output.
-              #       Those numbers won't be matching the original `.strings` file line numbers because they are line numbers in the SwiftGen-generated intermediate
-              #       file instead, but they can still give an indication at the index in the list of keys at which this difference is located.
-              diff.gsub!(/^(---|\+\+\+).*\n/, '')
-              diff.empty? ? nil : [lang, diff]
-            end.compact.to_h
-          end
-        end
+              next nil if params_for_lang.nil? || params_for_lang.empty?
 
-        # Returns true if the file only contains empty lines, i.e. lines that only contains whitespace (space, tab, CR, LF)
-        def only_empty_lines?(file)
-          File.open(file) do |f|
-            while (line = f.gets)
-              return false unless line.strip.empty?
-            end
+              violations = params_for_lang.map do |key, param_types|
+                next "`#{key}` was unexpected, as it is not present in the base locale." if params_for_base_lang[key].nil?
+                next "`#{key}` expected placeholders for #{params_for_base_lang[key]} but found #{param_types} instead." if params_for_base_lang[key] != param_types
+              end.compact
+
+              [lang, violations] unless violations.empty?
+            end.compact.to_h
           end
-          return true
         end
       end
     end

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

@@ -0,0 +1,107 @@
+module Fastlane
+  module Helper
+    module Ios
+      class StringsFileValidationHelper
+        # context can be one of:
+        #   :root, :maybe_comment_start, :in_line_comment, :in_block_comment,
+        #   :maybe_block_comment_end, :in_quoted_key,
+        #   :after_quoted_key_before_eq, :after_quoted_key_and_equal,
+        #   :in_quoted_value, :after_quoted_value
+        State = Struct.new(:context, :buffer, :in_escaped_ctx, :found_key, keyword_init: true)
+
+        TRANSITIONS = {
+          root: {
+            /\s/ => :root,
+            '/' => :maybe_comment_start,
+            '"' => :in_quoted_key
+          },
+          maybe_comment_start: {
+            '/' => :in_line_comment,
+            /\*/ => :in_block_comment
+          },
+          in_line_comment: {
+            "\n" => :root,
+            /./ => :in_line_comment
+          },
+          in_block_comment: {
+            /\*/ => :maybe_block_comment_end,
+            /./m => :in_block_comment
+          },
+          maybe_block_comment_end: {
+            '/' => :root,
+            /./m => :in_block_comment
+          },
+          in_quoted_key: {
+            '"' => lambda do |state, _|
+              state.found_key = state.buffer.string.dup
+              state.buffer.string = ''
+              :after_quoted_key_before_eq
+            end,
+            /./ => lambda do |state, c|
+              state.buffer.write(c)
+              :in_quoted_key
+            end
+          },
+          after_quoted_key_before_eq: {
+            /\s/ => :after_quoted_key_before_eq,
+            '=' => :after_quoted_key_and_eq
+          },
+          after_quoted_key_and_eq: {
+            /\s/ => :after_quoted_key_and_eq,
+            '"' => :in_quoted_value
+          },
+          in_quoted_value: {
+            '"' => :after_quoted_value,
+            /./m => :in_quoted_value
+          },
+          after_quoted_value: {
+            /\s/ => :after_quoted_value,
+            ';' => :root
+          }
+        }.freeze
+
+        # Inspects the given `.strings` file for duplicated keys, returning them if any.
+        #
+        # @param [String] file The path to the file to inspect.
+        # @return [Hash<String, Array<Int>] Hash with the dublipcated keys.
+        #         Each element has the duplicated key (from the `.strings`) as key and an array of line numbers where the key occurs as value.
+        def self.find_duplicated_keys(file:)
+          keys_with_lines = Hash.new([])
+
+          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|
+            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.
+              if state.in_escaped_ctx || c == '\\'
+                # Just because we check for escaped characters at the global level, it doesn't mean we allow them in every context.
+                allowed_contexts_for_escaped_characters = %i[in_quoted_key in_quoted_value in_block_comment in_line_comment]
+                raise "Found escaped character outside of allowed contexts on line #{line_no + 1} (current context: #{state.context})" unless allowed_contexts_for_escaped_characters.include?(state.context)
+
+                state.buffer.write(c) if state.context == :in_quoted_key
+                state.in_escaped_ctx = !state.in_escaped_ctx
+                next
+              end
+
+              # Look at the transitions table for the current context, and find the first transition matching the current character
+              (_, next_context) = TRANSITIONS[state.context].find { |regex, _| c.match?(regex) } || [nil, nil]
+              raise "Invalid character `#{c}` found on line #{line_no + 1}, col #{col_no + 1}" if next_context.nil?
+
+              state.context = next_context.is_a?(Proc) ? next_context.call(state, c) : next_context
+              next unless state.found_key
+
+              # If we just exited the :in_quoted_key context and thus have found a new key, process it
+              key = state.found_key.dup
+              state.found_key = nil
+
+              keys_with_lines[key] += [line_no + 1]
+            end
+          end
+
+          keys_with_lines.keep_if { |_, lines| lines.count > 1 }
+        end
+      end
+    end
+  end
+end

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

@@ -12,8 +12,7 @@ module Fastlane
         @alternates = {}
       end
 
-      # Downloads data from GlotPress,
-      # in JSON format
+      # Downloads data from GlotPress, in JSON format
       def download(target_locale, glotpress_url, is_source)
         uri = URI(glotpress_url)
         response = Net::HTTP.get_response(uri)
@@ -80,8 +79,7 @@ module Fastlane
         end
       end
 
-      # Writes the downloaded content
-      # to the target file
+      # Writes the downloaded content to the target file
       def save_metadata(locale, file_name, content)
         file_path = get_target_file_path(locale, file_name)
 

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

@@ -117,8 +117,7 @@ module Fastlane
       end
 
       def draw_screenshot_to_canvas(entry, canvas, device)
-        # Don't require a screenshot to be present – we can just skip
-        # this function if one doesn't exist.
+        # Don't require a screenshot to be present – we can just skip this function if one doesn't exist.
         return canvas if entry['screenshot'].nil?
 
         device_mask = device['screenshot_mask']

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

@@ -9,9 +9,11 @@ module Fastlane
       def self.add_new_section(path:, section_title:)
         lines = File.readlines(path)
 
-        # Find the index of the first non-empty line that is also NOT a comment. That way we keep commment headers as the very top of the file
+        # Find the index of the first non-empty line that is also NOT a comment.
+        # That way we keep commment headers as the very top of the file
         line_idx = lines.find_index { |l| !l.start_with?('***') && !l.start_with?('//') && !l.chomp.empty? }
-        # Put back the header, then the new entry, then the rest (note: '...' excludes the higher bound of the range, unlike '..')
+        # Put back the header, then the new entry, then the rest
+        # (note: '...' excludes the higher bound of the range, unlike '..')
         new_lines = lines[0...line_idx] + ["#{section_title}\n", "-----\n", "\n", "\n"] + lines[line_idx..]
 
         File.write(path, new_lines.join)

data/lib/fastlane/plugin/wpmreleasetoolkit/models/file_reference.rb

@@ -40,11 +40,9 @@ module Fastlane
       end
 
       # "Applies" the instruction described in the instance to the file system.
-      # That is, copies the content of the source `file` to the `destination`
-      # path.
+      # That is, copies the content of the source `file` to the `destination` path.
       #
-      # @raise [StandardError] For security reasons, it will raise if
-      # `destination` is not ignored under Git.
+      # @raise [StandardError] For security reasons, it will raise if `destination` is not ignored under Git.
       def apply
         # Only decrypt the file if the destination is ignored in Git
         unless Fastlane::Helper::GitHelper.is_ignored?(path: destination_file_path)

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

@@ -1,5 +1,5 @@
 module Fastlane
   module Wpmreleasetoolkit
-    VERSION = '3.0.0'
+    VERSION = '4.1.0'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-wpmreleasetoolkit
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 4.1.0
 platform: ruby
 authors:
 - Lorenzo Mattei
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-02-09 00:00:00.000000000 Z
+date: 2022-04-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diffy
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: '1.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: '1.5'
 - !ruby/object:Gem::Dependency
   name: git
   requirement: !ruby/object:Gem::Requirement
@@ -401,6 +401,7 @@ files:
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/common/removebranchprotection_action.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/common/setbranchprotection_action.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/common/setfrozentag_action.rb
+- lib/fastlane/plugin/wpmreleasetoolkit/actions/common/upload_to_s3.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/configure/configure_add_files_to_copy_action.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/configure/configure_apply_action.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/configure/configure_download_action.rb
@@ -421,6 +422,7 @@ files:
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/ios/ios_completecodefreeze_prechecks.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/ios/ios_current_branch_is_hotfix.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/ios/ios_download_strings_files_from_glotpress.rb
+- lib/fastlane/plugin/wpmreleasetoolkit/actions/ios/ios_extract_keys_from_strings_files.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/ios/ios_final_tag.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/ios/ios_finalize_prechecks.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/ios/ios_generate_strings_file_from_code.rb
@@ -452,6 +454,7 @@ files:
 - lib/fastlane/plugin/wpmreleasetoolkit/helper/ios/ios_git_helper.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/helper/ios/ios_l10n_helper.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/helper/ios/ios_l10n_linter_helper.rb
+- lib/fastlane/plugin/wpmreleasetoolkit/helper/ios/ios_strings_file_validation_helper.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/helper/ios/ios_version_helper.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/helper/metadata_download_helper.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/helper/metadata_update_helper.rb