better_translate 0.5.0 → 1.0.0

data/lib/better_translate/similarity_analyzer.rb

@@ -1,218 +0,0 @@
-# frozen_string_literal: true
-
-require "yaml"
-require "set"
-require "json"
-require "time"
-
-module BetterTranslate
-  # Analyzes translation YAML files to find similar content across keys.
-  # Uses the Levenshtein distance algorithm to identify strings that are similar
-  # but not identical, which could indicate redundant translations.
-  #
-  # @example
-  #   analyzer = BetterTranslate::SimilarityAnalyzer.new(["config/locales/en.yml", "config/locales/fr.yml"])
-  #   analyzer.analyze
-  class SimilarityAnalyzer
-    # Default threshold for considering two strings similar (75%)
-    # @return [Float] The similarity threshold as a decimal between 0 and 1
-    SIMILARITY_THRESHOLD = 0.75 # Abbassiamo la soglia per trovare più similarità
-    
-    # Default filename for the detailed JSON report
-    # @return [String] The filename for the JSON report
-    REPORT_FILE = "translation_similarities.json"
-
-    # Initializes a new SimilarityAnalyzer with the specified YAML files.
-    #
-    # @param yaml_files [Array<String>] An array of paths to YAML translation files
-    # @return [SimilarityAnalyzer] A new instance of the analyzer
-    def initialize(yaml_files)
-      @yaml_files = yaml_files
-      @similarities = {}
-    end
-
-    # Performs the complete analysis process:
-    # 1. Loads all translation files
-    # 2. Finds similarities between translations
-    # 3. Generates JSON and text reports
-    #
-    # @return [void]
-    def analyze
-      translations_by_language = load_translations
-      find_similarities(translations_by_language)
-      generate_report
-    end
-
-    private
-
-    # Loads all YAML translation files specified during initialization.
-    # Parses each file and organizes translations by language code.
-    #
-    # @return [Hash] A hash mapping language codes to their translation data structures
-    def load_translations
-      translations = {}
-      puts "Loading YAML files..."
-      
-      @yaml_files.each do |file|
-        lang_code = File.basename(file, ".yml")
-        translations[lang_code] = YAML.load_file(file)
-        puts "  - Loaded #{lang_code}.yml"
-      end
-
-      translations
-    end
-
-    # Finds similar translations within each language file.
-    # For each language, flattens the translation structure and compares each pair of strings
-    # to identify similarities based on the Levenshtein distance algorithm.
-    #
-    # @param translations_by_language [Hash] A hash mapping language codes to their translation data
-    # @return [void]
-    def find_similarities(translations_by_language)
-      translations_by_language.each do |lang, translations|
-        puts "\nAnalyzing #{lang} translations..."
-        flattened = flatten_translations(translations)
-        keys = flattened.keys
-        similar_found = 0
-        
-        keys.each_with_index do |key1, i|
-          value1 = flattened[key1]
-          
-          # Confronta solo con le chiavi successive per evitare duplicati
-          keys[(i + 1)..-1].each do |key2|
-            value2 = flattened[key2]
-            
-            similarity = calculate_similarity(value1.to_s, value2.to_s)
-            if similarity >= SIMILARITY_THRESHOLD
-              record_similarity(lang, key1, key2, value1, value2, similarity)
-              similar_found += 1
-            end
-          end
-        end
-        
-        puts "  Found #{similar_found} similar translations"
-      end
-    end
-
-    # Flattens a nested translation hash into a single-level hash with dot-notation keys.
-    # For example, {"en" => {"hello" => "world"}} becomes {"en.hello" => "world"}.
-    #
-    # @param hash [Hash] The nested hash to flatten
-    # @param prefix [String] The current key prefix (used recursively)
-    # @param result [Hash] The accumulator for flattened key-value pairs
-    # @return [Hash] A flattened hash with dot-notation keys
-    def flatten_translations(hash, prefix = "", result = {})
-      hash.each do |key, value|
-        current_key = prefix.empty? ? key.to_s : "#{prefix}.#{key}"
-        
-        if value.is_a?(Hash)
-          flatten_translations(value, current_key, result)
-        else
-          result[current_key] = value
-        end
-      end
-      
-      result
-    end
-
-    # Calculates the similarity between two strings using normalized Levenshtein distance.
-    # Returns a value between 0 (completely different) and 1 (identical).
-    # The normalization accounts for the length of the strings.
-    #
-    # @param str1 [String] The first string to compare
-    # @param str2 [String] The second string to compare
-    # @return [Float] A similarity score between 0 and 1
-    def calculate_similarity(str1, str2)
-      # Implementazione della distanza di Levenshtein normalizzata
-      matrix = Array.new(str1.length + 1) { Array.new(str2.length + 1) }
-      
-      (0..str1.length).each { |i| matrix[i][0] = i }
-      (0..str2.length).each { |j| matrix[0][j] = j }
-      
-      (1..str1.length).each do |i|
-        (1..str2.length).each do |j|
-          cost = str1[i-1] == str2[j-1] ? 0 : 1
-          matrix[i][j] = [
-            matrix[i-1][j] + 1,
-            matrix[i][j-1] + 1,
-            matrix[i-1][j-1] + cost
-          ].min
-        end
-      end
-      
-      max_length = [str1.length, str2.length].max
-      1 - (matrix[str1.length][str2.length].to_f / max_length)
-    end
-
-    # Records a similarity finding in the internal data structure.
-    # Organizes findings by language and stores all relevant information about the similar strings.
-    #
-    # @param lang [String] The language code
-    # @param key1 [String] The first translation key
-    # @param key2 [String] The second translation key
-    # @param value1 [String] The first translation value
-    # @param value2 [String] The second translation value
-    # @param similarity [Float] The calculated similarity score
-    # @return [void]
-    def record_similarity(lang, key1, key2, value1, value2, similarity)
-      @similarities[lang] ||= []
-      @similarities[lang] << {
-        key1: key1,
-        key2: key2,
-        value1: value1,
-        value2: value2,
-        similarity: similarity.round(2)
-      }
-    end
-
-    # Generates both JSON and human-readable reports of the similarity findings.
-    # The JSON report contains detailed information about each similarity found.
-    # The text summary provides a more readable format for quick review.
-    #
-    # @return [void]
-    def generate_report
-      puts "\nGenerating reports..."
-      report = {
-        generated_at: Time.now.iso8601,
-        similarity_threshold: SIMILARITY_THRESHOLD,
-        findings: @similarities
-      }
-
-      File.write(REPORT_FILE, JSON.pretty_generate(report))
-      puts "  - Generated #{REPORT_FILE}"
-      
-      summary = generate_summary(report)
-      File.write("translation_similarities_summary.txt", summary)
-      puts "  - Generated translation_similarities_summary.txt"
-    end
-
-    # Generates a human-readable summary of the similarity findings.
-    # Creates a formatted text report organized by language, showing each pair of similar strings
-    # with their keys, values, and similarity percentage.
-    #
-    # @param report [Hash] The complete similarity report data
-    # @return [String] A formatted text summary
-    def generate_summary(report)
-      summary = ["Translation Similarities Report", "=" * 30, ""]
-      
-      report[:findings].each do |lang, similarities|
-        summary << "Language: #{lang}"
-        summary << "-" * 20
-        
-        similarities.each do |sim|
-          summary << "Similar translations found:"
-          summary << "  Key 1: #{sim[:key1]}"
-          summary << "  Value 1: #{sim[:value1]}"
-          summary << "  Key 2: #{sim[:key2]}"
-          summary << "  Value 2: #{sim[:value2]}"
-          summary << "  Similarity: #{(sim[:similarity] * 100).round(1)}%"
-          summary << ""
-        end
-        
-        summary << ""
-      end
-      
-      summary.join("\n")
-    end
-  end
-end

