fastlane-plugin-wpmreleasetoolkit 15.0.0 → 15.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d947683766d2a3fddc5ab9ccf7182bc628ca63d839e94ab6633cead85d91fc76
-  data.tar.gz: 3278ec05690d03d229b938b711e8e4ecf59fe2945008672ebc81b7a5edbfe555
+  metadata.gz: f47aea4602fae982122ed3c370c7cbc3330ebe242781ff4abffb4498016f384c
+  data.tar.gz: e4526ac1fcbb27ece5e15fc8a11ea60d453c2bbd1ab34a8f1c88040f590e31f8
 SHA512:
-  metadata.gz: 5512d2f282436ade2e641cefb4f5e4b3bb5db9a6c857a1d20841cebf45339c4e4e485e994c6094eb3f1a5eb78a284ef5826edaf0712d51c78b012def1f0bed3a
-  data.tar.gz: fa586cd530a3bb5463e3038ae9e057cab05d8166ab9d69aedbc823824f2770e14efc8afb70674fd66a4e6bc5790e6dfe753a9469eecdd6d1a809176bd9c7a4d4
+  metadata.gz: 297833bfc56d46af40b9771485fe42cc5b2e54c910ddf92ea2701e50088bb4015176ed988544e593128569e3f410093cb0421976b32167e4c9755c423fc44c0d
+  data.tar.gz: 39d1cd8e4a1cc8fde878d10538cc5a49cb6b2fa58ad2f2a80fb3d1c2ea4fa830c8e4803f7052fdbd243619b4dcc60a150f4b522504f218327dd4145f3b15dee5

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative '../../helper/config_item_helper'
+
 # This action is the new version of android_update_metadata (AndroidUpdateMetadataAction) and should now be used instead of that one
 
 module Fastlane
@@ -19,7 +21,8 @@ module Fastlane
           res_dir: res_dir,
           glotpress_project_url: params[:glotpress_url],
           glotpress_filters: params[:status_filter].map { |s| { status: s } },
-          locales_map: params[:locales]
+          locales_map: params[:locales],
+          fail_on_error: params[:fail_on_error]
         )
 
         # Update submodules then lint translations
@@ -99,6 +102,7 @@ module Fastlane
             type: Boolean,
             default_value: false
           ),
+          Fastlane::Helper::ConfigItemHelper.opt_in_fail_on_error_config_item,
         ]
       end
 

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'fastlane/action'
+require_relative '../../helper/config_item_helper'
 require_relative '../../helper/github_helper'
 
 module Fastlane
@@ -104,15 +105,7 @@ module Fastlane
                                                     'See https://docs.github.com/en/repositories/releasing-projects-on-github/automatically-generated-release-notes#configuration-options',
                                        optional: true,
                                        type: String),
-          FastlaneCore::ConfigItem.new(key: :fail_on_error,
-                                       description: 'Whether to fail the lane if the changelog cannot be computed. ' \
-                                                    'When `false` (the default), the error message is returned as the changelog itself, ' \
-                                                    'so that it ends up visible in the GitHub Release body. ' \
-                                                    'Set this to `true` if the caller publishes the release only after this action succeeds, ' \
-                                                    'and would rather stop than publish a release whose notes are an error message',
-                                       optional: true,
-                                       default_value: false,
-                                       type: Boolean),
+          Fastlane::Helper::ConfigItemHelper.opt_in_fail_on_error_config_item,
           Fastlane::Helper::GithubHelper.github_token_config_item,
         ]
       end

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

@@ -2,6 +2,7 @@
 
 require 'fastlane/action'
 require_relative '../../helper/metadata_download_helper'
+require_relative '../../helper/config_item_helper'
 
 module Fastlane
   module Actions
@@ -13,12 +14,13 @@ module Fastlane
         UI.message "Source locale: #{params[:source_locale].nil? ? '-' : params[:source_locale]}"
         UI.message "Path: #{params[:download_path]}"
         UI.message "Auto-retry: #{params[:auto_retry]}"
+        UI.message "Fail on error: #{params[:fail_on_error]}"
 
         # Check download path
         FileUtils.mkdir_p(params[:download_path])
 
         # Download
