feat: run the translation tasks in //

Author: did

app/services/maglev/translate_page.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+# rubocop:disable Metrics/ClassLength
 module Maglev
   # Translate a page into a given locale from a source locale.
   # This is a fake service that only copies the page attributes.
@@ -16,7 +17,13 @@ class TranslatePage
     def call
       return nil unless page.persisted?
 
+      @translations = {}
+
       translate_all!
+
+      persist_changes!
+
+      page
     end
 
     protected
@@ -29,13 +36,19 @@ def theme
       @theme ||= fetch_theme.call
     end
 
+    # this is a third-step process because we need to group all the translations to process
+    # in order to process them in parallel
     def translate_all!
-      translate_page_attributes
-      translate_all_sections
+      # 1. replace all the text to translatewith placeholders
+      prepare_translate_page_attributes
+      prepare_translate_all_sections # sections from page and site
 
-      persist_changes!
+      # 2. Translate all the placeholders in parallel
+      async_translate
 
-      page
+      # 3. replace the placeholders with the actual translations that has been processed in parallel
+      replace_translations_in_page_attributes
+      replace_translations_in_all_sections
     end
 
     def persist_changes!
@@ -45,80 +58,123 @@ def persist_changes!
       end
     end
 
-    def translate_page_attributes
+    def async_translate
+      tasks = @translations.map do |id, text|
+        Concurrent::Promises.future do
+          { id => translate_text(text) }
+        end
+      end
+      @translations = Concurrent::Promises.zip(*tasks).value!.reduce({}, :merge)
+    end
+
+    def translate_text(text)
+      # @note: implement actual translation logic in a subclass
+      # by default we just add the locale to the text
+      text + " [#{locale.upcase}]"
+    end
+
+    # ===== Apply translations =====
+
+    def replace_translations_in_page_attributes
       %w[title seo_title meta_description og_title og_description].each do |attr|
-        translate_page_attribute(attr)
+        page.translations_for(attr)[locale] = replace_translated_text(page.translations_for(attr)[locale])
+      end
+    end
+
+    def replace_translations_in_all_sections
+      [page, site].each do |source|
+        source.sections_translations = JSON.parse(replace_translated_text(source.sections_translations.to_json))
+      end
+    end
+
+    # ===== Prepare translations =====
+
+    def prepare_translate_page_attributes
+      %w[title seo_title meta_description og_title og_description].each do |attr|
+        prepare_translate_page_attribute(attr)
       end
       # og_image_url is a special case because it's a URL, not content
       page.translations_for(:og_image_url)[locale] = page.translations_for(:og_image_url)[source_locale]
     end
 
-    def translate_page_attribute(attr)
-      page.translations_for(attr)[locale] = translate_text(page.translations_for(attr)[source_locale])
+    def prepare_translate_page_attribute(attr)
+      page.translations_for(attr)[locale] = prepare_translate_text(page.translations_for(attr)[source_locale])
     end
 
-    def translate_all_sections
+    def prepare_translate_all_sections
       [page, site].each do |source|
-        translate_sections(source)
+        prepare_translate_sections(source)
       end
     end
 
-    def translate_sections(source)
+    def prepare_translate_sections(source)
       # @note no need to translate if there are no sections in the source locale
       return if source.translations_for(:sections, source_locale).blank?
 
       # @note we don't want to overwrite existing translations
       return if source.translations_for(:sections, locale).present?
 
       source.sections_translations[locale] = clone_array(source.sections_translations[source_locale]).tap do |sections|
-        sections.each { |section| translate_section(section) }
+        sections.each { |section| prepare_translate_section(section) }
       end
     end
 
-    def translate_section(section)
+    def prepare_translate_section(section)
       definition = theme.sections.find(section['type'])
-      translate_settings(section, definition)
-      translate_section_blocks(section, definition)
+      prepare_translate_settings(section, definition)
+      prepare_translate_section_blocks(section, definition)
     end
 
-    def translate_settings(section_or_block, definition)
+    def prepare_translate_settings(section_or_block, definition)
       section_or_block['settings'].each do |setting|
         type = definition.settings.find { |s| s.id == setting['id'] }&.type
         next if type.blank?
 
-        setting['value'] = translate_setting_value(setting['value'], type)
+        setting['value'] = prepare_translate_setting_value(setting['value'], type)
       end
     end
 
-    def translate_section_blocks(section, definition)
+    def prepare_translate_section_blocks(section, definition)
       section['blocks'].each do |block|
         block_definition = definition.blocks.find { |b| b.type == block['type'] }
-        translate_settings(block, block_definition)
+        prepare_translate_settings(block, block_definition)
       end
     end
 
-    def translate_setting_value(value, type)
+    def prepare_translate_setting_value(value, type)
       case type
       when 'text'
-        translate_text(value)
+        prepare_translate_text(value)
       when 'link'
-        value.merge(text: translate_text(value['text'])) if value.is_a?(Hash)
+        value.merge(text: prepare_translate_text(value['text'])) if value.is_a?(Hash)
       when 'image'
-        value.merge(alt: translate_text(value['alt'])) if value.is_a?(Hash)
+        value.merge(alt: prepare_translate_text(value['alt'])) if value.is_a?(Hash)
       else
         value
       end
     end
 
     # NOTE: this method is a placeholder for the actual translation logic.
-    def translate_text(text)
-      return nil if text.blank?
+    def prepare_translate_text(text)
+      return text if text.blank?
 
-      text + " [#{locale.upcase}]"
+      id = SecureRandom.uuid
+      @translations[id] = text
+
+      "{#{id}}"
+    end
+
+    def replace_translated_text(text)
+      return text if text.blank?
+
+      text.gsub(/\{([a-f0-9-]{36})\}/) do |_match|
+        @translations[::Regexp.last_match(1)]
+      end
     end
 
     def clone_array(array)
       Marshal.load(Marshal.dump(array || []))
     end
   end
 end
+# rubocop:enable Metrics/ClassLength