better_translate 1.0.0.1 → 1.1.1

data/lib/better_translate/translator.rb

@@ -34,12 +34,19 @@ module BetterTranslate
       @config.validate!
       provider_name = config.provider || :chatgpt
       @provider = ProviderFactory.create(provider_name, config)
-      @yaml_handler = YAMLHandler.new(config)
+
+      # Resolve input files (supports input_file, input_files array, or glob pattern)
+      @input_files = resolve_input_files
+
+      # We'll determine handler per file during translation
       @progress_tracker = ProgressTracker.new(enabled: config.verbose)
     end
 
     # Translate to all target languages
     #
+    # Uses parallel execution when max_concurrent_requests > 1,
+    # sequential execution otherwise. Supports multiple input files.
+    #
     # @return [Hash] Results hash with :success_count, :failure_count, :errors
     #
     # @example
@@ -47,8 +54,128 @@ module BetterTranslate
     #   #=> { success_count: 2, failure_count: 0, errors: [] }
     #
     def translate_all
-      source_strings = @yaml_handler.get_source_strings
+      # @type var combined_results: translation_results
+      combined_results = {
+        success_count: 0,
+        failure_count: 0,
+        errors: []
+      }
+
+      @input_files.each do |input_file|
+        # Create appropriate handler for this file
+        handler = if input_file.end_with?(".json")
+                    JsonHandler.new(config)
+                  else
+                    YAMLHandler.new(config)
+                  end
+
+        # Temporarily set input_file for this iteration
+        original_input_file = config.input_file
+        config.input_file = input_file
+
+        source_strings = handler.get_source_strings
+
+        results = if config.max_concurrent_requests > 1
+                    translate_parallel(source_strings, handler)
+                  else
+                    translate_sequential(source_strings, handler)
+                  end
+
+        # Restore original config
+        config.input_file = original_input_file
+
+        # Accumulate results
+        combined_results[:success_count] += results[:success_count]
+        combined_results[:failure_count] += results[:failure_count]
+        combined_results[:errors].concat(results[:errors])
+      end
+
+      combined_results
+    end
+
+    private
+
+    # Resolve input files from config
+    #
+    # Handles input_file, input_files array, or glob patterns
+    #
+    # @return [Array<String>] Resolved file paths
+    # @raise [FileError] if no files found
+    # @api private
+    #
+    def resolve_input_files
+      files = if config.input_files
+                # Handle input_files (array or glob pattern)
+                if config.input_files.is_a?(Array)
+                  config.input_files
+                else
+                  # Glob pattern
+                  Dir.glob(config.input_files)
+                end
+              elsif config.input_file
+                # Backward compatibility with single input_file
+                [config.input_file]
+              else
+                [] # : Array[String]
+              end
+
+      # Validate files exist (unless glob pattern that found nothing)
+      if files.empty?
+        if config.input_files && !config.input_files.is_a?(Array)
+          raise FileError, "No files found matching pattern: #{config.input_files}"
+        end
+
+        raise FileError, "No input files specified"
+
+      end
+
+      files.each do |file|
+        Validator.validate_file_exists!(file)
+      end
+
+      files
+    end
+
+    # Translate languages in parallel
+    #
+    # @param source_strings [Hash] Source strings (flattened)
+    # @param handler [YAMLHandler, JsonHandler] File handler for this file
+    # @return [Hash] Results hash with counts and errors
+    # @api private
+    #
+    def translate_parallel(source_strings, handler)
+      # @type var results: translation_results
+      results = {
+        success_count: 0,
+        failure_count: 0,
+        errors: []
+      }
+      mutex = Mutex.new
+
+      # Process languages in batches of max_concurrent_requests
+      config.target_languages.each_slice(config.max_concurrent_requests) do |batch|
+        threads = batch.map do |lang|
+          Thread.new do
+            translate_language(source_strings, lang, handler)
+            mutex.synchronize { results[:success_count] += 1 }
+          rescue StandardError => e
+            mutex.synchronize { record_error(results, lang, e) }
+          end
+        end
+        threads.each(&:join)
+      end
+
+      results
+    end
 
+    # Translate languages sequentially
+    #
+    # @param source_strings [Hash] Source strings (flattened)
+    # @param handler [YAMLHandler, JsonHandler] File handler for this file
+    # @return [Hash] Results hash with counts and errors
+    # @api private
+    #
+    def translate_sequential(source_strings, handler)
       # @type var results: translation_results
       results = {
         success_count: 0,
@@ -57,42 +184,53 @@ module BetterTranslate
       }
 
       config.target_languages.each do |lang|