data/lib/better_translate/utils.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module BetterTranslate
-  # Utility class providing helper methods for logging and metrics tracking.
-  # Used throughout the BetterTranslate gem to standardize logging and performance monitoring.
-  class Utils
-    class << self
-      
-      # Logs a message using the Rails logger if available, otherwise prints to standard output.
-      # Provides a consistent logging interface across different environments.
-      #
-      # @param message [String, nil] The message to log
-      # @return [void]
-      def logger(message: nil)
-        if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
-          Rails.logger.info message
-        else
-          puts message
-        end
-      end
-
-      # Tracks a metric with the given name and value.
-      # Stores metrics in memory with timestamps for performance analysis.
-      # Automatically limits each metric type to the most recent 1000 entries.
-      #
-      # @param name [Symbol, String] The name of the metric to track
-      # @param value [Numeric] The value to record for this metric
-      # @return [void]
-      def track_metric(name, value)
-        @metrics ||= {}
-        @metrics[name] ||= []
-        @metrics[name] << { value: value, timestamp: Time.now }
-
-        # Mantieni solo le ultime 1000 metriche per tipo
-        @metrics[name] = @metrics[name].last(1000) if @metrics[name].size > 1000
-      end
-
-      # Retrieves all tracked metrics.
-      # Returns a hash where keys are metric names and values are arrays of recorded values with timestamps.
-      #
-      # @return [Hash] The collected metrics or an empty hash if no metrics have been tracked
-      def get_metrics
-        @metrics || {}
-      end
-
-      # Clears all tracked metrics.
-      # Useful for resetting metrics between translation jobs or testing.
-      #
-      # @return [Hash] An empty hash representing the cleared metrics
-      def clear_metrics
-        @metrics = {}
-      end
-    end
-  end
-end