-        downloader = Fastlane::Helper::MetadataDownloader.new(params[:download_path], params[:target_files], params[:auto_retry])
+        downloader = Fastlane::Helper::MetadataDownloader.new(params[:download_path], params[:target_files], params[:auto_retry], fail_on_error: params[:fail_on_error])
 
         params[:locales].each do |loc|
           if loc.is_a?(Array)
@@ -77,6 +79,7 @@ module Fastlane
                                        type: FastlaneCore::Boolean,
                                        optional: true,
                                        default_value: true),
+          Fastlane::Helper::ConfigItemHelper.opt_in_fail_on_error_config_item,
         ]
       end
 

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

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require 'tempfile'
+require_relative '../../helper/config_item_helper'
+
 module Fastlane
   module Actions
     class IosDownloadStringsFilesFromGlotpressAction < Action
@@ -17,33 +20,91 @@ module Fastlane
           destination = File.join(lproj_dir, "#{params[:table_basename]}.strings")
           FileUtils.mkdir_p(lproj_dir)
 
-          Fastlane::Helper::Ios::L10nHelper.download_glotpress_export_file(
+          download_and_replace_strings_file(
             project_url: params[:project_url],
             locale: glotpress_locale,
             filters: params[:filters],
-            destination: destination
+            destination: destination,
+            table_basename: params[:table_basename],
+            skip_file_validation: params[:skip_file_validation],
+            fail_on_error: params[:fail_on_error]
           )
-          # Do a quick check of the downloaded `.strings` file to ensure it looks valid
-          validate_strings_file(destination) unless params[:skip_file_validation]
         end
       end
 
-      # Validate that a `.strings` file downloaded from GlotPress seems valid and does not contain empty translations
-      def self.validate_strings_file(destination)
-        return unless File.exist?(destination) # If the file failed to download, don't try to validate an non-existing file. We'd already have a separate error for the download failure anyway.
+      def self.download_and_replace_strings_file(project_url:, locale:, filters:, destination:, table_basename:, skip_file_validation:, fail_on_error:)
+        if File.exist?(destination) && !File.file?(destination)
+          report_error("The destination `#{destination}` exists but is not a regular file", fail_on_error: fail_on_error)
+          return false
+        end
 
-        translations = Fastlane::Helper::Ios::L10nHelper.read_strings_file_as_hash(path: destination)
-        empty_keys = translations.select { |_, value| value.nil? || value.empty? }.keys.sort
-        unless empty_keys.empty?
-          UI.error(
-            "Found empty translations in `#{destination}` for the following keys: #{empty_keys.inspect}.\n" \
-              + "This is likely a GlotPress bug, and will lead to copies replaced by empty text in the UI.\n" \
-              + 'Please report this to the GlotPress team, and fix the file locally before continuing.'
+        destination_mode = File.exist?(destination) ? File.stat(destination).mode & 0o7777 : 0o644
+        Tempfile.create([table_basename, '.strings'], File.dirname(destination)) do |temporary_file|
+          downloaded = Fastlane::Helper::Ios::L10nHelper.download_glotpress_export_file(
+            project_url: project_url,
+            locale: locale,
+            filters: filters,
+            destination: temporary_file,
+            fail_on_error: fail_on_error
           )
+          return false unless downloaded
+
+          temporary_file.flush
+          # Do a quick check of the downloaded `.strings` file to ensure it looks valid
+          validate_strings_file(temporary_file.path, display_path: destination, fail_on_error: fail_on_error) unless skip_file_validation
+          File.chmod(destination_mode, temporary_file.path)
+          temporary_file.close
+          File.rename(temporary_file.path, destination)
         end
+        true
+      rescue FastlaneCore::Interface::FastlaneError
+        raise
       rescue StandardError => e
-        UI.error("Error while validating the file exported from GlotPress (`#{destination}`) - #{e.message.chomp}")
+        report_error("Error writing downloaded locale `#{locale}` — #{e.message} (#{destination})", fail_on_error: fail_on_error)
+        false
+      end
+      private_class_method :download_and_replace_strings_file
+
+      # Validate that a `.strings` file downloaded from GlotPress seems valid and does not contain empty translations
+      def self.validate_strings_file(path, display_path: path, fail_on_error: false)
+        unless File.exist?(path)
+          report_error("The file exported from GlotPress was not created (`#{display_path}`)", fail_on_error: fail_on_error) if fail_on_error
+          return
+        end
+
+        if File.empty?(path)
+          report_error("The file exported from GlotPress is empty (`#{display_path}`)", fail_on_error: fail_on_error) if fail_on_error
+          return
+        end
+
+        translations = nil
+        begin
+          translations = Fastlane::Helper::Ios::L10nHelper.read_strings_file_as_hash(path: path)
+        rescue StandardError => e
+          report_error("Error while validating the file exported from GlotPress (`#{display_path}`) - #{e.message.chomp}", fail_on_error: fail_on_error)
+          return
+        end
+
+        unless translations.is_a?(Hash) && translations.all? { |key, value| key.is_a?(String) && value.is_a?(String) }
+          report_error("The file exported from GlotPress is not a string-to-string dictionary (`#{display_path}`)", fail_on_error: fail_on_error)
+          return
+        end
+
+        empty_keys = translations.select { |_, value| value.nil? || value.empty? }.keys.sort
+        return if empty_keys.empty?
+
+        report_error(
+          "Found empty translations in `#{display_path}` for the following keys: #{empty_keys.inspect}.\n" \
+            + "This is likely a GlotPress bug, and will lead to copies replaced by empty text in the UI.\n" \
+            + 'Please report this to the GlotPress team, and fix the file locally before continuing.',
+          fail_on_error: fail_on_error
+        )
+      end
+
+      def self.report_error(message, fail_on_error:)
+        fail_on_error ? UI.user_error!(message) : UI.error(message)
       end
+      private_class_method :report_error
 
       #####################################################
       # @!group Documentation
@@ -92,6 +153,7 @@ module Fastlane
                                        type: Fastlane::Boolean,
                                        optional: true,
                                        default_value: false),
+          Fastlane::Helper::ConfigItemHelper.opt_in_fail_on_error_config_item,
         ]
       end
 

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