-        translate_language(source_strings, lang)
+        translate_language(source_strings, lang, handler)
         results[:success_count] += 1
       rescue StandardError => e
-        results[:failure_count] += 1
-        # @type var error_context: Hash[Symbol, untyped]
-        error_context = if e.is_a?(BetterTranslate::Error)
-                          e.context
-                        else
-                          {}
-                        end
-        results[:errors] << {
-          language: lang[:name],
-          error: e.message,
-          context: error_context
-        }
-        @progress_tracker.error(lang[:name], e)
+        record_error(results, lang, e)
       end
 
       results
     end
 
-    private
+    # Record translation error in results
+    #
+    # @param results [Hash] Results hash to update
+    # @param lang [Hash] Language config
+    # @param error [StandardError] The error that occurred
+    # @return [void]
+    # @api private
+    #
+    def record_error(results, lang, error)
+      results[:failure_count] += 1
+      # @type var error_context: Hash[Symbol, untyped]
+      error_context = if error.is_a?(BetterTranslate::Error)
+                        error.context
+                      else
+                        {}
+                      end
+      results[:errors] << {
+        language: lang[:name],
+        error: error.message,
+        context: error_context
+      }
+      @progress_tracker.error(lang[:name], error)
+    end
 
     # Translate to a single language
     #
     # @param source_strings [Hash] Source strings (flattened)
     # @param lang [Hash] Language config with :short_name and :name
+    # @param handler [YAMLHandler, JsonHandler] File handler for this file
     # @return [void]
     # @api private
     #
-    def translate_language(source_strings, lang)
+    def translate_language(source_strings, lang, handler)
       target_lang_code = lang[:short_name]
       target_lang_name = lang[:name]
 
       # Filter exclusions
-      strings_to_translate = @yaml_handler.filter_exclusions(source_strings, target_lang_code)
+      strings_to_translate = handler.filter_exclusions(source_strings, target_lang_code)
 
       return if strings_to_translate.empty?
 
@@ -108,20 +246,64 @@ module BetterTranslate
       @progress_tracker.reset
       translated = strategy.translate(strings_to_translate, target_lang_code, target_lang_name)
 
-      # Save
-      output_path = @yaml_handler.build_output_path(target_lang_code)
+      # Save - generate output path with proper filename
+      current_input_file = config.input_file or raise "No input file set"
+      output_path = build_output_path_for_file(current_input_file, target_lang_code)
 
       final_translations = if config.translation_mode == :incremental
-                             @yaml_handler.merge_translations(output_path, translated)
+                             handler.merge_translations(output_path, translated)
                            else
                              Utils::HashFlattener.unflatten(translated)
                            end
 
       # Wrap in language key (e.g., "it:")
       wrapped = { target_lang_code => final_translations }
-      @yaml_handler.write_yaml(output_path, wrapped)
+
+      # Write using appropriate handler method (write_yaml or write_json)
+      if handler.is_a?(JsonHandler)
+        handler.write_json(output_path, wrapped)
+      else
+        handler.write_yaml(output_path, wrapped)
+      end
 
       @progress_tracker.complete(target_lang_name, translated.size)
     end
