better_translate 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ac3bc8d98853820f1c6367bbbe4fb36733a872de35eef7ff8bc47349fc9376e5
+  data.tar.gz: fa486ddb0bf587faee2792bbca54982ddbdffcc44b4b183e9c0de1c849f917b7
+SHA512:
+  metadata.gz: 643e1688cc0171ddee6bfeb848aa1d555922bf2c44907afc56981ea0b5c9dd9ce8fa5788b509596eb53735cd4ce63e1adbccaeb1592f5cb3d1653da794a0c415
+  data.tar.gz: ea2451b736c946d2bead72f3bf36dab06fb38e2037662c160a400f73a1854919314bfecb0a5081b63add8b7a66b1402ae85b3cfa42af10149cb9faf9677fba90

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 alessiobussolari
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,116 @@
+# BetterTranslate
+
+BetterTranslate is a Ruby gem that enables you to translate YAML files from a source language into one or more target languages using translation providers such as ChatGPT (OpenAI) and Google Gemini. The gem supports two translation modes:
+
+- **Override**: Completely rewrites the translated file.
+- **Incremental**: Updates the translated file only with new or modified keys while keeping existing ones.
+
+Configuration is centralized via an initializer (for example, in a Rails app), where you can set API keys, the source language, target languages, key exclusions, the output folder, and the translation mode. Additionally, BetterTranslate integrates progress tracking using the [ruby-progressbar](https://github.com/jfelchner/ruby-progressbar) gem.
+
+## Features
+
+- **Multi-language YAML Translation**: Translates YAML files from a source language into one or more target languages.
+- **Multiple Providers**: Supports ChatGPT (OpenAI) and Google Gemini (with potential for extending to other providers in the future).
+- **Translation Modes**:
+    - **Override**: Rewrites the file from scratch.
+    - **Incremental**: Updates only missing or modified keys.
+- **Centralized Configuration**: Configured via an initializer with settings for API keys, source language, target languages, exclusions (using dot notation), and the output folder.
+- **Progress Bar**: Displays the translation progress using ruby-progressbar.
+
+## Installation
+
+Add the gem to your Gemfile:
+
+```ruby
+gem 'better_translate'
+
+Then run:
+
+```bash
+bundle install
+```
+
+Or install the gem manually:
+
+```bash
+gem install better_translate
+```
+
+## Configuration
+
+In a Rails application, generate the initializer by running:
+
+```bash
+rails generate better_translate:install
+```
+
+This command creates the file `config/initializers/better_translate.rb` with a default configuration. An example configuration is:
+
+```ruby
+BetterTranslate.configure do |config|
+  # Choose the provider to use: :chatgpt or :gemini
+  config.provider = :chatgpt
+
+  # API key for ChatGPT (OpenAI)
+  config.openai_key = ENV.fetch("OPENAI_API_KEY") { "YOUR_OPENAI_API_KEY" }
+
+  # API key for Google Gemini
+  config.google_gemini_key = ENV.fetch("GOOGLE_GEMINI_KEY") { "YOUR_GOOGLE_GEMINI_KEY" }
+
+  # Source language (e.g., "en" if the source file is in English)
+  config.source_language = "en"
+
+  # Output folder where the translated files will be saved
+  config.output_folder = Rails.root.join("config", "locales", "translated").to_s
+
+  # List of target languages (short_name and name)
+  config.target_languages = [
+    # Example:
+    { short_name: "it", name: "italian" }
+  ]
+
+  # Global exclusions (keys in dot notation) to exclude from translation
+  config.global_exclusions = [
+    "key.child_key",
+  ]
+
+  # Language-specific exclusions (optional)
+  config.exclusions_per_language = {
+    "ru" => []
+  }
+
+  # Path to the input file (e.g., en.yml)
+  config.input_file = Rails.root.join("config", "locales", "en.yml").to_s
+
+  # Translation mode: :override or :incremental
+  config.translation_method = :override
+end
+```
+
+## Usage
+
+### YAML File Translation
+
+To start the translation process, simply call the `magic` method:
+
+```ruby
+BetterTranslate.magic
+```
+
+This will execute the process that:
+1. Reads the input YAML file.
+2. Applies any filters (exclusions).
+3. Translates the strings from the source language to the configured target languages.
+4. Writes the translated files to the output folder, either in **override** or **incremental** mode based on the configuration.
+
+## Contributing
+
+Pull requests are welcome! If you would like to suggest improvements or new features, please open an issue to discuss your ideas before submitting a pull request.
+
+## Changelog
+
+See the [CHANGELOG](https://github.com/alessiobussolari/better_translate/blob/main/CHANGELOG.md) for a summary of changes.
+
+## License
+
+BetterTranslate is distributed under the MIT license. See the [LICENSE](LICENSE) file for more details.

data/lib/better_translate/providers/base_provider.rb

@@ -0,0 +1,18 @@
+module BetterTranslate
+  module Providers
+    class BaseProvider
+      def initialize(api_key)
+        @api_key = api_key
+      end
+
+      # Metodo da implementare nelle classi derivate.
+      # @param text [String] testo da tradurre.
+      # @param target_lang_code [String] codice della lingua di destinazione (es. "en").
+      # @param target_lang_name [String] nome della lingua di destinazione (es. "English").
+      # @return [String] testo tradotto.
+      def translate(text, target_lang_code, target_lang_name)
+        raise NotImplementedError, "Il provider #{self.class} deve implementare il metodo translate"
+      end
+    end
+  end
+end

data/lib/better_translate/providers/chatgpt_provider.rb

@@ -0,0 +1,38 @@
+module BetterTranslate
+  module Providers
+    class ChatgptProvider < BaseProvider
+      # Utilizza l'API di OpenAI per tradurre il testo.
+      def translate(text, target_lang_code, target_lang_name)
+        uri = URI("https://api.openai.com/v1/chat/completions")
+        headers = {
+          "Content-Type"  => "application/json",
+          "Authorization" => "Bearer #{@api_key}"
+        }
+
+        # Costruiamo il prompt per tradurre il testo.
+        body = {
+          model: "gpt-3.5-turbo",
+          messages: [
+            { role: "system", content: "Sei un traduttore professionale. Traduci esattamente il seguente testo da #{BetterTranslate.configuration.source_language} a #{target_lang_name} senza aggiungere commenti, spiegazioni o alternative. Fornisci solamente la traduzione diretta:" },
+            { role: "user", content: "#{text}" }
+          ],
+          temperature: 0.3
+        }
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        request = Net::HTTP::Post.new(uri.path, headers)
+        request.body = body.to_json
+
+        response = http.request(request)
+        if response.is_a?(Net::HTTPSuccess)
+          json = JSON.parse(response.body)
+          translated_text = json.dig("choices", 0, "message", "content")
+          translated_text ? translated_text.strip : text
+        else
+          raise "Errore durante la traduzione con ChatGPT: #{response.body}"
+        end
+      end
+    end
+  end
+end

data/lib/better_translate/providers/gemini_provider.rb

@@ -0,0 +1,35 @@
+module BetterTranslate
+  module Providers
+    class GeminiProvider < BaseProvider
+      # Esempio di implementazione per Google Gemini.
+      # Nota: L'endpoint e i parametri sono ipotetici e vanno sostituiti con quelli reali secondo la documentazione ufficiale.
+      def translate(text, target_lang_code, target_lang_name)
+        uri = URI("https://gemini.googleapis.com/v1/translate")
+        headers = {
+          "Content-Type"  => "application/json",
+          "Authorization" => "Bearer #{@api_key}"
+        }
+
+        body = {
+          input_text: text,
+          target_language: target_lang_code,
+          model: "gemini" # oppure altri parametri richiesti dall'API
+        }
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        request = Net::HTTP::Post.new(uri.path, headers)
+        request.body = body.to_json
+
+        response = http.request(request)
+        if response.is_a?(Net::HTTPSuccess)
+          json = JSON.parse(response.body)
+          translated_text = json["translatedText"]
+          translated_text ? translated_text.strip : text
+        else
+          raise "Errore durante la traduzione con Gemini: #{response.body}"
+        end
+      end
+    end
+  end
+end

data/lib/better_translate/service.rb

@@ -0,0 +1,25 @@
+module BetterTranslate
+  class Service
+    def initialize
+      @provider_name = BetterTranslate.configuration.provider
+    end
+
+    # Metodo per tradurre un testo utilizzando il provider selezionato.
+    def translate(text, target_lang_code, target_lang_name)
+      provider_instance.translate(text, target_lang_code, target_lang_name)
+    end
+
+    private
+
+    def provider_instance
+      @provider_instance ||= case @provider_name
+                             when :chatgpt
+                               Providers::ChatgptProvider.new(BetterTranslate.configuration.openai_key)
+                             when :gemini
+                               Providers::GeminiProvider.new(BetterTranslate.configuration.google_gemini_key)
+                             else
+                               raise "Provider non supportato: #{@provider_name}"
+                             end
+    end
+  end
+end

data/lib/better_translate/translator.rb

@@ -0,0 +1,131 @@
+module BetterTranslate
+  class Translator
+    class << self
+      def work
+        puts "Avvio della traduzione dei file..."
+
+        translations = read_yml_source
+
+        # Rimuove le chiavi da escludere (global_exclusions) dalla struttura letta
+        filtered_translations = remove_exclusions(
+          translations, BetterTranslate.configuration.global_exclusions
+        )
+
+        BetterTranslate.configuration.target_languages.each do |target_lang|
+          puts "Inizio traduzione da #{BetterTranslate.configuration.source_language} a #{target_lang[:short_name]}"
+          service = BetterTranslate::Service.new
+          translated_data = translate_with_progress(filtered_translations, service, target_lang[:short_name], target_lang[:name])
+          BetterTranslate::Writer.write_translations(translated_data, target_lang[:short_name])
+          puts "Traduzione completata da #{BetterTranslate.configuration.source_language} a #{target_lang[:short_name]}"
+        end
+
+        "Traduzione iniziata! #{filtered_translations.inspect}"
+      end
+
+      private
+
+      # Legge il file YAML in base al percorso fornito.
+      #
+      # @param file_path [String] percorso del file YAML da leggere
+      # @return [Hash] struttura dati contenente le traduzioni
+      # @raise [StandardError] se il file non esiste
+      def read_yml_source
+        file_path = BetterTranslate.configuration.input_file
+        unless File.exist?(file_path)
+          raise "File non trovato: #{file_path}"
+        end
+
+        YAML.load_file(file_path)
+      end
+
+      # Rimuove le chiavi specificate in exclusion_list dalla struttura dati,
+      # calcolando i percorsi a partire dal contenuto della lingua di partenza.
+      #
+      # Ad esempio, se il file YAML è:
+      # { "en" => { "sample" => { "valid" => "valid", "excluded" => "Excluded" } } }
+      # e exclusion_list = ["sample.excluded"],
+      # il risultato sarà:
+      # { "en" => { "sample" => { "valid" => "valid" } } }
+      #
+      # @param data [Hash, Array, Object] La struttura dati da filtrare.
+      # @param exclusion_list [Array<String>] Lista dei percorsi (in dot notation) da escludere.
+      # @param current_path [Array] Il percorso corrente (usato in maniera ricorsiva).
+      # @return [Hash, Array, Object] La struttura dati filtrata.
+      def remove_exclusions(data, exclusion_list, current_path = [])
+        if data.is_a?(Hash)
+          data.each_with_object({}) do |(key, value), result|
+            # Se siamo al livello top-level e la chiave corrisponde alla lingua di partenza,
+            # resettare il percorso (così da escludere "en" dal percorso finale)
+            new_path = if current_path.empty? && key == BetterTranslate.configuration.source_language
+                         []
+                       else
+                         current_path + [key]
+                       end
+
+            path_string = new_path.join(".")
+            unless exclusion_list.include?(path_string)
+              result[key] = remove_exclusions(value, exclusion_list, new_path)
+            end
+          end
+        elsif data.is_a?(Array)
+          data.map.with_index do |item, index|
+            remove_exclusions(item, exclusion_list, current_path + [index])
+          end
+        else
+          data
+        end
+      end
+
+      # Metodo ricorsivo che percorre la struttura, traducendo ogni stringa e aggiornando il progresso.
+      #
+      # @param data [Hash, Array, String] La struttura dati da tradurre.
+      # @param provider [Object] Il provider che risponde al metodo translate.
+      # @param target_lang_code [String] Codice della lingua target (es. "en").
+      # @param target_lang_name [String] Nome della lingua target (es. "English").
+      # @param progress [Hash] Un hash con le chiavi :count e :total per monitorare il progresso.
+      # @return [Hash, Array, String] La struttura tradotta.
+      def deep_translate_with_progress(data, service, target_lang_code, target_lang_name, progress)
+        if data.is_a?(Hash)
+          data.each_with_object({}) do |(key, value), result|
+            result[key] = deep_translate_with_progress(value, service, target_lang_code, target_lang_name, progress)
+          end
+        elsif data.is_a?(Array)
+          data.map do |item|
+            deep_translate_with_progress(item, service, target_lang_code, target_lang_name, progress)
+          end
+        elsif data.is_a?(String)
+          progress.increment
+          service.translate(data, target_lang_code, target_lang_name)
+        else
+          data
+        end
+      end
+
+      # Metodo principale per tradurre l'intera struttura dati, con monitoraggio del progresso.
+      #
+      # @param data [Hash, Array, String] la struttura dati da tradurre
+      # @param provider [Object] il provider da usare per tradurre (deve implementare translate)
+      # @param target_lang_code [String] codice della lingua target
+      # @param target_lang_name [String] nome della lingua target
+      # @return la struttura tradotta
+      def translate_with_progress(data, service, target_lang_code, target_lang_name)
+        total = count_strings(data)
+        progress = ProgressBar.create(total: total, format: '%a %B %p%% %t')
+        deep_translate_with_progress(data, service, target_lang_code, target_lang_name, progress)
+      end
+
+      # Conta ricorsivamente il numero di stringhe traducibili nella struttura dati.
+      def count_strings(data)
+        if data.is_a?(Hash)
+          data.values.sum { |v| count_strings(v) }
+        elsif data.is_a?(Array)
+          data.sum { |item| count_strings(item) }
+        elsif data.is_a?(String)
+          1
+        else
+          0
+        end
+      end
+    end
+  end
+end

data/lib/better_translate/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module BetterTranslate
+  VERSION = "0.1.0"
+end

data/lib/better_translate/writer.rb

@@ -0,0 +1,64 @@
+module BetterTranslate
+  class Writer
+    class << self
+      # Scrive il file di traduzione per una lingua target.
+      # Se il metodo di traduzione è :override, il file viene riscritto da zero;
+      # se è :incremental, il file esistente viene aggiornato inserendo le nuove traduzioni nelle posizioni corrette.
+      #
+      # @param translated_data [Hash] La struttura dati tradotta (ad es. { "sample" => { "valid" => "tradotto", "new_key" => "nuova traduzione" } }).
+      # @param target_lang_code [String] Codice della lingua target (es. "ru").
+      def write_translations(translated_data, target_lang_code)
+        output_folder = BetterTranslate.configuration.output_folder
+        output_file = File.join(output_folder, "#{target_lang_code}.yml")
+
+        # Riformatta la struttura per utilizzare il codice target come chiave principale.
+        output_content = if translated_data.is_a?(Hash) && translated_data.key?(BetterTranslate.configuration.source_language)
+                           # Sostituisce la chiave della lingua di partenza con quella target.
+                           { target_lang_code => translated_data[BetterTranslate.configuration.source_language] }
+                         else
+                           { target_lang_code => translated_data }
+                         end
+
+        if BetterTranslate.configuration.translation_method.to_sym == :incremental && File.exist?(output_file)
+          existing_data = YAML.load_file(output_file)
+          merged = deep_merge(existing_data, output_content)
+          File.write(output_file, merged.to_yaml(line_width: -1))
+          puts "File aggiornato in modalità incremental: #{output_file}"
+        else
+          FileUtils.mkdir_p(output_folder) unless Dir.exist?(output_folder)
+          File.write(output_file, output_content.to_yaml(line_width: -1))
+          puts "File riscritto in modalità override: #{output_file}"
+        end
+      end
+
+      private
+
+      # Metodo di deep merge: unisce in modo ricorsivo i due hash.
+      # Se una chiave esiste in entrambi gli hash e i valori sono hash, li unisce ricorsivamente.
+      # Altrimenti, se la chiave esiste già nell'hash esistente, la mantiene e non la sovrascrive.
+      # Se la chiave non esiste, la aggiunge.
+      #
+      # @param existing [Hash] hash esistente (file corrente)
+      # @param new_data [Hash] nuovo hash con le traduzioni da unire
+      # @return [Hash] hash unito
+      def deep_merge(existing, new_data)
+        merged = existing.dup
+        new_data.each do |key, value|
+          if merged.key?(key)
+            if merged[key].is_a?(Hash) && value.is_a?(Hash)
+              merged[key] = deep_merge(merged[key], value)
+            else
+              # Se la chiave esiste già, non sovrascrivo il valore (modalità incrementale)
+              # oppure potresti decidere di aggiornare comunque, a seconda delle esigenze.
+              merged[key] = merged[key]
+            end
+          else
+            merged[key] = value
+          end
+        end
+        merged
+      end
+
+    end
+  end
+end

data/lib/better_translate.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+require "ruby-progressbar"
+
+require "better_translate/version"
+require "better_translate/translator"
+require "better_translate/service"
+require "better_translate/writer"
+
+require 'better_translate/providers/base_provider'
+require 'better_translate/providers/chatgpt_provider'
+require 'better_translate/providers/gemini_provider'
+
+module BetterTranslate
+  class << self
+    attr_accessor :configuration
+
+    # Metodo per configurare la gemma
+    def configure
+      self.configuration ||= OpenStruct.new
+      yield(configuration) if block_given?
+    end
+
+    # Metodo install per generare il file di configurazione (initializer)
+    def install
+      unless defined?(Rails) && Rails.respond_to?(:root)
+        puts "Il metodo install è disponibile solo in un'applicazione Rails."
+        return
+      end
+
+      # Costruisce il percorso della cartella template all'interno della gemma
+      source = File.expand_path("../generators/better_translate/templates/better_translate.rb", __dir__)
+      destination = File.join(Rails.root, "config", "initializers", "better_translate.rb")
+
+      if File.exist?(destination)
+        puts "Il file initializer esiste già: #{destination}"
+      else
+        FileUtils.mkdir_p(File.dirname(destination))
+        FileUtils.cp(source, destination)
+        puts "Initializer creato in: #{destination}"
+      end
+    end
+
+    def magic
+      puts "Metodo magic invocato: eseguirò la traduzione dei file..."
+
+      BetterTranslate::Translator.work
+      puts "Metodo magic invocato: Traduzione completata con successo!"
+    end
+
+  end
+end

data/lib/generators/better_translate/install_generator.rb

@@ -0,0 +1,14 @@
+require 'rails/generators'
+
+module BetterTranslate
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path('templates', __dir__)
+      desc "Genera il file config/initializers/better_translate.rb con la configurazione di default"
+
+      def copy_initializer
+        template "better_translate.rb", "config/initializers/better_translate.rb"
+      end
+    end
+  end
+end

data/lib/generators/better_translate/templates/better_translate.rb

@@ -0,0 +1,49 @@
+BetterTranslate.configure do |config|
+  # Scegli il provider da utilizzare: :chatgpt oppure :gemini
+  config.provider = :chatgpt
+
+  # API key per OpenAI
+  config.openai_key = ENV.fetch("OPENAI_API_KEY") { "YOUR_OPENAI_API_KEY" }
+
+  # API key per Google Gemini
+  config.google_gemini_key = ENV.fetch("GOOGLE_GEMINI_KEY") { "YOUR_GOOGLE_GEMINI_KEY" }
+
+  # Lingua sorgente (ad esempio "en" se il file sorgente è in inglese)
+  config.source_language = "en"
+
+  # Lista delle lingue target (short_name e name)
+  config.target_languages = [
+    # { short_name: 'es', name: 'spagnolo' },
+    # { short_name: 'it', name: 'italiano' },
+    # { short_name: 'fr', name: 'francese' },
+    # { short_name: 'de', name: 'tedesco' },
+    # { short_name: 'pt', name: 'portoghese' },
+    { short_name: "ru", name: "russian" }
+  ]
+
+  # Esclusioni globali (percorsi in dot notation) da escludere per tutte le lingue
+  config.global_exclusions = [
+    "key.value"
+  ]
+
+  # Esclusioni specifiche per lingua
+  config.exclusions_per_language = {
+    "es" => [],
+    "it" => [],
+    "fr" => [],
+    "de" => [],
+    "pt" => [],
+    "ru" => []
+  }
+
+  # Percorso del file di input (ad es. en.yml)
+  config.input_file = Rails.root.join("config", "locales", "en.yml").to_s
+
+  # Cartella di output dove verranno salvati i file tradotti
+  config.output_folder = Rails.root.join("config", "locales", "translated").to_s
+
+  # Metodo di traduzione:
+  # - :override => rigenera tutte le traduzioni
+  # - :incremental => aggiorna solo le chiavi mancanti (o quelle che hanno subito modifiche)
+  config.translation_method = :override
+end

metadata

@@ -0,0 +1,138 @@
+--- !ruby/object:Gem::Specification
+name: better_translate
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- alessio_bussolari
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-03-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: yaml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ruby-progressbar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: "\nBetterTranslate è una gemma che consente di tradurre file YAML partendo
+  da una lingua sorgente verso una o più lingue target.\nLa gemma supporta differenti
+  provider di traduzione, attualmente ChatGPT (OpenAI) e Google Gemini, e permette
+  di scegliere\nla modalità di traduzione: \"override\" per rigenerare tutte le traduzioni
+  oppure \"incremental\" per aggiornare solo le chiavi mancanti.\n\nLa configurazione
+  della gemma è centralizzata tramite un initializer, dove è possibile definire API
+  key, lingue target, lingua sorgente,\nesclusioni di chiavi e la cartella di output.
+  BetterTranslate integra inoltre il monitoraggio del progresso della traduzione tramite
+  una progress bar.\n  "
+email:
+- alessio.bussolari@pandev.it
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/better_translate.rb
+- lib/better_translate/providers/base_provider.rb
+- lib/better_translate/providers/chatgpt_provider.rb
+- lib/better_translate/providers/gemini_provider.rb
+- lib/better_translate/service.rb
+- lib/better_translate/translator.rb
+- lib/better_translate/version.rb
+- lib/better_translate/writer.rb
+- lib/generators/better_translate/install_generator.rb
+- lib/generators/better_translate/templates/better_translate.rb
+homepage: https://github.com/alessiobussolari/better_translate
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  rubygems_mfa_required: 'true'
+  homepage_uri: https://github.com/alessiobussolari/better_translate
+  source_code_uri: https://github.com/alessiobussolari/better_translate
+  changelog_uri: https://github.com/alessiobussolari/better_translate/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.11
+signing_key:
+specification_version: 4
+summary: Gemma per tradurre file YAML in più lingue tramite provider (ChatGPT e Gemini)
+test_files: []