fastlane-plugin-wpmreleasetoolkit 4.0.0 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e6b39530c08effa688004cbc0c5d8fa8f4fcf3ae5795cb028ca7b60d84f25e0
-  data.tar.gz: bccb8c68d90bbb681f2fc41e896f1af775bf141ccd28d83eb3aac1f7ba40e28a
+  metadata.gz: ee81192aaa403dc7878821f60017e13f9867c549ba84ba2912d1e3ae0623b7b8
+  data.tar.gz: a702bfd98e9134e8d3f4303a1bad07705e6b27c107ead1295f5583a78b40384e
 SHA512:
-  metadata.gz: 2d5324c615ca08aba37682e1cd6d613e885245f75f1cea5b459c644f083e8cd43af6ba6e6f93932ee7ce8e2a6bb21ed75a12f655610784494955226e2119fb54
-  data.tar.gz: d2fbbaeb3d7b753b400d77f33f8bf863a8eafc0dccdab8c4e36886f32af1b7791ca02a9dee75ad9ff09b29659d7af2887c4840d029411f6bc71be098378b8410
+  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/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_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/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_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 = '4.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: 4.0.0
+  version: 4.1.0
 platform: ruby
 authors:
 - Lorenzo Mattei
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-03-17 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
@@ -454,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