i18n-context-generator 0.4.0 → 0.5.1

data/lib/i18n_context_generator/context_extractor/run_logging.rb

@@ -8,18 +8,57 @@ module I18nContextGenerator
 
       def log_empty_entries_message
         if @config.diff_base && translation_backed_discovery?
-          puts "No changed translation keys found since #{@config.diff_base}."
+          log "No changed translation keys found in #{@config.diff_base}...#{@config.diff_head}."
         elsif @config.diff_base && source_discovery_filtered_by_diff?
-          puts "No changed source localization entries found since #{@config.diff_base}."
+          log "No changed source localization entries found in #{@config.diff_base}...#{@config.diff_head}."
         else
-          puts "No #{entry_label_for_logging} found."
+          log "No #{entry_label_for_logging} found."
         end
       end
 
       def log_loaded_entries(count)
-        puts "Loaded #{count} #{entry_label_for_logging}"
-        puts "(filtered to changes since #{@config.diff_base})" if @config.diff_base && translation_backed_discovery?
-        puts "(filtered to source changes since #{@config.diff_base})" if source_discovery_filtered_by_diff?
+        log "Loaded #{count} #{entry_label_for_logging}"
+        range = "#{@config.diff_base}...#{@config.diff_head}"
+        log "(filtered to changes in #{range})" if @config.diff_base && translation_backed_discovery?
+        log "(filtered to source changes in #{range})" if source_discovery_filtered_by_diff?
+      end
+
+      def resolved_model
+        LLM::Client.default_model_for(@config.provider, configured_model: @config.model)
+      end
+
+      def log_metrics
+        summary = [
+          "Requests: #{@metrics.request_count}",
+          "cache hits: #{@metrics.cache_hits}",
+          "tokens: #{@metrics.input_tokens} in / #{@metrics.output_tokens} out",
+          "retries: #{@metrics.retry_count}"
+        ].join(', ')
+        if @metrics.estimated_cost_usd
+          summary += format(
+            ', estimated cost: $%<cost>.6f (standard list prices as of %<date>s)',
+            cost: @metrics.estimated_cost_usd,
+            date: @metrics.cost_pricing_as_of
+          )
+        end
+        log summary
+      end
+
+      def log(message = '')
+        return if @quiet
+
+        log_output.puts(message)
+      end
+
+      def log_output
+        @configured_log_output ||
+          (@config.output_stdout || workflow_stage == 'preview_diff' ? $stderr : $stdout)
+      end
+
+      def write_patch(patch)
+        output = @patch_output || $stdout
+        output.write(patch)
+        output.write("\n") unless patch.end_with?("\n")
       end
     end
   end

