better_translate 1.1.0 → 1.1.1

data/brakeman.yml

@@ -0,0 +1,37 @@
+# Brakeman configuration file
+# https://brakemanscanner.org/docs/options/
+
+# Set application path (defaults to current directory)
+:app_path: "."
+
+# Set Rails version (detected automatically)
+# :rails_version: "8.1.0"
+
+# Enable additional security checks
+:force_scan: true
+
+# Show all files processed
+:report_progress: true
+
+# Skip certain checks (none skipped by default)
+:skip_checks: []
+
+# Only run specific checks (empty means run all)
+:run_checks: []
+
+# Set confidence levels to report (1=High, 2=Medium, 3=Weak)
+:min_confidence: 2
+
+# Ignore specific warnings
+:ignore_file: ".brakeman.ignore"
+
+# Additional paths to scan
+:additional_checks_path: []
+
+# Paths to exclude from scanning
+:skip_files:
+  - "spec/"
+  - "test/"
+
+# Exit with error code if warnings found
+:exit_on_warn: true

data/codecov.yml

@@ -0,0 +1,34 @@
+# Codecov configuration
+# Documentation: https://docs.codecov.com/docs/codecov-yaml
+
+codecov:
+  require_ci_to_pass: yes
+
+coverage:
+  precision: 2
+  round: down
+  range: "70...100"
+
+  status:
+    project:
+      default:
+        target: 90%
+        threshold: 1%
+        if_ci_failed: error
+
+    patch:
+      default:
+        target: 90%
+        threshold: 1%
+
+comment:
+  layout: "reach,diff,flags,tree,footer"
+  behavior: default
+  require_changes: false
+  require_base: false
+  require_head: true
+
+ignore:
+  - "spec/**/*"
+  - "vendor/**/*"
+  - "gemfiles/**/*"

data/lib/better_translate/analyzer/code_scanner.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "set"
-
 module BetterTranslate
   module Analyzer
     # Scans code files to find i18n key references

data/lib/better_translate/analyzer/orphan_detector.rb

@@ -64,9 +64,12 @@ module BetterTranslate
       #   #=> { "orphan_key" => "This is never used" }
       #
       def orphan_details
-        @orphans.each_with_object({}) do |key, details|
-          details[key] = all_keys[key]
+        # @type var result: Hash[String, untyped]
+        result = {}
+        @orphans.each do |key|
+          result[key] = all_keys[key]
         end
+        result
       end
 
       # Calculate usage percentage
@@ -81,7 +84,7 @@ module BetterTranslate
         return 0.0 if all_keys.empty?
 
         used_count = all_keys.size - @orphans.size
-        (used_count.to_f / all_keys.size * 100).round(1)
+        (used_count.to_f / all_keys.size * 100).round(1).to_f
       end
     end
   end

data/lib/better_translate/analyzer/reporter.rb

@@ -87,7 +87,7 @@ module BetterTranslate
       # @return [String] Text report
       #
       def generate_text
-        lines = []
+        lines = [] # : Array[String]
         lines << "=" * 60
         lines << "Orphan Keys Analysis Report"
         lines << "=" * 60

data/lib/better_translate/cli.rb

@@ -225,8 +225,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/better_translate/configuration.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "fileutils"
+require "json"
+
 module BetterTranslate
   # Configuration class for BetterTranslate
   #
@@ -216,7 +219,12 @@ module BetterTranslate
 
       # Only validate input_file exists if using single file mode (not glob pattern or array)
       return unless input_file && !input_file.empty? && !input_files
-      raise ConfigurationError, "Input file does not exist: #{input_file}" unless File.exist?(input_file)
+
+      # Create input file if it doesn't exist
+      return if File.exist?(input_file)
+
+      create_default_input_file!(input_file)
+      puts "Created empty input file: #{input_file}" if verbose
     end
 
     # Validate optional settings (timeouts, retries, cache, etc.)
@@ -243,5 +251,24 @@ module BetterTranslate
       # Validate max_tokens is positive
       raise ConfigurationError, "Max tokens must be positive" if max_tokens && max_tokens <= 0
     end
+
+    # Create a default input file with root language key
+    #
+    # @param file_path [String] Path to the input file
+    # @return [void]
+    # @api private
+    def create_default_input_file!(file_path)
+      # Create directory if needed
+      FileUtils.mkdir_p(File.dirname(file_path))
+
+      # Determine file format (YAML or JSON)
+      content = if file_path.end_with?(".json")
+                  JSON.pretty_generate({ source_language => {} })
+                else
+                  { source_language => {} }.to_yaml
+                end
+
+      File.write(file_path, content)
+    end
   end
 end