data/lib/better_translate/writer.rb

@@ -1,75 +0,0 @@
-module BetterTranslate
-  # Responsible for writing translated content to YAML files.
-  # Supports both incremental and override translation methods.
-  # Incremental mode preserves existing translations and adds new ones,
-  # while override mode completely replaces the target file.
-  class Writer
-    class << self
-      # Writes the translation file for a target language.
-      # If the translation method is :override, the file is rewritten from scratch;
-      # if it's :incremental, the existing file is updated by inserting new translations in the correct positions.
-      #
-      # @param translated_data [Hash] The translated data structure (e.g. { "sample" => { "valid" => "translated", "new_key" => "new translation" } }).
-      # @param target_lang_code [String] Target language code (e.g. "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")
-
-        # Reformats the structure to use the target code as the main key.
-        output_content = if translated_data.is_a?(Hash) && translated_data.key?(BetterTranslate.configuration.source_language)
-                           # Replaces the source language key with the target one.
-                           { 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))
-          message = "File updated in incremental mode: #{output_file}"
-          BetterTranslate::Utils.logger(message: message)
-        else
-          FileUtils.mkdir_p(output_folder) unless Dir.exist?(output_folder)
-          File.write(output_file, output_content.to_yaml(line_width: -1))
-          message = "File rewritten in override mode: #{output_file}"
-          BetterTranslate::Utils.logger(message: message)
-        end
-      end
-
-      private
-
-      # Recursively merges two hashes while preserving existing values.
-      # If a key exists in both hashes and the values are hashes, they are merged recursively.
-      # If a key exists in both hashes but the values are not hashes, the existing value is preserved.
-      # If a key only exists in the new hash, it is added to the merged result.
-      #
-      # @param existing [Hash] The existing hash (current file content)
-      # @param new_data [Hash] The new hash with translations to merge
-      # @return [Hash] The merged hash with preserved existing values
-      # @example
-      #   existing = { "en" => { "hello" => "Hello", "nested" => { "key" => "Value" } } }
-      #   new_data = { "en" => { "hello" => "New Hello", "nested" => { "key2" => "Value2" } } }
-      #   deep_merge(existing, new_data)
-      #   # => { "en" => { "hello" => "Hello", "nested" => { "key" => "Value", "key2" => "Value2" } } }
-      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
-              # If the key already exists, don't overwrite the value (incremental mode)
-              # or you might decide to update anyway, depending on the requirements.
-              merged[key] = merged[key]
-            end
-          else
-            merged[key] = value
-          end
-        end
-        merged
-      end
-
-    end
-  end
-end

data/lib/generators/better_translate/analyze_generator.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-require "rails/generators"
-
-module BetterTranslate
-  module Generators
-    # Rails generator for analyzing translation files to find similar content.
-    # Uses the SimilarityAnalyzer to identify potentially redundant translations
-    # across locale files and generates both JSON and human-readable reports.
-    #
-    # @example
-    #   rails generate better_translate:analyze
-    class AnalyzeGenerator < Rails::Generators::Base
-      desc "Analyze translation files for similarities"
-
-      # Main generator method that analyzes translation files for similarities.
-      # Finds all YAML files in the config/locales directory, runs the analysis,
-      # and displays a summary of the results.
-      #
-      # The analysis uses the Levenshtein distance algorithm to identify strings
-      # that are similar but not identical, which could indicate redundant translations.
-      #
-      # @return [void]
-      def analyze_translations
-        say "Starting translation similarity analysis...", :blue
-
-        # Find all YAML files in the locales directory
-        locale_dir = Rails.root.join("config", "locales")
-        yaml_files = Dir[locale_dir.join("*.yml")]
-
-        if yaml_files.empty?
-          say "No YAML files found in #{locale_dir}", :red
-          return
-        end
-
-        say "Found #{yaml_files.length} YAML files to analyze", :green
-
-        # Run analysis
-        analyzer = BetterTranslate::SimilarityAnalyzer.new(yaml_files)
-        analyzer.analyze
-
-        # Show results
-        say "\nAnalysis complete!", :green
-        say "Reports generated:", :green
-        say "  * #{BetterTranslate::SimilarityAnalyzer::REPORT_FILE} (detailed JSON report)"
-        say "  * translation_similarities_summary.txt (human-readable summary)"
-        
-        # Show quick summary from the text file
-        if File.exist?("translation_similarities_summary.txt")
-          summary = File.read("translation_similarities_summary.txt")
-          say "\nQuick Summary:", :blue
-          say summary
-        end
-      end
-    end
-  end
-end

data/lib/generators/better_translate/install_generator.rb