@@ -243,9 +243,11 @@ module Fastlane
         # @param [Array<Hash{Symbol=>String}>] locales_map
         #        An array of locales to download. Each item in the array must be a Hash
         #        with keys `:glotpress` and `:android` containing the respective locale codes.
+        # @param [Boolean] fail_on_error Whether to fail on request errors or invalid downloaded XML.
         #
-        def self.download_from_glotpress(res_dir:, glotpress_project_url:, locales_map:, glotpress_filters: { status: 'current' })
+        def self.download_from_glotpress(res_dir:, glotpress_project_url:, locales_map:, glotpress_filters: { status: 'current' }, fail_on_error: false)
           glotpress_filters = [glotpress_filters] unless glotpress_filters.is_a?(Array)
+          UI.user_error!('At least one GlotPress filter is required.') if fail_on_error && glotpress_filters.empty?
 
           orig_file = File.join(res_dir, 'values', 'strings.xml')
           orig_xml = File.open(orig_file) { |f| Nokogiri::XML(f, nil, Encoding::UTF_8.to_s) }
@@ -253,7 +255,7 @@ module Fastlane
           locales_map.each do |lang_codes|
             all_xml_documents = glotpress_filters.map do |filters|
               UI.message "Downloading translations for '#{lang_codes[:android]}' from GlotPress (#{lang_codes[:glotpress]}) [#{filters}]..."
-              download_glotpress_export_file(project_url: glotpress_project_url, locale: lang_codes[:glotpress], filters: filters)
+              download_glotpress_export_file(project_url: glotpress_project_url, locale: lang_codes[:glotpress], filters: filters, fail_on_error: fail_on_error)
             end.compact
             next if all_xml_documents.empty?
 
