fastlane-plugin-translate 0.1.0

data/lib/fastlane/plugin/translate/actions/translate_with_deepl.rb

@@ -0,0 +1,547 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'fileutils'
+require 'deepl'
+
+module Fastlane
+  module Actions
+    module SharedValues
+      TRANSLATE_WITH_DEEPL_TRANSLATED_COUNT = :TRANSLATE_WITH_DEEPL_TRANSLATED_COUNT
+      TRANSLATE_WITH_DEEPL_TARGET_LANGUAGE = :TRANSLATE_WITH_DEEPL_TARGET_LANGUAGE
+      TRANSLATE_WITH_DEEPL_BACKUP_FILE = :TRANSLATE_WITH_DEEPL_BACKUP_FILE
+    end
+
+    class TranslateWithDeeplAction < Action
+      def self.run(params)
+        # Setup and validation
+        setup_deepl_client(params)
+        xcstrings_path = find_xcstrings_file(params[:xcstrings_path])
+        backup_file = create_backup(xcstrings_path)
+
+        # Parse xcstrings file
+        xcstrings_data = JSON.parse(File.read(xcstrings_path))
+        source_language = xcstrings_data['sourceLanguage']
+        available_languages = extract_available_languages(xcstrings_data)
+
+        # Filter languages supported by DeepL
+        supported_languages = Helper::DeeplLanguageMapperHelper.supported_languages_from_list(available_languages)
+        unsupported_languages = Helper::DeeplLanguageMapperHelper.unsupported_languages(available_languages)
+
+        UI.important("⚠️  Languages not supported by DeepL: #{unsupported_languages.map { |l| "#{Helper::LanguageRegistryHelper.language_name(l)} (#{l})" }.join(', ')}") if unsupported_languages.any?
+
+        UI.user_error!('❌ No DeepL-supported languages found in xcstrings file') if supported_languages.empty?
+
+        # Language selection
+        target_language = select_target_language(params[:target_language], supported_languages, xcstrings_data)
+
+        # Formality detection
+        formality = detect_and_ask_formality(target_language, params[:formality])
+
+        # Translate the selected language
+        translated_count = translate_language(xcstrings_data, xcstrings_path, source_language, target_language, formality, params)
+
+        # Set shared values for other actions
+        Actions.lane_context[SharedValues::TRANSLATE_WITH_DEEPL_TRANSLATED_COUNT] = translated_count
+        Actions.lane_context[SharedValues::TRANSLATE_WITH_DEEPL_TARGET_LANGUAGE] = target_language
+        Actions.lane_context[SharedValues::TRANSLATE_WITH_DEEPL_BACKUP_FILE] = backup_file
+
+        UI.success('🎉 Translation completed!')
+        UI.message("📊 Translated #{translated_count} strings for #{Helper::LanguageRegistryHelper.language_name(target_language)} (#{target_language})")
+        UI.message("📄 Backup saved: #{backup_file}")
+        UI.message('🗑️  You can delete the backup after verifying results')
+
+        translated_count
+      end
+
+      def self.setup_deepl_client(params)
+        DeepL.configure do |config|
+          config.auth_key = params[:api_token]
+          config.host = params[:free_api] ? 'https://api-free.deepl.com' : 'https://api.deepl.com'
+        end
+
+        # Test API key
+        begin
+          DeepL.usage
+          UI.success('✅ DeepL API key validated')
+        rescue DeepL::Exceptions::AuthorizationFailed
+          UI.user_error!('❌ Invalid DeepL API key. Get one at: https://www.deepl.com/pro#developer')
+        rescue StandardError => e
+          UI.user_error!("❌ DeepL API connection failed: #{e.message}")
+        end
+      end
+
+      def self.find_xcstrings_file(provided_path)
+        if provided_path
+          UI.user_error!("❌ Localizable.xcstrings file not found at: #{provided_path}") unless File.exist?(provided_path)
+          return provided_path
+        end
+
+        # Search for xcstrings files
+        xcstrings_files = Dir.glob('**/Localizable.xcstrings')
+
+        UI.user_error!('❌ No Localizable.xcstrings files found. Please specify the path with xcstrings_path parameter.') if xcstrings_files.empty?
+
+        if xcstrings_files.count == 1
+          UI.message("📁 Found xcstrings file: #{xcstrings_files.first}")
+          return xcstrings_files.first
+        end
+
+        # Multiple files found, let user choose
+        UI.message('📁 Multiple xcstrings files found:')
+        UI.select('Choose file:', xcstrings_files)
+      end
+
+      def self.create_backup(xcstrings_path)
+        timestamp = Time.now.strftime('%Y%m%d_%H%M%S')
+        backup_path = "#{xcstrings_path}.backup_#{timestamp}"
+        FileUtils.cp(xcstrings_path, backup_path)
+        UI.message("💾 Backup created: #{backup_path}")
+        backup_path
+      end
+
+      def self.extract_available_languages(xcstrings_data)
+        languages = Set.new
+
+        xcstrings_data['strings'].each do |_, string_data|
+          next unless string_data['localizations']
+
+          string_data['localizations'].each_key { |lang| languages.add(lang) }
+        end
+
+        # Remove source language from target options
+        source_lang = xcstrings_data['sourceLanguage']
+        languages.delete(source_lang)
+
+        languages.to_a.sort
+      end
+
+      def self.select_target_language(param_language, available_languages, xcstrings_data)
+        if param_language
+          UI.user_error!("❌ Language '#{param_language}' not found in xcstrings file. Available: #{available_languages.join(', ')}") unless available_languages.include?(param_language)
+          return param_language
+        end
+
+        # Calculate translation percentages for each language
+        language_stats = calculate_translation_stats(xcstrings_data, available_languages)
+
+        # Create display list with language names and translation status
+        language_options = available_languages.map do |lang_code|
+          lang_name = Helper::LanguageRegistryHelper.language_name(lang_code)
+          stats = language_stats[lang_code]
+          percentage = ((stats[:translated].to_f / stats[:total]) * 100).round(1)
+
+          display_name = "#{lang_name} (#{lang_code}): #{percentage}% translated (#{stats[:untranslated]} remaining"
+          display_name += ", #{stats[:skipped_dont_translate]} don't translate" if (stats[:skipped_dont_translate]).positive?
+          display_name += ')'
+
+          # Add formality indicator
+          display_name += ' [supports formality]' if Helper::DeeplLanguageMapperHelper.supports_formality?(lang_code)
+
+          { display: display_name, code: lang_code, stats: }
+        end
+
+        # Sort by most untranslated first (prioritize languages that need work)
+        language_options.sort_by! { |opt| -opt[:stats][:untranslated] }
+
+        UI.message('📋 Available languages for translation:')
+        selected_display = UI.select('Choose target language:', language_options.map { |opt| opt[:display] })
+
+        # Find the corresponding language code
+        selected_option = language_options.find { |opt| opt[:display] == selected_display }
+        selected_option[:code]
+      end
+
+      def self.calculate_translation_stats(xcstrings_data, languages)
+        stats = {}
+
+        languages.each do |lang_code|
+          total = 0
+          translated = 0
+          skipped_dont_translate = 0
+
+          xcstrings_data['strings'].each do |string_key, string_data|
+            next if string_key.empty?
+            next unless string_data.dig('localizations', lang_code)
+
+            # Skip strings marked as "Don't translate" from statistics
+            if string_data['shouldTranslate'] == false
+              skipped_dont_translate += 1
+              next
+            end
+
+            total += 1
+            localization = string_data.dig('localizations', lang_code, 'stringUnit')
+
+            if localization && localization['state'] == 'translated' &&
+               localization['value'] && !localization['value'].empty?
+              translated += 1
+            end
+          end
+
+          stats[lang_code] = {
+            total:,
+            translated:,
+            untranslated: total - translated,
+            skipped_dont_translate:
+          }
+        end
+
+        stats
+      end
+
+      def self.detect_and_ask_formality(target_language, formality_param)
+        return formality_param if formality_param
+        return nil unless Helper::DeeplLanguageMapperHelper.supports_formality?(target_language)
+
+        lang_name = Helper::LanguageRegistryHelper.language_name(target_language)
+        choice = UI.select(
+          "🎭 #{lang_name} supports formality options. Choose style:",
+          ['default', 'more (formal)', 'less (informal)', 'prefer_more (formal if possible)', 'prefer_less (informal if possible)']
+        )
+
+        case choice
+        when 'more (formal)' then 'more'
+        when 'less (informal)' then 'less'
+        when 'prefer_more (formal if possible)' then 'prefer_more'
+        when 'prefer_less (informal if possible)' then 'prefer_less'
+        end
+      end
+
+      def self.translate_language(xcstrings_data, xcstrings_path, source_language, target_language, formality, params)
+        # Validate DeepL support
+        UI.user_error!("❌ Language '#{target_language}' is not supported by DeepL") unless Helper::DeeplLanguageMapperHelper.supported?(target_language)
+
+        # Get DeepL language codes
+        deepl_source = Helper::DeeplLanguageMapperHelper.get_source_language(source_language)
+        deepl_target = Helper::DeeplLanguageMapperHelper.get_target_language(target_language)
+
+        UI.message("🔄 Translating from #{deepl_source} to #{deepl_target}")
+
+        # Progress setup
+        progress = Helper::TranslationProgressHelper.create_progress_tracker(xcstrings_path, target_language)
+
+        if progress.has_progress?
+          summary = progress.progress_summary
+          UI.message("📈 Found existing progress: #{summary[:translated_count]} strings translated")
+          choice = UI.select('Continue from where you left off?', ['Yes, continue', 'No, start fresh'])
+          progress.cleanup if choice == 'No, start fresh'
+        end
+
+        # Extract untranslated strings
+        untranslated_strings = extract_untranslated_strings(
+          xcstrings_data, source_language, target_language, progress.get_translated_strings
+        )
+
+        if untranslated_strings.empty?
+          UI.success("✅ All strings already translated for #{target_language}")
+          progress.cleanup
+          return 0
+        end
+
+        UI.message("📝 Found #{untranslated_strings.count} untranslated strings")
+
+        # Batch translation
+        translated_count = translate_in_batches(
+          untranslated_strings, deepl_source, deepl_target,
+          formality, params[:batch_size], progress
+        )
+
+        # Update xcstrings file
+        update_xcstrings_file(xcstrings_path, xcstrings_data, target_language,
+                              progress.get_translated_strings)
+
+        # Validation and cleanup
+        validate_json_file(xcstrings_path)
+        progress.cleanup
+
+        translated_count
+      end
+
+      def self.extract_untranslated_strings(xcstrings_data, source_language, target_language, already_translated)
+        untranslated = {}
+
+        xcstrings_data['strings'].each do |string_key, string_data|
+          next if string_key.empty? # Skip empty keys
+
+          # Skip strings marked as "Don't translate" in Xcode
+          if string_data['shouldTranslate'] == false
+            UI.message("⏭️ Skipping string marked as 'Don't translate': \"#{string_key}\"")
+            next
+          end
+
+          localization = string_data.dig('localizations', target_language, 'stringUnit')
+          next unless localization
+
+          # Check if NOT fully translated (inverse of the translation stats logic)
+          # A string is considered translated only if: state == 'translated' AND has non-empty value
+          is_fully_translated = localization['state'] == 'translated' &&
+                                localization['value'] && !localization['value'].empty?
+          next if is_fully_translated
+
+          # Skip if already translated in progress
+          next if already_translated[string_key]
+
+          # Get source text from source language
+          source_text = string_data.dig('localizations', source_language, 'stringUnit', 'value')
+          next if source_text.nil? || source_text.empty?
+
+          context = extract_string_context(string_key, string_data)
+          untranslated[string_key] = {
+            'source_text' => source_text,
+            'context' => context
+          }
+        end
+
+        untranslated
+      end
+
+      def self.extract_string_context(string_key, string_data)
+        # Check for comment field in the string data
+        comment = string_data['comment']
+        return comment if comment && !comment.empty?
+
+        # Fallback: use string key as minimal context if it's descriptive
+        string_key.length > 50 ? nil : string_key
+      end
+
+      def self.translate_in_batches(untranslated_strings, source_lang, target_lang, formality, batch_size, progress)
+        batches = untranslated_strings.each_slice(batch_size).to_a
+        total_translated = 0
+
+        batches.each_with_index do |batch, index|
+          UI.message("🔄 Translating batch #{index + 1}/#{batches.count} (#{batch.count} strings)...")
+
+          # Prepare batch for DeepL API
+          texts_to_translate = batch.map { |_, data| data['source_text'] }
+
+          retry_count = 0
+          max_retries = 3
+
+          begin
+            # Build translation options (exclude source_lang and target_lang)
+            translation_options = {}
+            translation_options[:formality] = formality if formality
+
+            # Get context from first item if available (DeepL applies to all)
+            first_context = batch.first&.last&.dig('context')
+            translation_options[:context] = first_context if first_context
+
+            # Call DeepL with positional arguments for source_lang and target_lang
+            translations = DeepL.translate(texts_to_translate, source_lang, target_lang, translation_options)
+
+            # Save translations to progress (only save non-empty translations)
+            translated_batch = {}
+            skipped_empty = 0
+
+            batch.each_with_index do |(string_key, _), text_index|
+              translated_text = translations.is_a?(Array) ? translations[text_index].text : translations.text
+
+              # Only save non-empty translations
+              if translated_text && !translated_text.strip.empty?
+                translated_batch[string_key] = translated_text
+              else
+                skipped_empty += 1
+                UI.important("⚠️ Skipping empty translation for: \"#{string_key}\"")
+              end
+            end
+
+            progress.save_translated_strings(translated_batch)
+            total_translated += translated_batch.size
+
+            success_msg = "✅ Batch #{index + 1} completed (#{translated_batch.size} strings translated"
+            success_msg += ", #{skipped_empty} empty translations skipped" if skipped_empty.positive?
+            success_msg += ')'
+            UI.success(success_msg)
+          rescue DeepL::Exceptions::AuthorizationFailed
+            UI.user_error!('❌ Invalid DeepL API key')
+          rescue DeepL::Exceptions::QuotaExceeded
+            UI.user_error!('❌ DeepL quota exceeded. Upgrade your plan or wait for reset.')
+          rescue DeepL::Exceptions::LimitExceeded
+            action = handle_rate_limit_error(batch, index, batches.count)
+            if action == :retry && retry_count < max_retries
+              retry_count += 1
+              retry
+            elsif action == :skip
+              next
+            end
+          rescue StandardError => e
+            action = handle_translation_error(e, batch, index, batches.count)
+            if action == :retry && retry_count < max_retries
+              retry_count += 1
+              retry
+            elsif action == :skip
+              next
+            end
+          end
+        end
+
+        total_translated
+      end
+
+      def self.handle_rate_limit_error(_batch, index, total_batches)
+        choice = UI.select("⚠️ Rate limit exceeded for batch #{index + 1}/#{total_batches}",
+                           ['Wait 60s and retry', 'Skip this batch', 'Abort translation'])
+        case choice
+        when 'Wait 60s and retry'
+          UI.message('⏳ Waiting 60 seconds...')
+          sleep(60)
+          :retry
+        when 'Skip this batch'
+          UI.important("⏭️ Skipping batch #{index + 1}")
+          :skip
+        when 'Abort translation'
+          UI.user_error!('❌ Translation aborted by user')
+        end
+      end
+
+      def self.handle_translation_error(error, _batch, index, total_batches)
+        UI.error("❌ Translation error for batch #{index + 1}/#{total_batches}: #{error.message}")
+        choice = UI.select('Choose action:', ['Skip this batch', 'Retry batch', 'Abort translation'])
+
+        case choice
+        when 'Skip this batch'
+          UI.important("⏭️ Skipping batch #{index + 1}")
+          :skip
+        when 'Retry batch'
+          UI.message("🔄 Retrying batch #{index + 1}")
+          :retry
+        when 'Abort translation'
+          UI.user_error!('❌ Translation aborted by user')
+        end
+      end
+
+      def self.update_xcstrings_file(xcstrings_path, xcstrings_data, target_language, translated_strings)
+        UI.message("📝 Updating xcstrings file with #{translated_strings.size} translations...")
+
+        # Update the JSON structure
+        actually_updated = 0
+        translated_strings.each do |string_key, translated_text|
+          localization = xcstrings_data.dig('strings', string_key, 'localizations', target_language, 'stringUnit')
+          next unless localization
+
+          # Double-check: only mark as translated if we have actual content
+          if translated_text && !translated_text.strip.empty?
+            localization['value'] = translated_text
+            localization['state'] = 'translated'
+            actually_updated += 1
+          else
+            # Keep as 'new' if translation is empty
+            localization['value'] = translated_text || ''
+            localization['state'] = 'new'
+            UI.important("⚠️ Keeping empty translation as 'new' state: \"#{string_key}\"")
+          end
+        end
+
+        # Write updated JSON back to file
+        File.write(xcstrings_path, JSON.pretty_generate(xcstrings_data))
+        UI.success("💾 Updated xcstrings file (#{actually_updated} marked as translated)")
+      end
+
+      def self.validate_json_file(xcstrings_path)
+        JSON.parse(File.read(xcstrings_path))
+        UI.success('✅ Updated xcstrings file is valid JSON')
+      rescue JSON::ParserError => e
+        UI.user_error!("❌ Generated xcstrings file is invalid JSON: #{e.message}")
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        'Automatically translate untranslated strings in Localizable.xcstrings using DeepL API'
+      end
+
+      def self.details
+        'This action finds your Localizable.xcstrings file, analyzes translation status for each language, ' \
+          'and uses DeepL API to translate missing strings. It supports progress tracking, formality options, ' \
+          'and provides comprehensive error handling with user choices for recovery.'
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(
+            key: :api_token,
+            env_name: 'DEEPL_AUTH_KEY',
+            description: 'DeepL API authentication key',
+            sensitive: true,
+            verify_block: proc do |value|
+              UI.user_error!('DeepL API key required. Get one at: https://www.deepl.com/pro#developer') if value.to_s.empty?
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :xcstrings_path,
+            description: 'Path to Localizable.xcstrings file (auto-detected if not provided)',
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :target_language,
+            description: 'Target language code (e.g., "de", "fr", "es") - will prompt if not provided',
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :batch_size,
+            description: 'Number of strings to translate per API call',
+            type: Integer,
+            default_value: 50,
+            verify_block: proc do |value|
+              UI.user_error!('Batch size must be between 1 and 50') unless (1..50).cover?(value)
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :free_api,
+            description: 'Use DeepL Free API endpoint instead of Pro',
+            type: Boolean,
+            default_value: false
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :formality,
+            description: 'Translation formality (auto-detected if language supports it): default, more, less, prefer_more, prefer_less',
+            optional: true,
+            verify_block: proc do |value|
+              if value
+                valid_options = %w[default more less prefer_more prefer_less]
+                UI.user_error!("Invalid formality. Use: #{valid_options.join(', ')}") unless valid_options.include?(value)
+              end
+            end
+          )
+        ]
+      end
+
+      def self.output
+        [
+          ['TRANSLATE_WITH_DEEPL_TRANSLATED_COUNT', 'Number of strings that were translated'],
+          ['TRANSLATE_WITH_DEEPL_TARGET_LANGUAGE', 'The target language that was translated'],
+          ['TRANSLATE_WITH_DEEPL_BACKUP_FILE', 'Path to the backup file created before translation']
+        ]
+      end
+
+      def self.return_value
+        'Number of strings that were translated'
+      end
+
+      def self.authors
+        ['Your GitHub/Twitter Name']
+      end
+
+      def self.is_supported?(platform)
+        platform == :ios
+      end
+      # rubocop:enable Naming/PredicateName
+
+      def self.example_code
+        [
+          'translate_with_deepl',
+          'translate_with_deepl(target_language: "de")',
+          'translate_with_deepl(target_language: "fr", formality: "more")',
+          'translate_with_deepl(xcstrings_path: "./MyApp/Localizable.xcstrings", free_api: true)'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/translate/helper/deepl_language_mapper_helper.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'fastlane_core/ui/ui'
+
+module Fastlane
+  UI = FastlaneCore::UI unless Fastlane.const_defined?(:UI)
+
+  module Helper
+    class DeeplLanguageMapperHelper
+      # DeepL API language mappings
+      # Based on: https://developers.deepl.com/docs/resources/supported-languages
+      DEEPL_MAPPINGS = {
+        # iOS language code => { source: DeepL_source_code, target: DeepL_target_code }
+        'ar' => { source: 'AR', target: 'AR' },
+        'bg' => { source: 'BG', target: 'BG' },
+        'cs' => { source: 'CS', target: 'CS' },
+        'da' => { source: 'DA', target: 'DA' },
+        'de' => { source: 'DE', target: 'DE' },
+        'el' => { source: 'EL', target: 'EL' },
+        'en' => { source: 'EN', target: 'EN' },
+        'en-US' => { source: 'EN', target: 'EN-US' },
+        'en-GB' => { source: 'EN', target: 'EN-GB' },
+        'en-AU' => { source: 'EN', target: 'EN-GB' }, # DeepL doesn't have AU variant
+        'en-CA' => { source: 'EN', target: 'EN-US' }, # DeepL doesn't have CA variant
+        'es' => { source: 'ES', target: 'ES' },
+        'es-ES' => { source: 'ES', target: 'ES' },
+        'es-MX' => { source: 'ES', target: 'ES' }, # DeepL doesn't distinguish ES variants for target
+        'et' => { source: 'ET', target: 'ET' },
+        'fi' => { source: 'FI', target: 'FI' },
+        'fr' => { source: 'FR', target: 'FR' },
+        'fr-CA' => { source: 'FR', target: 'FR' },
+        'hu' => { source: 'HU', target: 'HU' },
+        'id' => { source: 'ID', target: 'ID' },
+        'it' => { source: 'IT', target: 'IT' },
+        'ja' => { source: 'JA', target: 'JA' },
+        'ko' => { source: 'KO', target: 'KO' },
+        'lt' => { source: 'LT', target: 'LT' },
+        'lv' => { source: 'LV', target: 'LV' },
+        'nb' => { source: 'NB', target: 'NB' },
+        'nl' => { source: 'NL', target: 'NL' },
+        'pl' => { source: 'PL', target: 'PL' },
+        'pt' => { source: 'PT', target: 'PT-PT' },
+        'pt-BR' => { source: 'PT', target: 'PT-BR' },
+        'pt-PT' => { source: 'PT', target: 'PT-PT' },
+        'ro' => { source: 'RO', target: 'RO' },
+        'ru' => { source: 'RU', target: 'RU' },
+        'sk' => { source: 'SK', target: 'SK' },
+        'sl' => { source: 'SL', target: 'SL' },
+        'sv' => { source: 'SV', target: 'SV' },
+        'tr' => { source: 'TR', target: 'TR' },
+        'uk' => { source: 'UK', target: 'UK' },
+        'zh' => { source: 'ZH', target: 'ZH' },
+        'zh-Hans' => { source: 'ZH', target: 'ZH' },
+        'zh-Hant' => { source: 'ZH', target: 'ZH-HANT' },
+        'zh-HK' => { source: 'ZH', target: 'ZH-HANT' }
+      }.freeze
+
+      # Languages that support formality in DeepL
+      FORMALITY_SUPPORTED = %w[DE FR IT ES NL PL PT-BR PT-PT JA RU].freeze
+
+      def self.supported?(ios_language_code)
+        DEEPL_MAPPINGS.key?(ios_language_code)
+      end
+
+      def self.get_source_language(ios_language_code)
+        mapping = DEEPL_MAPPINGS[ios_language_code]
+        return nil unless mapping
+
+        mapping[:source]
+      end
+
+      def self.get_target_language(ios_language_code)
+        mapping = DEEPL_MAPPINGS[ios_language_code]
+        return nil unless mapping
+
+        mapping[:target]
+      end
+
+      def self.supports_formality?(ios_language_code)
+        target_lang = get_target_language(ios_language_code)
+        return false unless target_lang
+
+        FORMALITY_SUPPORTED.include?(target_lang)
+      end
+
+      def self.unsupported_languages(ios_language_codes)
+        ios_language_codes.reject { |code| supported?(code) }
+      end
+
+      def self.supported_languages_from_list(ios_language_codes)
+        ios_language_codes.select { |code| supported?(code) }
+      end
+
+      def self.all_supported_languages
+        DEEPL_MAPPINGS.keys
+      end
+    end
+  end
+end