fastlane-plugin-translate 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '094cd9a767279fbff36838d5bea6a4adb7e6f64381df5cf2ae934e1a37c7038e'
-  data.tar.gz: f0de0b5a62196fc84570c1d8cd44651b16a75193f9659ac4eca2baea203ade18
+  metadata.gz: cb50e549d9a01fa0537ad44d52a80ddb8fb372417336eb31e2455b684f84ecba
+  data.tar.gz: c9a6afa40d2c1d40fc07cc1bf4a143f71db9603519c4a9c20cbdd356adf56ce9
 SHA512:
-  metadata.gz: 75d924a65adfdb29515f747fb4513eed4bdc85eec3d378c299656f7aaecb0934e1ec33494714a2e4296141a0d6b2478083b02b5b1dc01fa2a2bfb9df9abfacfa
-  data.tar.gz: 0cca73dcf50da91a43bb3ff19e838ff0da44331e8a44b6e32551009d824516c29e87873750bc3a46d7b0ef4dc700d54567b943f81551854fd4866977a1b9fcec
+  metadata.gz: ce8b51d5e1c16e0249d56b90c2b1500dcbcb4d82560e6d64da3c1a88753e0f13a96d21110c9f743613ec168a029f0f2dc9dd7ad48dc988d258e3d4d7ef8942e2
+  data.tar.gz: 682624a1f320c81a3304d3a6dab231909e3c6dce4a0e7c7b7c624db178afc312a57d7dd760df983a8f126352149b5610db5c077a07f9a92bf0250be036d44936

data/README.md