@@ -282,19 +284,35 @@ module Fastlane
         # @param [String] locale The GlotPress locale code to download strings for.
         # @param [Hash{Symbol=>String}] filters The hash of filters to apply when exporting from GlotPress.
         #                               Typical examples include `{ status: 'current' }` or `{ status: 'review' }`.
+        # @param [Boolean] fail_on_error Whether to fail on request errors or invalid downloaded XML.
         # @return [Nokogiri::XML::Document] the download XML document, parsed as a Nokogiri::XML object
         #
-        def self.download_glotpress_export_file(project_url:, locale:, filters:)
+        def self.download_glotpress_export_file(project_url:, locale:, filters:, fail_on_error:)
           query_params = filters.transform_keys { |k| "filters[#{k}]" }.merge(format: 'android')
           url = "#{project_url.chomp('/')}/#{locale}/default/export-translations/?#{URI.encode_www_form(query_params)}"
 
           Fastlane::Helper::GlotPressDownloader.download(
             url: url,
             locale: locale,
-            auto_retry: true
+            auto_retry: true,
+            fail_on_error: fail_on_error
           ) do |response_body|
             # Replace tabs with spaces (GlotPress uses tabs, but we prefer spaces)
-            Nokogiri::XML(response_body.gsub("\t", '    '), nil, Encoding::UTF_8.to_s)
+            if fail_on_error
+              begin
+                xml = Nokogiri::XML(response_body.gsub("\t", '    '), nil, Encoding::UTF_8.to_s, &:strict)
+              rescue Nokogiri::XML::SyntaxError => e
+                UI.user_error!("Invalid Android translation export for locale `#{locale}` — #{e.message} (#{url})")
+              end
+
+              unless xml.root&.name == 'resources'
+                UI.user_error!("Invalid Android translation export for locale `#{locale}` — expected a `resources` root element (#{url})")
+              end
+
+              xml
+            else
+              Nokogiri::XML(response_body.gsub("\t", '    '), nil, Encoding::UTF_8.to_s)
+            end
           end
         end
         private_class_method :download_glotpress_export_file

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Fastlane
+  module Helper
+    class ConfigItemHelper
+      def self.opt_in_fail_on_error_config_item
+        FastlaneCore::ConfigItem.new(
+          key: :fail_on_error,
+          description: 'Whether handled errors should fail the lane instead of using the action-specific fallback behavior',
+          type: FastlaneCore::Boolean,
+          optional: true,
+          default_value: false
+        )
+      end
+    end
+  end
+end

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

@@ -9,19 +9,22 @@ module Fastlane
     class GlotPressDownloader
       AUTO_RETRY_SLEEP_TIME = 20
       MAX_AUTO_RETRY_ATTEMPTS = 30
+      MAX_REDIRECTS = 10
 
-      attr_reader :auto_retry, :auto_retry_attempt_counter, :url, :locale
+      attr_reader :auto_retry, :auto_retry_attempt_counter, :url, :locale, :fail_on_error
 
       # Initialize a new GlotPressDownloader
       #
       # @param [String] url The URL to download from
       # @param [String] locale The locale being downloaded (for logging purposes)
       # @param [Boolean] auto_retry Whether to automatically retry on rate limiting (429 errors)
+      # @param [Boolean] fail_on_error Whether to raise a Fastlane error after retry handling instead of returning false
       #
-      def initialize(url:, locale:, auto_retry: false)
+      def initialize(url:, locale:, auto_retry: false, fail_on_error: false)
         @url = url
         @locale = locale
         @auto_retry = auto_retry
+        @fail_on_error = fail_on_error
         @auto_retry_attempt_counter = 0
       end
 
@@ -30,34 +33,55 @@ module Fastlane
       # @param [String] url The URL to download from
       # @param [String] locale The locale being downloaded (for logging purposes)
       # @param [Boolean] auto_retry Whether to automatically retry on rate limiting (429 errors)
-      # @yield [String] The response body if the download was successful
-      # @return The result of the block if provided, or true/false indicating success if no block provided
+      # @param [Boolean] fail_on_error Whether to raise a Fastlane error after retry handling instead of returning false
+      # @yield [String] The response body if the download was successful. Return `false` to reject it and suppress the success message.
+      # @return The result of the block if provided, or true/false indicating success if no block is provided
+      # @raise [FastlaneCore::Interface::FastlaneError] If the download fails after retry handling and `fail_on_error` is true
       #