data/lib/i18n_context_generator/context_extractor/source_entries.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module I18nContextGenerator
+  class ContextExtractor
+    # Loads source-discovered entries and hydrates them from translation files.
+    module SourceEntries
+      private
+
+      def load_entries
+        case normalized_discovery_mode
+        when 'source'
+          load_source_entries
+        when 'translations'
+          load_translations
+        else
+          auto_discovery_entries
+        end
+      end
+
+      def auto_discovery_entries
+        return load_source_entries if @config.translations.empty?
+
+        load_translations
+      end
+
+      def load_source_entries
+        discovered_entries = filter_source_entries(searcher.discover_localization_entries)
+
+        discovered_entries.flat_map do |entry|
+          hydrated_entries = translation_entries_for_discovered(entry)
+          hydrated_entries = [nil] if hydrated_entries.empty?
+
+          hydrated_entries.map { |hydrated_entry| build_source_entry(entry, hydrated_entry) }
+        end
+      end
+
+      def build_source_entry(entry, hydrated_entry)
+        translation_comment = hydrated_entry&.metadata&.dig(:comment)
+        source_comment = entry.comment
+        metadata = hydrated_entry&.metadata&.dup || {}
+        metadata[:comment] = translation_comment || source_comment if translation_comment || source_comment
+        metadata[:source_location] = "#{entry.file}:#{entry.line}"
+        metadata[:source_locations] = entry.locations
+        metadata[:source_location_groups] = entry.location_groups
+        metadata[:resource_type] = entry.resource_type unless entry.resource_type == :string
+
+        Parsers::TranslationEntry.new(
+          key: hydrated_entry&.key || entry.key,
+          text: hydrated_entry&.text || entry.text || entry.key,
+          source_file: hydrated_entry&.source_file,
+          metadata: metadata
+        )
+      end
+
+      def load_translation_lookup
+        return @load_translation_lookup if defined?(@load_translation_lookup)
+
+        empty_lookup = Hash.new { |hash, key| hash[key] = [] }
+        @load_translation_lookup = load_translations.each_with_object(empty_lookup) do |entry, lookup|
+          lookup[entry.key] << entry
+        end
+      end
+
+      def load_translation_resource_lookup
+        return @load_translation_resource_lookup if defined?(@load_translation_resource_lookup)
+
+        empty_lookup = Hash.new { |hash, key| hash[key] = [] }
+        @load_translation_resource_lookup = load_translations.each_with_object(empty_lookup) do |entry, lookup|
+          metadata = entry.metadata || {}
+          if metadata[:plural]
+            lookup[[:plural, metadata[:plural]]] << entry
+          elsif metadata[:array]
+            lookup[[:array, metadata[:array]]] << entry
+          end
+        end
+      end
+
+      def translation_entries_for_discovered(entry)
+        case entry.resource_type
+        when :plural, :array
+          load_translation_resource_lookup[[entry.resource_type, entry.key]]
+        else
+          load_translation_lookup[entry.key]
+        end
+      end
+
+      def normalized_discovery_mode
+        @config.discovery_mode.to_s.downcase
+      end
+
+      def translation_backed_discovery?
+        return true if normalized_discovery_mode == 'translations'
+        return false if normalized_discovery_mode == 'source'
+
+        @config.translations.any?
+      end
+
+      def entry_label_for_logging
+        translation_backed_discovery? ? 'translation keys' : 'source localization entries'
+      end
+    end
+  end
+end

data/lib/i18n_context_generator/context_extractor/source_filters.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'pathname'
+
 module I18nContextGenerator
   class ContextExtractor
     # Helpers for filtering source-discovered entries without narrowing the full
@@ -21,7 +23,9 @@ module I18nContextGenerator
         return [] if line_filter.empty?
 
         entries.select do |entry|
-          line_filter.fetch(entry.file.to_s, Set.new).include?(entry.line)
+          entry.locations.any? do |location|
+            changed_location?(location, line_filter)
+          end
         end
       end
 
@@ -31,11 +35,41 @@ module I18nContextGenerator
         @source_line_filter =
           if @config.source_line_filter
             normalize_source_line_filter(@config.source_line_filter)
-          elsif @config.diff_base && source_discovery?
-            GitDiff.new(base_ref: @config.diff_base).changed_lines(@config.source_paths)
+          elsif @config.diff_base
+            git_diff.changed_lines(@config.source_paths)
           end
       end
 
+      def changed_result_locations_for(locations)
+        line_filter = source_line_filter
+        return [] unless line_filter
+
+        locations.select do |location|
+          changed_location?(location, line_filter)
+        end
+      end
+
+      def changed_result_location_groups_for(entry, changed_locations)
+        return [] if changed_locations.empty?
+
+        location_groups = entry.metadata&.dig(:source_location_groups)
+        return changed_locations.map { |location| [location] } unless location_groups&.any?
+
+        changed_location_set = changed_locations.to_set
+        location_groups.filter_map do |group|
+          changed_group = Array(group).select { |location| changed_location_set.include?(location) }
+          changed_group unless changed_group.empty?
+        end
+      end
+
+      def changed_location_attributes_for(entry, locations)
+        changed_locations = changed_result_locations_for(locations)
+        {
+          changed_locations: changed_locations,
+          changed_location_groups: changed_result_location_groups_for(entry, changed_locations)
+        }
+      end
+
       def normalize_source_line_filter(filter)
         filter.each_with_object(Hash.new { |h, k| h[k] = Set.new }) do |(file, lines), normalized_filter|
           next if file.nil?