@@ -1,14 +0,0 @@
-require 'rails/generators'
-
-module BetterTranslate
-  module Generators
-    class InstallGenerator < Rails::Generators::Base
-      source_root File.expand_path('templates', __dir__)
-      desc "Generates the config/initializers/better_translate.rb file with default configuration"
-
-      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

@@ -1,56 +0,0 @@
-BetterTranslate.configure do |config|
-  # Choose the provider to use: :chatgpt, :gemini, or any custom provider registered with BetterTranslate::Service.register_provider
-  config.provider = :chatgpt
-
-  # API key for 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" }
-  
-  # Custom provider API keys
-  # If you've created a custom provider using 'rails generate better_translate:provider YourProvider',
-  # add its API key here following the naming convention: config.your_provider_key
-  # 
-  # Example for a custom DeepL provider:
-  # config.deepl_key = ENV.fetch("DEEPL_API_KEY") { "YOUR_DEEPL_API_KEY" }
-
-  # Source language (for example "en" if the source file is in English)
-  config.source_language = "en"
-
-  # List of target languages (short_name and 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" }
-  ]
-
-  # Global exclusions (paths in dot notation) to exclude for all languages
-  config.global_exclusions = [
-    "key.value"
-  ]
-
-  # Language-specific exclusions
-  config.exclusions_per_language = {
-    "es" => [],
-    "it" => [],
-    "fr" => [],
-    "de" => [],
-    "pt" => [],
-    "ru" => []
-  }
-
-  # Input file path (e.g. en.yml)
-  config.input_file = Rails.root.join("config", "locales", "en.yml").to_s
-
-  # Output folder where translated files will be saved
-  config.output_folder = Rails.root.join("config", "locales", "translated").to_s
-
-  # Translation method:
-  # - :override => regenerates all translations
-  # - :incremental => updates only missing keys (or those that have been modified)
-  config.translation_method = :override
-end

data/lib/generators/better_translate/translate_generator.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails/generators'
-
-module BetterTranslate
-  module Generators
-    # Rails generator for executing translations with BetterTranslate.
-    # This generator validates the configuration and starts the translation process.
-    #
-    # @example
-    #   rails generate better_translate:translate
-    class TranslateGenerator < Rails::Generators::Base
-      desc "Starts the translation process configured in BetterTranslate"
-
-      # Main generator method that initiates the translation process.
-      # Validates the configuration before starting and provides status messages.
-      #
-      # @return [void]
-      def translate
-        say "Starting translation with BetterTranslate...", :blue
-        
-        # Verifica che la configurazione sia valida
-        if validate_configuration
-          say "Configuration validated. Starting translation...", :green
-          BetterTranslate.magic
-          say "Translation completed.", :green
-        else
-          say "Translation aborted due to configuration issues.", :red
-        end
-      end
-      
-      private
-      
-      # Validates the BetterTranslate configuration.
-      # Checks for required settings and reports any issues found.
-      #
-      # @return [Boolean] true if the configuration is valid, false otherwise
-      def validate_configuration
-        valid = true
-        
-        # Verifica che il file di input esista
-        unless BetterTranslate.configuration.respond_to?(:input_file)
-          say "Error: input_file not configured. Please check your initializer.", :red
-          return false
-        end
-        
-        input_file = BetterTranslate.configuration.input_file
-        unless File.exist?(input_file)
-          say "Error: Input file not found: #{input_file}", :red
-          valid = false
-        end
-        
-        # Verifica che ci siano lingue target attive
-        if !BetterTranslate.configuration.respond_to?(:target_languages) || 
-           BetterTranslate.configuration.target_languages.empty?
-          say "Error: No target languages configured. Please uncomment or add target languages in your initializer.", :red
-          valid = false
-        end
-        
-        # Verifica che il provider sia configurato
-        if !BetterTranslate.configuration.respond_to?(:provider)
-          say "Error: No provider configured. Please set config.provider in your initializer.", :red
-          valid = false
-        end
-        
-        # Verifica che la chiave API sia configurata per il provider selezionato
-        if BetterTranslate.configuration.respond_to?(:provider)
-          provider = BetterTranslate.configuration.provider
-          if provider == :chatgpt && (!BetterTranslate.configuration.respond_to?(:openai_key) || 
-             BetterTranslate.configuration.openai_key == "YOUR_OPENAI_API_KEY")
-            say "Error: OpenAI API key not configured. Please set config.openai_key in your initializer.", :red
-            valid = false
-          elsif provider == :gemini && (!BetterTranslate.configuration.respond_to?(:google_gemini_key) || 
-                BetterTranslate.configuration.google_gemini_key == "YOUR_GOOGLE_GEMINI_KEY")
-            say "Error: Gemini API key not configured. Please set config.google_gemini_key in your initializer.", :red
-            valid = false
-          end
-        end
-        
-        valid
-      end
-    end
-  end
-end