@@ -6,14 +6,16 @@
 
 [![fastlane Plugin Badge](https://rawcdn.githack.com/fastlane/fastlane/master/fastlane/assets/plugin-badge.svg)](https://rubygems.org/gems/fastlane-plugin-translate)
 [![Gem Version](https://badge.fury.io/rb/fastlane-plugin-translate.svg)](https://badge.fury.io/rb/fastlane-plugin-translate)
-[![Buy Me A Coffee](https://img.shields.io/badge/Buy%20Me%20A%20Coffee-support-yellow.svg?style=flat)](https://buymeacoffee.com/xocrgwybbs)
+[![ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/D1D6P4LAR)
 
 ## About translate
 
-Automatically translate iOS `Localizable.xcstrings` files using DeepL API. This plugin helps you efficiently manage app localization by translating untranslated strings while preserving your existing translations.
+Automatically translate iOS `Localizable.xcstrings` files and App Store metadata using DeepL API. This plugin helps you efficiently manage app localization by translating untranslated strings while preserving your existing translations, and seamlessly translate App Store metadata files like release notes and descriptions to all your supported languages.
 
 ## Features
 
+### App Strings Translation
+
 - **Language selection with progress**: Shows translation completeness for each language
 - **Smart targeting**: Only translates missing strings, preserves existing translations
 - **Formality options**: Formal/informal translation styles for supported languages
@@ -22,6 +24,14 @@ Automatically translate iOS `Localizable.xcstrings` files using DeepL API. This
 - **Automatic backups**: Safe translation with rollback capability
 - **Error recovery**: Handle API failures gracefully with retry options
 
+### App Store Metadata Translation
+
+- **Auto-detection**: Automatically detects target languages from existing metadata directories
+- **Smart mapping**: Handles App Store locale directory names to DeepL language codes
+- **Multiple files**: Translate release notes, descriptions, keywords, or any metadata file
+- **Batch translation**: Translate to all supported languages in one command
+- **Error resilience**: Continues translating other languages if one fails
+
 ## Getting Started
 
 ### Install from RubyGems (Recommended)
@@ -108,6 +118,173 @@ translate_with_deepl(
 )
 ```
 
+## App Store Metadata Translation
+
+In addition to translating app strings, the plugin can translate App Store metadata files like release notes, descriptions, and keywords using the `translate_metadata_with_deepl` action.
+
+### Features
+
+- **Auto-detection**: Automatically detects target languages from existing metadata directories
+- **Smart mapping**: Handles App Store locale directory names (e.g., `de-DE`, `fr-FR`) to DeepL language codes
+- **Multiple files**: Translate `release_notes.txt`, `description.txt`, `keywords.txt`, or any metadata file
+- **Backup creation**: Creates backups before translation for safety
+- **Progress tracking**: Shows translation progress for each language
+- **Error resilience**: Continues translating other languages if one fails
+
+### Basic Metadata Translation
+
+```ruby
+# Translate release notes to all detected languages
+translate_metadata_with_deepl(
+  file_name: "release_notes.txt"
+)
+```
+
+### Fastfile Examples
+
+```ruby
+# Translate release notes to all supported languages
+lane :release_notes_translate do
+  translate_metadata_with_deepl(
+    metadata_path: "./fastlane/metadata",
+    source_locale: "en-US",
+    file_name: "release_notes.txt",
+    formality: "prefer_less"
+  )
+end
+
+# Translate app description
+lane :description_translate do
+  translate_metadata_with_deepl(
+    file_name: "description.txt",
+    formality: "prefer_more"
+  )
+end
+
+# Translate any metadata file
+lane :translate_metadata do |options|
+  file_name = options[:file] || UI.input("Enter metadata file name: ")
+  
+  translate_metadata_with_deepl(
+    file_name: file_name,
+    formality: "prefer_less"
+  )
+end
+```
+
+### Advanced Configuration
+
+```ruby
+# Translate only to specific languages
+translate_metadata_with_deepl(
+  file_name: "release_notes.txt",
+  target_languages: ["de", "fr", "es", "ja"],
+  formality: "more"
+)
+
+# Use custom metadata path and source locale
+translate_metadata_with_deepl(
+  metadata_path: "./custom/metadata",
+  source_locale: "en-GB",
+  file_name: "keywords.txt",
+  formality: "prefer_less"
+)
+```
+
+### Metadata Translation Parameters
+
+| Parameter | Description | Default | Required |
+|-----------|-------------|---------|----------|
+| `metadata_path` | Path to fastlane metadata directory | `./fastlane/metadata` | No |
+| `source_locale` | Source language locale (e.g., en-US) | `en-US` | No |
+| `file_name` | Metadata file to translate | `release_notes.txt` | No |
+| `target_languages` | Specific languages to translate to | Auto-detected | No |
+| `formality` | Translation formality setting | Language default | No |
+| `api_token` | DeepL API authentication key | `ENV['DEEPL_AUTH_KEY']` | Yes |
+| `free_api` | Use DeepL Free API endpoint | `false` | No |
+
+### Example Output
+
+```
+🔍 Auto-detecting target languages from metadata directories...
+📁 Found metadata directories for: de, fr, es, ja, ko, zh-Hans
+✅ DeepL API key validated
+💾 Backup created: ./fastlane/metadata/en-US/release_notes.txt.backup_20241201_163535
+
+📋 Translating release_notes.txt from en-US to 6 languages:
+  • German (de)
+  • French (fr)
+  • Spanish (es)
+  • Japanese (ja)
+  • Korean (ko)
+  • Chinese (Simplified) (zh-Hans)
+
+🔄 Translating to German (de)...
+✅ de: Translation completed
+🔄 Translating to French (fr)...
+✅ fr: Translation completed
+🔄 Translating to Spanish (es)...
+✅ es: Translation completed
+
+🎉 Metadata translation completed!
+📊 Successfully translated release_notes.txt for 6 languages
+📄 Backup saved: ./fastlane/metadata/en-US/release_notes.txt.backup_20241201_163535
+```
+
+### Directory Structure
+
+The action expects and maintains the standard fastlane metadata structure:
+
+```
+fastlane/
+└── metadata/
+    ├── en-US/           # Source locale
+    │   ├── release_notes.txt
+    │   ├── description.txt
+    │   └── keywords.txt
+    ├── de-DE/           # German
+    │   ├── release_notes.txt
+    │   └── description.txt
+    ├── fr-FR/           # French
+    │   └── release_notes.txt
+    └── ja/              # Japanese
+        └── release_notes.txt
+```
+
+### Language Mapping
+
+The plugin automatically handles App Store locale directory naming:
+
+| App Store Directory | DeepL Language Code | Language |
+|---------------------|---------------------|----------|
+| `de-DE` | `de` | German |
+| `fr-FR` | `fr` | French |
+| `es-ES` | `es` | Spanish |
+| `nl-NL` | `nl` | Dutch |
+| `no` | `nb` | Norwegian Bokmål |
+| `pt-BR` | `pt-BR` | Portuguese (Brazil) |
+| `pt-PT` | `pt-PT` | Portuguese (Portugal) |
+| `zh-Hans` | `zh` | Chinese (Simplified) |
+
+### Shared Values
+
+The metadata translation action sets these shared values:
+
+- `TRANSLATE_METADATA_WITH_DEEPL_TRANSLATED_COUNT` - Number of languages successfully translated
+- `TRANSLATE_METADATA_WITH_DEEPL_TARGET_LANGUAGES` - Array of target language codes that were translated
+- `TRANSLATE_METADATA_WITH_DEEPL_BACKUP_FILE` - Path to the backup file created
+
+```ruby
+lane :translate_and_upload do
+  count = translate_metadata_with_deepl(file_name: "release_notes.txt")
+  
+  if count > 0
+    upload_to_app_store(skip_binary_upload: true)
+    slack(message: "✅ Translated release notes for #{count} languages and uploaded!")
+  end
+end
+```
+
 ## Supported Languages
 
 The plugin supports all languages available in both Apple's App Store Connect and DeepL API:

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

@@ -0,0 +1,315 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'fileutils'
+require 'deepl'
+
+module Fastlane
+  module Actions
+    module SharedValues
+      TRANSLATE_METADATA_WITH_DEEPL_TRANSLATED_COUNT = :TRANSLATE_METADATA_WITH_DEEPL_TRANSLATED_COUNT
+      TRANSLATE_METADATA_WITH_DEEPL_TARGET_LANGUAGES = :TRANSLATE_METADATA_WITH_DEEPL_TARGET_LANGUAGES
+      TRANSLATE_METADATA_WITH_DEEPL_BACKUP_FILE = :TRANSLATE_METADATA_WITH_DEEPL_BACKUP_FILE
+    end
+
+    class TranslateMetadataWithDeeplAction < Action
+      def self.run(params)
+        # Setup and validation
+        setup_deepl_client(params)
+
+        metadata_path = params[:metadata_path]
+        source_locale = params[:source_locale]
+        file_name = params[:file_name]
+
+        # Validate source file exists
+        source_file_path = File.join(metadata_path, source_locale, file_name)
+        UI.user_error!("❌ Source file not found: #{source_file_path}") unless File.exist?(source_file_path)
+
+        # Read source content
+        source_content = File.read(source_file_path).strip
+        UI.user_error!("❌ Source file is empty: #{source_file_path}") if source_content.empty?
+
+        # Create backup
+        backup_file = create_backup(source_file_path)
+
+        # Detect available target languages
+        target_languages = detect_target_languages(metadata_path, source_locale, params[:target_languages])
+
+        # Filter by DeepL support
+        supported_languages = Helper::DeeplLanguageMapperHelper.supported_languages_from_list(target_languages)
+        unsupported_languages = Helper::DeeplLanguageMapperHelper.unsupported_languages(target_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') if supported_languages.empty?
+
+        UI.message("📋 Translating #{file_name} from #{source_locale} to #{supported_languages.size} languages:")
+        supported_languages.each { |lang| UI.message("  • #{Helper::LanguageRegistryHelper.language_name(lang)} (#{lang})") }
+
+        # Translate to each target language
+        total_translated = 0
+        successful_languages = []
+
+        supported_languages.each do |target_language|
+          UI.message("🔄 Translating to #{Helper::LanguageRegistryHelper.language_name(target_language)} (#{target_language})...")
+
+          begin
+            # Determine formality for this language
+            formality = determine_formality(target_language, params[:formality])
+
+            # Translate content
+            translated_content = translate_content(source_content, source_locale, target_language, formality)
+
+            # Write to target file
+            target_file_path = File.join(metadata_path, map_to_metadata_directory(target_language), file_name)
+            ensure_directory_exists(File.dirname(target_file_path))
+            File.write(target_file_path, translated_content)
+
+            UI.success("✅ #{target_language}: Translation completed")
+            total_translated += 1
+            successful_languages << target_language
+          rescue StandardError => e
+            UI.error("❌ #{target_language}: Translation failed - #{e.message}")
+          end
+        end
+
+        # Set shared values
+        Actions.lane_context[SharedValues::TRANSLATE_METADATA_WITH_DEEPL_TRANSLATED_COUNT] = total_translated
+        Actions.lane_context[SharedValues::TRANSLATE_METADATA_WITH_DEEPL_TARGET_LANGUAGES] = successful_languages
+        Actions.lane_context[SharedValues::TRANSLATE_METADATA_WITH_DEEPL_BACKUP_FILE] = backup_file
+
+        UI.success('🎉 Metadata translation completed!')
+        UI.message("📊 Successfully translated #{file_name} for #{total_translated} languages")
+        UI.message("📄 Backup saved: #{backup_file}")
+        UI.message('🗑️  You can delete the backup after verifying results')
+
+        total_translated
+      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.create_backup(source_file_path)
+        timestamp = Time.now.strftime('%Y%m%d_%H%M%S')
+        backup_path = "#{source_file_path}.backup_#{timestamp}"
+        FileUtils.cp(source_file_path, backup_path)
+        UI.message("💾 Backup created: #{backup_path}")
+        backup_path
+      end
+
+      def self.detect_target_languages(metadata_path, source_locale, specified_languages)
+        if specified_languages && !specified_languages.empty?
+          UI.message("🎯 Using specified target languages: #{specified_languages.join(', ')}")
+          return specified_languages
+        end
+
+        # Auto-detect from existing metadata directories
+        UI.message('🔍 Auto-detecting target languages from metadata directories...')
+
+        detected_languages = []
+        Dir.glob(File.join(metadata_path, '*')).each do |dir|
+          next unless File.directory?(dir)
+
+          locale = File.basename(dir)
+          next if locale == source_locale # Skip source locale
+          next if locale == 'default' # Skip special directories
+          next if locale == 'review_information'
+
+          # Map metadata directory names to DeepL-compatible language codes
+          deepl_language = map_metadata_directory_to_language(locale)
+          detected_languages << deepl_language
+        end
+
+        UI.message("📁 Found metadata directories for: #{detected_languages.join(', ')}")
+        detected_languages
+      end
+
+      def self.map_metadata_directory_to_language(metadata_dir)
+        # Map App Store metadata directory names to DeepL-compatible language codes
+        case metadata_dir
+        when 'de-DE'
+          'de' # German metadata directory -> de for DeepL
+        when 'es-ES'
+          'es' # Spanish (Spain) metadata directory -> es for DeepL
+        when 'fr-FR'
+          'fr' # French metadata directory -> fr for DeepL
+        when 'nl-NL'
+          'nl' # Dutch metadata directory -> nl for DeepL
+        when 'no'
+          'nb' # Norwegian metadata directory -> nb (Bokmål) for DeepL
+        else
+          metadata_dir # Direct mapping for most languages
+        end
+      end
+
+      def self.determine_formality(target_language, formality_param)
+        return formality_param if formality_param
+
+        if Helper::DeeplLanguageMapperHelper.supports_formality?(target_language)
+          UI.message("🎭 #{Helper::LanguageRegistryHelper.language_name(target_language)} supports formality options")
+          return 'prefer_more' # Default to more formal for App Store metadata
+        end
+
+        nil
+      end
+
+      def self.translate_content(source_content, source_language, target_language, formality)
+        source_lang = Helper::DeeplLanguageMapperHelper.get_source_language(source_language)
+        target_lang = Helper::DeeplLanguageMapperHelper.get_target_language(target_language)
+
+        translation_options = {}
+        translation_options[:formality] = formality if formality
+
+        # DeepL.translate expects: texts, source_lang, target_lang, options
+        result = DeepL.translate([source_content], source_lang, target_lang, translation_options)
+
+        # Handle both single and array responses
+        result.is_a?(Array) ? result.first.text : result.text
+      rescue StandardError => e
+        raise "DeepL translation failed: #{e.message}"
+      end
+
+      def self.map_to_metadata_directory(language_code)
+        # Map DeepL language codes back to App Store metadata directory names
+        case language_code
+        when 'nb'
+          'no' # Norwegian Bokmål -> no
+        when 'de'
+          'de-DE' # German -> de-DE
+        when 'es'
+          'es-ES' # Spanish -> es-ES
+        when 'fr'
+          'fr-FR' # French -> fr-FR
+        when 'nl'
+          'nl-NL' # Dutch -> nl-NL
+        else
+          language_code # Direct mapping for most languages
+        end
+      end
+
+      def self.ensure_directory_exists(directory_path)
+        FileUtils.mkdir_p(directory_path) unless File.directory?(directory_path)
+      end
+
+      def self.description
+        'Translate App Store metadata files using DeepL API'
+      end
+
+      def self.details
+        'This action translates App Store metadata files (like release_notes.txt, description.txt) ' \
+          'from a source language to all supported target languages using DeepL API. ' \
+          'It automatically detects target languages from existing metadata directories ' \
+          'and only translates to languages supported by both App Store and DeepL.'
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(
+            key: :api_token,
+            env_name: 'DEEPL_AUTH_KEY',
+            description: 'DeepL API authentication key',
+            sensitive: true,
+            default_value: ENV.fetch('DEEPL_AUTH_KEY', nil)
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :metadata_path,
+            description: 'Path to fastlane metadata directory',
+            default_value: './fastlane/metadata',
+            verify_block: proc do |value|
+              UI.user_error!("Metadata directory not found: #{value}") unless File.directory?(value)
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :source_locale,
+            description: 'Source language locale (e.g., en-US)',
+            default_value: 'en-US'
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :file_name,
+            description: 'Metadata file to translate (e.g., release_notes.txt, description.txt)',
+            default_value: 'release_notes.txt'
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :target_languages,
+            description: 'Specific target languages to translate to (optional, auto-detects if not specified)',
+            type: Array,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :formality,
+            description: 'Formality setting for translation (default, more, less, prefer_more, prefer_less)',
+            optional: true,
+            verify_block: proc do |value|
+              valid_options = %w[default more less prefer_more prefer_less]
+              UI.user_error!("Invalid formality option. Must be one of: #{valid_options.join(', ')}") unless valid_options.include?(value)
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :free_api,
+            description: 'Use DeepL Free API endpoint',
+            type: Boolean,
+            default_value: false
+          )
+        ]
+      end
+
+      def self.output
+        [
+          ['TRANSLATE_METADATA_WITH_DEEPL_TRANSLATED_COUNT', 'Number of languages successfully translated'],
+          ['TRANSLATE_METADATA_WITH_DEEPL_TARGET_LANGUAGES', 'Array of target language codes that were translated'],
+          ['TRANSLATE_METADATA_WITH_DEEPL_BACKUP_FILE', 'Path to the backup file created before translation']
+        ]
+      end
+
+      def self.return_value
+        'Number of languages that were successfully translated'
+      end
+
+      def self.authors
+        ['tijs']
+      end
+
+      def self.is_supported?(platform)
+        %i[ios android].include?(platform)
+      end
+
+      def self.example_code
+        [
+          '# Translate release notes to all detected languages',
+          'translate_metadata_with_deepl',
+          '',
+          '# Translate description file with specific settings',
+          'translate_metadata_with_deepl(',
+          '  file_name: "description.txt",',
+          '  source_locale: "en-US",',
+          '  formality: "prefer_more"',
+          ')',
+          '',
+          '# Translate only to specific languages',
+          'translate_metadata_with_deepl(',
+          '  file_name: "release_notes.txt",',
+          '  target_languages: ["de", "fr-FR", "es-ES", "ja"]',
+          ')'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+    end
+  end
+end

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

@@ -2,6 +2,6 @@
 
 module Fastlane
   module Translate
-    VERSION = '0.2.0'
+    VERSION = '0.3.0'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-translate
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Tijs Teulings
@@ -164,8 +164,8 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 description: A fastlane plugin to automatically translate iOS Localizable.xcstrings
-  files using DeepL API. Supports progress tracking, formality options, error recovery,
-  and more.
+  files and App Store metadata files using DeepL API. Supports progress tracking,
+  formality options, error recovery, auto-detection of target languages, and more.
 email: hello@tijs.org
 executables: []
 extensions: []
@@ -174,6 +174,7 @@ files:
 - LICENSE
 - README.md
 - lib/fastlane/plugin/translate.rb
+- lib/fastlane/plugin/translate/actions/translate_metadata_with_deepl.rb
 - lib/fastlane/plugin/translate/actions/translate_with_deepl.rb
 - lib/fastlane/plugin/translate/helper/batch_translation_processor.rb
 - lib/fastlane/plugin/translate/helper/deepl_language_mapper_helper.rb
@@ -202,5 +203,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.9
 specification_version: 4
-summary: Automatically translate iOS Localizable.xcstrings files using DeepL API
+summary: Automatically translate iOS Localizable.xcstrings files and App Store metadata
+  using DeepL API
 test_files: []