@@ -43,13 +77,25 @@ module I18nContextGenerator
           normalized_lines = Array(lines).filter_map { |line| Integer(line, exception: false) }
           next if normalized_lines.empty?
 
-          normalized_filter[file.to_s].merge(normalized_lines)
+          normalized_filter[normalize_source_file(file)].merge(normalized_lines)
         end
       end
 
+      def changed_location?(location, line_filter)
+        file, _, line = location.rpartition(':')
+        line_filter.fetch(normalize_source_file(file), Set.new).include?(line.to_i)
+      end
+
+      def normalize_source_file(file)
+        Pathname.new(file.to_s).cleanpath.to_s
+      end
+
       def result_locations_for(entry, matches)
+        source_locations = entry.metadata&.dig(:source_locations)
+        return source_locations if source_locations&.any?
+
         source_location = entry.metadata&.dig(:source_location)
-        return [source_location] if source_location
+        return Array(source_location) if source_location
 
         matches.map { |m| "#{m.file}:#{m.line}" }
       end

data/lib/i18n_context_generator/context_extractor/translation_filters.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require_relative '../android_resource'
+
+module I18nContextGenerator
+  class ContextExtractor
+    # Filters translation-backed entries and retains their changed inline locations.
+    module TranslationFilters
+      private
+
+      def filter_by_diff(entries)
+        @android_collection_members_by_location = {}
+        @android_resource_indexes_by_file = {}
+        @changed_translation_locations = git_diff.changed_key_locations(@config.translations)
+
+        return [] if @changed_translation_locations.empty?
+
+        log "Found #{@changed_translation_locations.size} changed translation entries in git diff"
+
+        entries.select { |entry| changed_translation_locations_for(entry).any? }
+      end
+
+      # Extract the base resource name from composite Android keys.
+      def android_base_key(key)
+        AndroidResource.base_key(key)
+      end
+
+      def translation_key_for(entry)
+        metadata = entry.metadata || {}
+        metadata[:plural] || metadata[:array] || android_base_key(entry.key)
+      end
+
+      def changed_translation_locations_for(entry)
+        return [] unless @changed_translation_locations
+        return [] unless entry.source_file
+
+        source_file = Pathname.new(entry.source_file).cleanpath.to_s
+        locations = @changed_translation_locations.fetch([source_file, translation_key_for(entry)], [])
+        narrow_android_collection_locations(entry, locations)
+      end
+
+      def narrow_android_collection_locations(entry, locations)
+        metadata = entry.metadata || {}
+        return locations unless metadata[:plural] || metadata[:array]
+
+        members_by_location = locations.to_h do |location|
+          changed_location = ChangedLocation.parse(location)
+          line_number = changed_location.right? ? changed_location.line : changed_location.fallback_line
+          member = if line_number && metadata[:line_span]&.cover?(line_number)
+                     entry.key
+                   else
+                     android_collection_member_at(changed_location, translation_key_for(entry))
+                   end
+          [location, member]
+        end
+        return locations if members_by_location.values.compact.empty?
+
+        locations.select { |location| members_by_location[location] == entry.key }
+      end
+
+      def android_collection_member_at(location, expected_parent)
+        cache_key = [expected_parent, location]
+        return @android_collection_members_by_location[cache_key] if @android_collection_members_by_location&.key?(cache_key)
+
+        changed_location = ChangedLocation.parse(location)
+        file = changed_location.file
+        target_line = changed_location.right? ? changed_location.line : changed_location.fallback_line
+        return unless target_line
+
+        member = scan_android_collection_members(file, target_line, expected_parent) if File.file?(file)
+        @android_collection_members_by_location ||= {}
+        @android_collection_members_by_location[cache_key] = member
+      end
+
+      def scan_android_collection_members(file, target_line, expected_parent)
+        android_resource_index(file).member_at(target_line, parent: expected_parent)
+      end
+
+      def android_resource_index(file)
+        @android_resource_indexes_by_file ||= {}
+        @android_resource_indexes_by_file[file] ||=
+          AndroidResource.index(File.read(file, encoding: 'UTF-8'))
+      end
+
+      def git_diff
+        @git_diff ||= GitDiff.new(base_ref: @config.diff_base, head_ref: @config.diff_head)
+      end
+    end
+  end
+end