-      #
-      def self.download(url:, locale:, auto_retry: false, &)
-        new(url: url, locale: locale, auto_retry: auto_retry).download(&)
+      def self.download(url:, locale:, auto_retry: false, fail_on_error: false, &)
+        new(url: url, locale: locale, auto_retry: auto_retry, fail_on_error: fail_on_error).download(&)
       end
 
       # Downloads data from GlotPress
       #
-      # @yield [String] The response body if the download was successful
-      # @return The result of the block if provided, or true/false indicating success if no block provided
+      # @yield [String] The response body if the download was successful. Return `false` to reject it and suppress the success message.
+      # @return The result of the block if provided, or true/false indicating success if no block is provided
+      # @raise [FastlaneCore::Interface::FastlaneError] If the download fails after retry handling and `fail_on_error` is true
       #
       def download(&)
         @auto_retry_attempt_counter = 0 # Reset counter only at start of download
-        download_from_url(@url, &)
+        download_from_url(@url, redirect_count: 0, &)
       end
 
       private
 
-      def download_from_url(url, &)
-        uri = URI(url)
+      def download_from_url(url, redirect_count:, &)
+        uri = parse_uri(url)
+        return block_given? ? nil : false if uri.nil?
+
         response = make_request(uri)
+        return block_given? ? nil : false if response.nil?
+
+        unless block_given?
+          return handle_response(response: response, url: url, original_uri: uri, redirect_count: redirect_count)
+        end
+
         result = nil
-        success = handle_response(response: response, url: url, original_uri: uri) do |body|
-          result = yield body if block_given?
+        handle_response(response: response, url: url, original_uri: uri, redirect_count: redirect_count) do |body|
+          result = yield(body)
         end
-        block_given? ? result : success
+        result
+      end
+
+      def parse_uri(url)
+        uri = URI(url)
+        return uri if uri.is_a?(URI::HTTP) && uri.host
+
+        handle_failure("Invalid URL for locale `#{@locale}` (#{url})")
+        nil
+      rescue URI::InvalidURIError, TypeError => e
+        handle_failure("Invalid URL for locale `#{@locale}` — #{e.message} (#{url})")
+        nil
       end
 
       def make_request(uri)
@@ -68,60 +92,70 @@ module Fastlane
         http.request(request)
       rescue StandardError => e
         # Network errors, connection errors, etc.
-        UI.error("Error downloading locale `#{@locale}` — #{e.message} (#{uri})")
+        message = "Error downloading locale `#{@locale}` — #{e.message} (#{uri})"
         retry if UI.interactive? && UI.confirm("Retry downloading `#{@locale}`?")
+        handle_failure(message)
         nil
       end
 
-      def handle_response(response:, url:, original_uri:)
-        return false if response.nil?
-
+      def handle_response(response:, url:, original_uri:, redirect_count:, &)
         case response.code
         when '200'
+          accepted = block_given? ? yield(response.body) : true
+          return false if accepted == false
+
           UI.success("Successfully downloaded `#{@locale}`.")
-          yield response.body if block_given?
           true
         when '301', '302', '307', '308'
           # Follow the redirect
           UI.message("Received #{response.code} for `#{@locale}`. Following redirect...")
           redirect_url = response['location']
-          if redirect_url.nil?
-            UI.error("Received #{response.code} but no location header found.")
-            false
-          else
-            # Follow redirect with the new URL
-            download_from_url(redirect_url) { |body| yield body if block_given? }
-          end
+          return handle_failure("Received #{response.code} for `#{@locale}` but no location header was found (#{original_uri}).") if redirect_url.nil? || redirect_url.empty?
+          return handle_failure("Too many redirects while downloading locale `#{@locale}` (#{original_uri}).") if redirect_count >= MAX_REDIRECTS
+
+          resolved_url = resolve_redirect_url(original_uri, redirect_url)
+          return false if resolved_url.nil?
+
+          download_from_url(resolved_url, redirect_count: redirect_count + 1, &)
         when '429'
           # Rate limited