data/lib/better_translate/json_handler.rb

@@ -76,7 +76,7 @@ module BetterTranslate
 
       # Show diff preview if in dry run mode
       if config.dry_run && diff_preview
-        existing_data = File.exist?(file_path) ? read_json(file_path) : {}
+        existing_data = File.exist?(file_path) ? read_json(file_path) : {} # : Hash[untyped, untyped]
         summary = diff_preview.show_diff(existing_data, data, file_path)
       end
 
@@ -151,7 +151,7 @@ module BetterTranslate
         target_lang = config.target_languages.first[:short_name]
         existing = existing[target_lang] || existing
       else
-        existing = {}
+        existing = {} # : Hash[untyped, untyped]
       end
 
       existing_flat = Utils::HashFlattener.flatten(existing)

data/lib/better_translate/translator.rb

@@ -116,7 +116,7 @@ module BetterTranslate
                 # Backward compatibility with single input_file
                 [config.input_file]
               else
-                []
+                [] # : Array[String]
               end
 
       # Validate files exist (unless glob pattern that found nothing)
@@ -247,7 +247,8 @@ module BetterTranslate
       translated = strategy.translate(strings_to_translate, target_lang_code, target_lang_name)
 
       # Save - generate output path with proper filename
-      output_path = build_output_path_for_file(config.input_file, target_lang_code)
+      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
                              handler.merge_translations(output_path, translated)

data/lib/better_translate/version.rb

@@ -2,5 +2,5 @@
 
 module BetterTranslate
   # Current version of BetterTranslate gem
-  VERSION = "1.1.0"
+  VERSION = "1.1.1"
 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"

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

data/lib/tasks/better_translate.rake

@@ -9,59 +9,75 @@ unless Rake::Task.task_defined?(:environment)
   end
 end
 
+# rubocop:disable Metrics/BlockLength
 namespace :better_translate do
   desc "Translate YAML locale files using AI providers"
   task translate: :environment do
-    config_file = Rails.root.join("config", "better_translate.yml")
+    # 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)
-      puts "Error: Configuration file not found at #{config_file}"
-      puts "Run 'rake better_translate:config:generate' to create one."
-      exit 1
-    end
+      unless File.exist?(config_file)
+        puts "Error: No configuration found"
+        puts "Either:"
+        puts "  1. Create config/initializers/better_translate.rb (recommended)"
+        puts "  2. Run 'rake better_translate:config:generate' to create YAML config"
+        exit 1
+      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 = yaml_config["input_file"]
+        config.output_folder = yaml_config["output_folder"]
+        config.verbose = yaml_config.fetch("verbose", true)
+        config.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
+    end
 
-      config.input_file = yaml_config["input_file"]
-      config.output_folder = yaml_config["output_folder"]
-      config.verbose = yaml_config.fetch("verbose", true)
-      config.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
+      puts "Error: Invalid configuration"
+      puts e.message
+      exit 1
     end
 
     # Perform translation
@@ -134,3 +150,4 @@ namespace :better_translate do
     end
   end
 end
+# rubocop:enable Metrics/BlockLength

data/sig/better_translate/analyzer/code_scanner.rbs

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module BetterTranslate
+  module Analyzer
+    # Scans code files to find i18n key references
+    class CodeScanner
+      # I18n patterns to match
+      I18N_PATTERNS: Array[Regexp]
+
+      # File extensions to scan
+      SCANNABLE_EXTENSIONS: Array[String]
+
+      # Path to scan (file or directory)
+      attr_reader path: String
+
+      # Found i18n keys
+      attr_reader keys: Set[String]
+
+      # List of scanned files
+      attr_reader files_scanned: Array[String]
+
+      # Initialize scanner with path
+      #
+      # @param path File or directory path to scan
+      def initialize: (String path) -> void
+
+      # Scan path and extract i18n keys
+      #
+      # @return Set of found i18n keys
+      def scan: () -> Set[String]
+
+      # Get count of unique keys found
+      #
+      # @return Number of unique keys
+      def key_count: () -> Integer
+
+      private
+
+      # Validate that path exists
+      def validate_path!: () -> void
+
+      # Collect all scannable files from path
+      #
+      # @return List of file paths
+      def collect_files: () -> Array[String]
+
+      # Check if file should be scanned
+      #
+      # @param file File path
+      # @return Boolean
+      def scannable_file?: (String file) -> bool
+
+      # Scan single file and extract keys
+      #
+      # @param file File path
+      def scan_file: (String file) -> void
+    end
+  end
+end