+
+    # Build output path for a specific file and language
+    #
+    # Replaces source language code with target language code in filename
+    # and preserves directory structure
+    #
+    # @param input_file [String] Input file path
+    # @param target_lang_code [String] Target language code
+    # @return [String] Output file path
+    # @api private
+    #
+    # @example
+    #   build_output_path_for_file("config/locales/common.en.yml", "it")
+    #   #=> "config/locales/common.it.yml"
+    #
+    def build_output_path_for_file(input_file, target_lang_code)
+      # Get file basename and directory
+      dir = File.dirname(input_file)
+      basename = File.basename(input_file)
+      ext = File.extname(basename)
+      name_without_ext = File.basename(basename, ext)
+
+      # Replace source language code with target language code
+      # Handles patterns like: common.en.yml -> common.it.yml
+      new_basename = name_without_ext.gsub(/\.#{config.source_language}$/, ".#{target_lang_code}") + ext
+
+      # If no language code in filename, use simple pattern
+      new_basename = "#{target_lang_code}#{ext}" if new_basename == basename
+
+      # Build output path
+      if config.output_folder
+        # Use output_folder but preserve relative directory structure if input was nested
+        File.join(config.output_folder, new_basename)
+      else
+        File.join(dir, new_basename)
+      end
+    end
   end
 end

data/lib/better_translate/version.rb

@@ -2,5 +2,5 @@
 
 module BetterTranslate
   # Current version of BetterTranslate gem
-  VERSION = "1.0.0.1"
+  VERSION = "1.1.1"
 end

data/lib/better_translate/yaml_handler.rb

@@ -81,6 +81,9 @@ module BetterTranslate
 
       return summary if config.dry_run
 
+      # Create backup if enabled and file exists
+      create_backup_file(file_path) if config.create_backup && File.exist?(file_path)
+
       # Ensure output directory exists
       FileUtils.mkdir_p(File.dirname(file_path))
 
@@ -164,5 +167,61 @@ module BetterTranslate
 
       File.join(config.output_folder, "#{target_lang_code}.yml")
     end
+
+    private
+
+    # Create backup file with rotation support
+    #
+    # @param file_path [String] Path to file to backup
+    # @return [void]
+    # @api private
+    #
+    def create_backup_file(file_path)
+      return unless File.exist?(file_path)
+
+      # Rotate existing backups if max_backups > 1
+      rotate_backups(file_path) if config.max_backups > 1
+
+      # Create primary backup
+      backup_path = "#{file_path}.bak"
+      FileUtils.cp(file_path, backup_path)
+    end
+
+    # Rotate backup files, keeping only max_backups
+    #
+    # Rotation strategy:
+    # - .bak is always the most recent
+    # - .bak.1, .bak.2, etc. are progressively older
+    # - When we reach max_backups, oldest is deleted
+    #
+    # @param file_path [String] Base file path
+    # @return [void]
+    # @api private
+    #
+    def rotate_backups(file_path)
+      primary_backup = "#{file_path}.bak"
+      return unless File.exist?(primary_backup)
+
+      # Clean up ANY backups that would exceed max_backups after rotation
+      # max_backups includes .bak itself, so numbered backups go from 1 to max_backups-1
+      # After rotation, .bak -> .bak.1, so we can have at most .bak.1 through .bak.(max_backups-1)
+      10.downto(config.max_backups) do |i|
+        numbered_backup = "#{file_path}.bak.#{i}"
+        FileUtils.rm_f(numbered_backup) if File.exist?(numbered_backup)
+      end
+
+      # Rotate numbered backups from high to low to avoid overwrites
+      # max_backups=2: nothing to rotate (only .bak -> .bak.1)
+      # max_backups=3: .bak.1 -> .bak.2 (if exists)
+      (config.max_backups - 2).downto(1) do |i|
+        old_path = "#{file_path}.bak.#{i}"
+        new_path = "#{file_path}.bak.#{i + 1}"
+
+        FileUtils.mv(old_path, new_path) if File.exist?(old_path)
+      end
+
+      # Move primary backup to .bak.1
+      FileUtils.mv(primary_backup, "#{file_path}.bak.1")
+    end
   end
 end

data/lib/better_translate.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "csv"
+
 require_relative "better_translate/version"
 require_relative "better_translate/errors"
 require_relative "better_translate/configuration"
@@ -14,6 +16,7 @@ require_relative "better_translate/providers/gemini_provider"
 require_relative "better_translate/providers/anthropic_provider"
 require_relative "better_translate/provider_factory"
 require_relative "better_translate/yaml_handler"
+require_relative "better_translate/json_handler"
 require_relative "better_translate/progress_tracker"
 require_relative "better_translate/strategies/base_strategy"
 require_relative "better_translate/strategies/deep_strategy"
@@ -21,6 +24,10 @@ require_relative "better_translate/strategies/batch_strategy"
 require_relative "better_translate/strategies/strategy_selector"
 require_relative "better_translate/translator"
 require_relative "better_translate/direct_translator"
+require_relative "better_translate/analyzer/key_scanner"
+require_relative "better_translate/analyzer/code_scanner"
+require_relative "better_translate/analyzer/orphan_detector"
+require_relative "better_translate/analyzer/reporter"
 require_relative "better_translate/cli"
 
 # Load Rails integration if Rails is present

data/lib/generators/better_translate/install/install_generator.rb

@@ -47,8 +47,8 @@ module BetterTranslate
           "dry_run" => false,
           "translation_mode" => "override",
           "preserve_variables" => true,
-          "global_exclusions" => [],
-          "exclusions_per_language" => {},
+          "global_exclusions" => [], # : Array[String]
+          "exclusions_per_language" => {}, # : Hash[String, Array[String]]
           "model" => nil,
           "temperature" => 0.3,
           "max_tokens" => 2000,

data/lib/generators/better_translate/install/templates/initializer.rb.tt

@@ -2,6 +2,10 @@
 
 # BetterTranslate Configuration
 #
+# IMPORTANT: I18n configuration is not yet available when initializers load.
+# You must manually set source_language and target_languages to match your
+# Rails I18n configuration in config/application.rb
+#
 # For more configuration options, see config/better_translate.yml
 
 BetterTranslate.configure do |config|
@@ -14,43 +18,27 @@ BetterTranslate.configure do |config|
   config.anthropic_key = ENV["ANTHROPIC_API_KEY"]
 
   # Source and target languages
-  # Automatically uses Rails I18n configuration
-  # To configure I18n in your Rails app, set in config/application.rb:
+  #
+  # IMPORTANT: These must be set manually to match your Rails I18n config
+  # (I18n.default_locale and I18n.available_locales are not yet available)
+  #
+  # Example: If your config/application.rb has:
   #   config.i18n.default_locale = :it
-  #   config.i18n.available_locales = [:it, :en, :es, :fr]
-  config.source_language = I18n.default_locale.to_s
-
-  # Target languages: automatically derived from I18n.available_locales
-  # Excludes the source language from targets
-  available_targets = (I18n.available_locales - [I18n.default_locale]).map(&:to_s)
+  #   config.i18n.available_locales = [:it, :en, :fr, :ja, :ru]
+  #
+  # Then set:
+  #   config.source_language = "it"  # matches default_locale
+  #   config.target_languages = [...]  # matches available_locales (excluding source)
 
-  # Language name mapping for common languages
-  language_names = {
-    "en" => "English", "it" => "Italian", "es" => "Spanish", "fr" => "French",
-    "de" => "German", "pt" => "Portuguese", "ru" => "Russian", "zh" => "Chinese",
-    "ja" => "Japanese", "ko" => "Korean", "ar" => "Arabic", "nl" => "Dutch",
-    "pl" => "Polish", "tr" => "Turkish", "sv" => "Swedish", "da" => "Danish",
-    "fi" => "Finnish", "no" => "Norwegian", "cs" => "Czech", "el" => "Greek",
-    "he" => "Hebrew", "hi" => "Hindi", "th" => "Thai", "vi" => "Vietnamese"
-  }
+  config.source_language = "en" # TODO: Change to match your default_locale
 
-  if available_targets.any?
-    # Use I18n available locales
-    config.target_languages = available_targets.map do |locale|
-      {
-        short_name: locale,
-        name: language_names[locale] || locale.capitalize
-      }
-    end
-  else
-    # Fallback: suggest common languages
-    # Uncomment and modify the languages you want to translate to
-    config.target_languages = [
-      { short_name: "it", name: "Italian" },
-      { short_name: "es", name: "Spanish" },
-      { short_name: "fr", name: "French" }
-    ]
-  end
+  # Target languages (excluding source language)
+  # TODO: Change to match your available_locales
+  config.target_languages = [
+    { short_name: "it", name: "Italian" },
+    { short_name: "es", name: "Spanish" },
+    { short_name: "fr", name: "French" }
+  ]
 
   # File paths
   # Uses source_language for input file

data/lib/generators/better_translate/translate/translate_generator.rb

@@ -29,57 +29,75 @@ module BetterTranslate
       #
       # @return [void]
       #
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
       def run_translation
-        config_file = Rails.root.join("config", "better_translate.yml")
-
-        unless File.exist?(config_file)
-          say "Config file not found at #{config_file}", :red
-          say "Run 'rails generate better_translate:install' first"
-          return
-        end
+        # Check if configuration is already loaded (from initializer)
+        if BetterTranslate.configuration.provider.nil?
+          # No initializer configuration found, try loading from YAML
+          config_file = Rails.root.join("config", "better_translate.yml")
+
+          unless File.exist?(config_file)
+            say "No configuration found", :red
+            say "Either:"
+            say "  1. Create config/initializers/better_translate.rb (recommended)"
+            say "  2. Run 'rails generate better_translate:install' to create YAML config"
+            return
+          end
 
-        # Load configuration from YAML
-        yaml_config = YAML.load_file(config_file)
-
-        # Configure BetterTranslate
-        BetterTranslate.configure do |config|
-          config.provider = yaml_config["provider"]&.to_sym
-          config.openai_key = yaml_config["openai_key"] || ENV["OPENAI_API_KEY"]
-          config.gemini_key = yaml_config["gemini_key"] || ENV["GEMINI_API_KEY"]
-          config.anthropic_key = yaml_config["anthropic_key"] || ENV["ANTHROPIC_API_KEY"]
-
-          config.source_language = yaml_config["source_language"]
-          config.target_languages = yaml_config["target_languages"]&.map do |lang|
-            if lang.is_a?(Hash)
-              { short_name: lang["short_name"], name: lang["name"] }
-            else
-              lang
+          # Load configuration from YAML
+          yaml_config = YAML.load_file(config_file)
+
+          # Configure BetterTranslate
+          BetterTranslate.configure do |config|
+            config.provider = yaml_config["provider"]&.to_sym
+            config.openai_key = yaml_config["openai_key"] || ENV["OPENAI_API_KEY"]
+            config.gemini_key = yaml_config["gemini_key"] || ENV["GEMINI_API_KEY"]
+            config.anthropic_key = yaml_config["anthropic_key"] || ENV["ANTHROPIC_API_KEY"]
+
+            config.source_language = yaml_config["source_language"]
+            config.target_languages = yaml_config["target_languages"]&.map do |lang|
+              if lang.is_a?(Hash)
+                { short_name: lang["short_name"], name: lang["name"] }
+              else
+                lang
+              end
             end
+
+            config.input_file = Rails.root.join(yaml_config["input_file"]).to_s
+            config.output_folder = Rails.root.join(yaml_config["output_folder"]).to_s
+            config.verbose = yaml_config.fetch("verbose", true)
+            config.dry_run = options[:dry_run] || yaml_config.fetch("dry_run", false)
+
+            # Map "full" to :override for backward compatibility
+            translation_mode = yaml_config.fetch("translation_mode", "override")
+            translation_mode = "override" if translation_mode == "full"
+            config.translation_mode = translation_mode.to_sym
+
+            config.preserve_variables = yaml_config.fetch("preserve_variables", true)
+
+            # Exclusions
+            config.global_exclusions = yaml_config["global_exclusions"] || []
+            config.exclusions_per_language = yaml_config["exclusions_per_language"] || {}
+
+            # Provider options
+            config.model = yaml_config["model"] if yaml_config["model"]
+            config.temperature = yaml_config["temperature"] if yaml_config["temperature"]
+            config.max_tokens = yaml_config["max_tokens"] if yaml_config["max_tokens"]
+            config.timeout = yaml_config["timeout"] if yaml_config["timeout"]
+            config.max_retries = yaml_config["max_retries"] if yaml_config["max_retries"]
+            config.rate_limit = yaml_config["rate_limit"] if yaml_config["rate_limit"]
           end
+        elsif options[:dry_run]
+          # Configuration from initializer exists, but apply dry_run option if provided
+          BetterTranslate.configuration.dry_run = true
+        end
 
-          config.input_file = Rails.root.join(yaml_config["input_file"]).to_s
-          config.output_folder = Rails.root.join(yaml_config["output_folder"]).to_s
-          config.verbose = yaml_config.fetch("verbose", true)
-          config.dry_run = options[:dry_run] || yaml_config.fetch("dry_run", false)
-
-          # Map "full" to :override for backward compatibility
-          translation_mode = yaml_config.fetch("translation_mode", "override")
-          translation_mode = "override" if translation_mode == "full"
-          config.translation_mode = translation_mode.to_sym
-
-          config.preserve_variables = yaml_config.fetch("preserve_variables", true)
-
-          # Exclusions
-          config.global_exclusions = yaml_config["global_exclusions"] || []
-          config.exclusions_per_language = yaml_config["exclusions_per_language"] || {}
-
-          # Provider options
-          config.model = yaml_config["model"] if yaml_config["model"]
-          config.temperature = yaml_config["temperature"] if yaml_config["temperature"]
-          config.max_tokens = yaml_config["max_tokens"] if yaml_config["max_tokens"]
-          config.timeout = yaml_config["timeout"] if yaml_config["timeout"]
-          config.max_retries = yaml_config["max_retries"] if yaml_config["max_retries"]
-          config.rate_limit = yaml_config["rate_limit"] if yaml_config["rate_limit"]
+        # Validate configuration (whether from initializer or YAML)
+        begin
+          BetterTranslate.configuration.validate!
+        rescue BetterTranslate::ConfigurationError => e
+          say "Invalid configuration: #{e.message}", :red
+          return
         end
 
         # Perform translation
@@ -110,6 +128,7 @@ module BetterTranslate
           say "  - #{error[:language]}: #{error[:error]}", :red
         end
       end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
     end
   end
 end