-          handle_rate_limiting(url: url) do |body|
-            yield body if block_given?
-          end
+          handle_rate_limiting(url: url, response: response, redirect_count: redirect_count, &)
         else
           # Unexpected status code (including 404, 500, etc.)
-          status_line = "#{response.code} #{response.message}"
-          UI.error("Error downloading locale `#{@locale}` — #{status_line} (#{original_uri})")
-          if UI.interactive? && UI.confirm("Retry downloading `#{@locale}`?")
-            download_from_url(url) { |body| yield body if block_given? }
-          else
-            false
-          end
+          status_line = [response.code, response.message].compact.join(' ').strip
+          message = "Error downloading locale `#{@locale}` — #{status_line} (#{original_uri})"
+          return handle_failure(message) unless UI.interactive? && UI.confirm("Retry downloading `#{@locale}`?")
+
+          download_from_url(url, redirect_count: redirect_count, &)
         end
       end
 
-      def handle_rate_limiting(url:)
+      def handle_rate_limiting(url:, response:, redirect_count:, &)
         if @auto_retry && @auto_retry_attempt_counter < MAX_AUTO_RETRY_ATTEMPTS
           UI.message("Received 429 for `#{@locale}`. Auto retrying in #{AUTO_RETRY_SLEEP_TIME} seconds... (attempt #{@auto_retry_attempt_counter + 1}/#{MAX_AUTO_RETRY_ATTEMPTS})")
           sleep(AUTO_RETRY_SLEEP_TIME)
           @auto_retry_attempt_counter += 1
-          download_from_url(url) { |body| yield body if block_given? }
+          download_from_url(url, redirect_count: redirect_count, &)
         elsif UI.interactive? && UI.confirm("Retry downloading `#{@locale}` after receiving 429 from the API?")
-          download_from_url(url) { |body| yield body if block_given? }
+          download_from_url(url, redirect_count: redirect_count, &)
         else
-          UI.error("Abandoning `#{@locale}` download.")
-          false
+          status_line = [response.code, response.message].compact.join(' ').strip
+          handle_failure("Error downloading locale `#{@locale}` — #{status_line} (#{url})")
         end
       end
+
+      def resolve_redirect_url(original_uri, redirect_url)
+        URI.join(original_uri.to_s, redirect_url).to_s
+      rescue URI::InvalidURIError => e
+        handle_failure("Invalid redirect URL for locale `#{@locale}` — #{e.message} (#{redirect_url})")
+        nil
+      end
+
+      def handle_failure(message)
+        UI.error(message)
+        UI.user_error!(message) if @fail_on_error
+        false
+      end
     end
   end
 end

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

@@ -191,26 +191,27 @@ module Fastlane
         # @param [Hash{Symbol=>String}] filters The hash of filters to apply when exporting from GlotPress.
         #                               Typical examples include `{ status: 'current' }` or `{ status: 'review' }`.
         # @param [String, IO] destination The path or `IO`-like instance, where to write the downloaded file on disk.
+        # @param [Boolean] fail_on_error Whether to fail on request errors.
         #
-        def self.download_glotpress_export_file(project_url:, locale:, filters:, destination:)
+        def self.download_glotpress_export_file(project_url:, locale:, filters:, destination:, fail_on_error: false)
           query_params = (filters || {}).transform_keys { |k| "filters[#{k}]" }.merge(format: 'strings')
           url = "#{project_url.chomp('/')}/#{locale}/default/export-translations/?#{URI.encode_www_form(query_params)}"
 
-          begin
-            Fastlane::Helper::GlotPressDownloader.download(
-              url: url,
-              locale: locale,
-              auto_retry: true
-            ) do |response_body|
-              if destination.is_a?(String)
-                File.write(destination, response_body)
-              else
-                destination.write(response_body)
-              end
+          Fastlane::Helper::GlotPressDownloader.download(
+            url: url,
+            locale: locale,
+            auto_retry: true,
+            fail_on_error: fail_on_error
+          ) do |response_body|
+            if destination.is_a?(String)
+              File.write(destination, response_body)
+            else
+              destination.write(response_body)
             end
           rescue StandardError => e
