Fix merge_strings crash on nested-dictionary .strings value

`merge_strings` bookkeeps keys via `plutil` but rewrites them by re-tokenizing
the raw lines through `StringsFileValidationHelper.prefix_keys`, whose
flat-`.strings` grammar has no `{`. A valid file like `"k" = { a = b; };`
clears the `:text` format gate, reaches `prefix_keys`, and raised
`Invalid character` — aborting a merge that previously copied the line through.

Fail soft: rescue the tokenizer and copy the file's lines through unprefixed
with a `UI.important` warning, mirroring the `scan_for_duplicate_keys`
`:unscannable` path. Flip the regression test to assert the graceful
degradation (no raise, warning emitted, line survives).

Author: jkmassel

CHANGELOG.md

@@ -18,6 +18,7 @@ _None_
 - `StringsFileValidationHelper.find_duplicated_keys` now also accepts comments placed *between* the tokens of a statement (e.g. `"key" /* note */ = "value";`), which `plutil` allows, instead of raising `Invalid character` on the `/`. [#741]
 - `ios_lint_localizations`' `check_duplicate_keys` no longer crashes the lane on a file that parses as a property list but isn't a flat `.strings` (e.g. a nested-dictionary value); it now warns via `UI.important` and skips that file. [#741]
 - `L10nHelper.merge_strings` now applies the key prefix via a comment-aware tokenizer, so it correctly prefixes unquoted keys containing `. - $ : /`, lines with an *unquoted* value (e.g. `CFBundleName = WordPress;`), and keys sitting behind an inter-token `.strings` comment (e.g. `CFBundleName /* note */ = WordPress;`) — matching the grammar `plutil` accepts. Previously the line-based matcher left those keys written to the merged file without the prefix while still bookkeeping them *with* it, leaving the output inconsistent with the reported keys (which could resurface the very collisions the prefix avoids and break downstream key extraction). [#741]
+- `L10nHelper.merge_strings` no longer crashes on a `:text` `.strings` file whose value is a nested dictionary (`"k" = { … };`) — valid input `plutil` accepts but the flat-`.strings` prefixing tokenizer can't rewrite. It now copies that file's lines through unprefixed with a `UI.important` warning instead of aborting the whole merge, mirroring the fail-soft behavior on the duplicate-key scanner path. [#750]
 
 ### Internal Changes
 

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

@@ -78,6 +78,9 @@ def self.read_utf8_lines(file)
         # @note The method is able to handle input files which are using different encodings,
         #       guessing the encoding of each input file using the BOM (and defaulting to UTF8).
         #       The generated file will always be in utf-8, by convention.
+        # @note If a file's keys can't be prefixed (e.g. it holds a nested-dictionary value, `"k" = { … };`,
+        #       which `plutil` accepts but the flat-`.strings` tokenizer can't rewrite), its lines are copied
+        #       through unprefixed with a warning rather than aborting the whole merge.
         #
         # @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.
         #
@@ -104,7 +107,17 @@ def self.merge_strings(paths:, output_path:)
               # sit (e.g. `CFBundleName /* note */ = WordPress;`) and `key = value`-looking text inside a comment is
               # left alone — keeping the written keys consistent with the (`plutil`-derived) keys bookkept above.
               lines = read_utf8_lines(input_file)
-              lines = Fastlane::Helper::Ios::StringsFileValidationHelper.prefix_keys(lines: lines, prefix: prefix)
+              begin
+                lines = Fastlane::Helper::Ios::StringsFileValidationHelper.prefix_keys(lines: lines, prefix: prefix)
+              rescue StandardError => e
+                # `plutil` accepts flat-`.strings` constructs the tokenizer doesn't — most notably a nested-dictionary
+                # value (`"k" = { … };`), which parses fine (so the file clears the `:text` gate above) yet exposes no
+                # flat `key = value` for `prefix_keys` to rewrite, so it raises on the `{`. Fail soft: copy this file's
+                # lines through unprefixed rather than aborting the whole merge — mirroring the scanner path, where
+                # `scan_for_duplicate_keys` returns `:unscannable` instead of crashing the lane. `lines` is untouched
+                # by the raise (the assignment above never completes), so it still holds the original file contents.
+                UI.important("Could not add prefix `#{prefix}` to the keys in `#{input_file}` (#{e.message}); copying its lines through unprefixed.")
+              end
               lines.each { |line| tmp_file.write(line) }
               tmp_file.write("\n")
             end

spec/ios_l10n_helper_spec.rb

@@ -160,19 +160,25 @@ def file_encoding(path)
       end
     end
 
-    it 'does not crash merging a text `.strings` file whose value is a nested dictionary' do
-      # Regression: `merge_strings` bookkeeps keys via `plutil` (which parses a nested-dictionary value
-      # fine) but re-tokenizes the raw lines through `prefix_keys`, which raises `Invalid character` on
-      # the `{`. Such a file is still `:text` and passes the format gate, so a public `ios_merge_strings_files`
-      # run that previously copied the line through now aborts. It should degrade gracefully instead of raising.
+    it 'copies a nested-dictionary value through unprefixed (with a warning) instead of crashing the merge' do
+      # Regression: `merge_strings` bookkeeps keys via `plutil` (which parses a nested-dictionary value fine)
+      # but rewrites keys by re-tokenizing the raw lines through `prefix_keys`, whose flat-`.strings` grammar
+      # has no `{` — so it raised `Invalid character`. Such a file is still `:text` and clears the format gate,
+      # so a public `ios_merge_strings_files` run that previously copied the line through would abort. It now
+      # degrades gracefully — copying the un-prefixable line verbatim and warning — like the scanner path.
       content = %("k" = { a = b; };\n)
       Dir.mktmpdir('a8c-release-toolkit-l10n-helper-tests-') do |tmp_dir|
         input_file = File.join(tmp_dir, 'InfoPlist.strings')
         File.write(input_file, content)
         output_file = File.join(tmp_dir, 'output.strings')
+
+        expect(FastlaneCore::UI).to receive(:important).with(a_string_including('Could not add prefix `pfx.`').and(a_string_including('unprefixed')))
         expect do
           described_class.merge_strings(paths: { input_file => 'pfx.' }, output_path: output_file)
         end.not_to raise_error
+
+        # The nested-dict line survives verbatim — unprefixed, since it has no flat `key = value` to rewrite.
+        expect(File.read(output_file)).to include('"k" = { a = b; };')
       end
     end