data/lib/i18n_context_generator/context_extractor/workflow.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module I18nContextGenerator
+  class ContextExtractor
+    # Explicit non-mutating and mutating workflow stages shared by the CLI and
+    # programmatic callers.
+    module Workflow
+      private
+
+      def workflow_stage
+        @config.dry_run ? 'plan' : @config.workflow_stage
+      end
+
+      def pre_extraction_stage_handled?(entries)
+        case workflow_stage
+        when 'plan'
+          log_plan(entries)
+          true
+        when 'check'
+          check_entries(entries)
+          true
+        else
+          false
+        end
+      end
+
+      def log_plan(entries)
+        label = @config.dry_run ? 'Dry run' : 'Plan'
+        log "\n#{label} - would process these keys:"
+        entries.first(20).each { |entry| log "  - #{entry.key}: #{truncate(entry.text, 50)}" }
+        log "  ... and #{entries.size - 20} more" if entries.size > 20
+        destinations = []
+        destinations << (@config.output_stdout ? 'structured stdout' : @config.output_path) if @config.output_path
+        destinations << 'translation write-back' if @config.write_back
+        destinations << 'Swift code write-back' if @config.write_back_to_code
+        log "Destinations: #{destinations.empty? ? 'none' : destinations.join(', ')}"
+      end
+
+      def check_entries(entries)
+        without_usage = entries.count do |entry|
+          resource_type = entry.metadata&.dig(:resource_type)
+          searcher.search(entry.key, resource_type: resource_type).empty?
+        end
+        log "Check passed: #{entries.size} entries parsed; #{without_usage} without source usage."
+      end
+
+      def deliver_results
+        if workflow_stage == 'preview_diff'
+          preview_changes
+        else
+          apply_results
+        end
+      end
+
+      def apply_results
+        write_configured_output
+        write_back_to_source if @config.write_back
+        write_back_to_code if @config.write_back_to_code
+      end
+
+      def write_configured_output
+        return unless @config.output_path
+
+        write_output
+        log "\nWrote #{@results.size} results to #{@config.output_stdout ? 'stdout' : @config.output_path}"
+      end
+
+      def preview_changes
+        preview_translation_changes if @config.write_back
+        preview_code_changes if @config.write_back_to_code
+      end
+
+      def preview_translation_changes
+        @config.translations.each do |path|
+          writer = source_writer_for(path)
+          next unless writer
+
+          relevant_results = @results.select { |result| result_matches_source_path?(result, path) }
+          next if relevant_results.empty?
+
+          patch = Writers::Preview.render(path) do |candidate_path|
+            candidate_results = relevant_results.map do |result|
+              ExtractionResult.new(**result.to_h.except(:source_file), source_file: candidate_path)
+            end
+            writer.write(candidate_results, candidate_path)
+          end
+          write_patch(patch) if patch
+        end
+      end
+
+      def preview_code_changes
+        results_by_key = build_results_by_key_for_code_write_back
+        return if results_by_key.empty?
+
+        swift_files_for_write_back.each do |swift_file|
+          patch = Writers::Preview.render(swift_file) do |candidate_path|
+            swift_writer.update_file(candidate_path, results_by_key)
+          end
+          write_patch(patch) if patch
+        end
+      end
+
+      def swift_writer
+        @swift_writer ||= Writers::SwiftWriter.new(
+          functions: @config.swift_functions,
+          context_prefix: @config.context_prefix,
+          context_mode: @config.context_mode
+        )
+      end
+
+      def swift_files_for_write_back
+        @config.source_paths.flat_map do |source_path|
+          find_swift_files(source_path, ignore_patterns: @config.ignore_patterns)
+        end.uniq
+      end
+    end
+  end
+end