-            UI.error "Error downloading locale `#{locale}` — #{e.message} (#{url})"
-            nil
+            message = "Error writing downloaded locale `#{locale}` — #{e.message} (#{url})"
+            fail_on_error ? UI.user_error!(message) : UI.error(message)
+            false
           end
         end
       end

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

@@ -9,10 +9,11 @@ module Fastlane
     class MetadataDownloader
       attr_reader :target_folder, :target_files
 
-      def initialize(target_folder, target_files, auto_retry)
+      def initialize(target_folder, target_files, auto_retry, fail_on_error: false)
         @target_folder = target_folder
         @target_files = target_files
         @auto_retry = auto_retry
+        @fail_on_error = fail_on_error
         @alternates = {}
       end
 
@@ -21,9 +22,10 @@ module Fastlane
         GlotPressDownloader.download(
           url: glotpress_url,
           locale: target_locale,
-          auto_retry: @auto_retry
+          auto_retry: @auto_retry,
+          fail_on_error: @fail_on_error
         ) do |response_body|
-          handle_glotpress_response(response_body: response_body, locale: target_locale, is_source: is_source)
+          handle_glotpress_response(response_body: response_body, locale: target_locale, is_source: is_source, url: glotpress_url)
         end
       end
 
@@ -106,17 +108,34 @@ module Fastlane
 
       private
 
-      def handle_glotpress_response(response_body:, locale:, is_source:)
+      def handle_glotpress_response(response_body:, locale:, is_source:, url:)
         # Parse the JSON response
         @alternates.clear
-        loc_data = begin
-          JSON.parse(response_body)
-        rescue StandardError
-          nil
-        end
+        loc_data = parse_metadata_response(response_body: response_body, locale: locale, url: url)
+
         parse_data(locale, loc_data, is_source)
         reparse_alternates(locale, loc_data, is_source) unless @alternates.empty?
       end
+
+      def parse_metadata_response(response_body:, locale:, url:)
+        return JSON.parse(response_body) unless @fail_on_error
+
+        loc_data = JSON.parse(response_body)
+        UI.user_error!("Unexpected GlotPress metadata response for locale `#{locale}` (#{url})") unless valid_metadata_response?(loc_data)
+        loc_data
+      rescue JSON::ParserError, TypeError => e
+        UI.user_error!("Error parsing GlotPress response for locale `#{locale}` — #{e.message} (#{url})") if @fail_on_error
+        nil
+      end
+
+      def valid_metadata_response?(loc_data)
+        return loc_data.empty? if loc_data.is_a?(Array)
+        return false unless loc_data.is_a?(Hash) && !loc_data.empty?
+
+        loc_data.all? do |source, translations|
+          source.is_a?(String) && translations.is_a?(Array) && translations.all?(String)
+        end
+      end
     end
   end
 end

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

@@ -3,6 +3,6 @@
 module Fastlane
   module Wpmreleasetoolkit
     NAME = 'fastlane-plugin-wpmreleasetoolkit'
-    VERSION = '15.0.0'
+    VERSION = '15.1.0'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-wpmreleasetoolkit
 version: !ruby/object:Gem::Version
-  version: 15.0.0
+  version: 15.1.0
 platform: ruby
 authors:
 - Automattic
@@ -71,14 +71,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.237'
+        version: '2.240'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.237'
+        version: '2.240'
 - !ruby/object:Gem::Dependency
   name: gettext
   requirement: !ruby/object:Gem::Requirement
@@ -343,6 +343,7 @@ files:
 - lib/fastlane/plugin/wpmreleasetoolkit/helper/apps_cdn_helper.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/helper/buildkite_aware_log_groups.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/helper/ci_helper.rb
+- lib/fastlane/plugin/wpmreleasetoolkit/helper/config_item_helper.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/helper/configure_helper.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/helper/encryption_helper.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/helper/filesystem_helper.rb