i18n-context-generator 0.3.0 → 0.5.0

data/lib/i18n_context_generator/llm/openai.rb

@@ -6,70 +6,56 @@ module I18nContextGenerator
     class OpenAI < Client
       API_URL = 'https://api.openai.com/v1/responses'
       DEFAULT_MODEL = 'gpt-5-mini'
-      MAX_RETRIES = 2
-      RESPONSE_SCHEMA = {
-        type: 'object',
-        additionalProperties: false,
-        required: %w[description ui_element tone max_length],
-        properties: {
-          description: { type: 'string' },
-          ui_element: { type: %w[string null], enum: %w[button label title alert toast placeholder navigation menu tab error confirmation other] + [nil] },
-          tone: { type: %w[string null], enum: %w[formal casual urgent friendly technical neutral] + [nil] },
-          max_length: { type: %w[integer null] }
-        }
-      }.freeze
 
-      def initialize
-        super
-        @api_key = ENV.fetch('OPENAI_API_KEY', nil)
-        raise Error, 'OPENAI_API_KEY environment variable is required' unless @api_key
+      def initialize(api_url: API_URL, api_key: ENV.fetch('OPENAI_API_KEY', nil), require_api_key: true)
+        super()
+        @api_key = api_key
+        raise Error, 'OPENAI_API_KEY environment variable is required' if require_api_key && !@api_key
 
-        @uri = URI(API_URL)
+        @uri = URI(api_url)
       end
 
       def generate_context(key:, text:, matches:, model: nil, comment: nil,
-                           include_file_paths: false, redact_prompts: true)
-        model ||= DEFAULT_MODEL
+                           include_file_paths: false, redact_prompts: true,
+                           max_prompt_chars: nil, supplemental_context: [])
+        outcome = nil
+        model = resolved_model(model)
         prompt = build_prompt(
           key: key,
           text: text,
           matches: matches,
           comment: comment,
           include_file_paths: include_file_paths,
-          redact_prompts: redact_prompts
+          redact_prompts: redact_prompts,
+          max_prompt_chars: max_prompt_chars,
+          supplemental_context: supplemental_context
         )
-        retries = 0
-
-        loop do
-          response = post_request(model: model, prompt: prompt)
-
-          if response.code.to_i == 429 && retries < MAX_RETRIES
-            retries += 1
-            delay = (response['retry-after']&.to_i || 2) * retries
-            sleep(delay)
-            next
-          end
-
-          return handle_response(response)
-        end
+        outcome = request_with_retries(uri: @uri) { post_request(model: model, prompt: prompt) }
+        handle_response(outcome.response, retries: outcome.retries)
+      rescue PromptPreparationError => e
+        ContextResult.new(description: 'Prompt preparation failed', error: e.message)
       rescue StandardError => e
-        ContextResult.new(description: 'API request failed', error: e.message)
+        ContextResult.new(
+          description: 'API request failed',
+          error: e.message,
+          **failure_request_telemetry(e, outcome: outcome)
+        )
       end
 
       private
 
       def post_request(model:, prompt:)
+        headers = {}
+        headers['Authorization'] = "Bearer #{@api_key}" if @api_key
         post_json(
           uri: @uri,
-          headers: {
-            'Authorization' => "Bearer #{@api_key}"
-          },
+          headers: headers,
           body: {
             model: model,
             store: false,
             instructions: SYSTEM_PROMPT,
             input: prompt,
-            max_output_tokens: 500,
+            max_output_tokens: MAX_OUTPUT_TOKENS,
             text: {
               format: {
                 type: 'json_schema',
@@ -82,24 +68,70 @@ module I18nContextGenerator
         )
       end
 
-      def handle_response(response)
+      def handle_response(response, retries:)
         case response.code.to_i
         when 200
           body = JSON.parse(response.body)
-          parse_response(extract_output_text(body))
-        when 429
-          ContextResult.new(description: 'Rate limited', error: 'Rate limit exceeded - try reducing concurrency')
-        when 401
-          ContextResult.new(description: 'Authentication failed', error: 'Invalid API key')
+          handle_successful_response(body, retries: retries)
         else
-          error_body = begin
-            JSON.parse(response.body)
-          rescue StandardError
-            {}
+          http_error_result(response, retries: retries)
+        end
+      end
+
+      def handle_successful_response(body, retries:)
+        telemetry = usage_telemetry(body, retries: retries)
+        status = body['status']
+        return incomplete_result(body, telemetry: telemetry) if status == 'incomplete'
+        return failed_result(body, telemetry: telemetry) if status == 'failed'
+
+        unless status == 'completed'
+          return ContextResult.new(
+            description: 'Incomplete response',
+            error: "Unexpected OpenAI response status: #{status || 'missing'}",
+            **telemetry
+          )
+        end
+
+        refusal = extract_refusal(body)
+        if refusal
+          return ContextResult.new(
+            description: 'Provider refused request',
+            error: "OpenAI refusal: #{refusal[0, 300]}",
+            **telemetry
+          )
+        end
+
+        parse_response(extract_output_text(body), telemetry: telemetry)
+      end
+
+      def incomplete_result(body, telemetry:)
+        reason = body.dig('incomplete_details', 'reason') || 'unknown reason'
+        ContextResult.new(
+          description: 'Incomplete response',
+          error: "OpenAI response incomplete: #{reason}",
+          **telemetry
+        )
+      end
+
+      def failed_result(body, telemetry:)
+        message = body.dig('error', 'message') || 'unknown provider error'
+        ContextResult.new(
+          description: 'API error',
+          error: "OpenAI response failed: #{message.to_s[0, 300]}",
+          **telemetry
+        )
+      end
+
+      def extract_refusal(body)
+        Array(body['output']).each do |output_item|
+          Array(output_item['content']).each do |content_item|
+            next unless content_item['type'] == 'refusal'
+
+            refusal = content_item['refusal'].to_s
+            return refusal unless refusal.empty?
           end
-          error_msg = error_body.dig('error', 'message') || error_body['message'] || "HTTP #{response.code}"
-          ContextResult.new(description: 'API error', error: error_msg)
         end
+        nil
       end
 
       def extract_output_text(body)
@@ -107,6 +139,15 @@ module I18nContextGenerator
         content_item = Array(output_item&.[]('content')).find { |item| item['type'] == 'output_text' }
         content_item&.dig('text')
       end
+
+      def usage_telemetry(body, retries:)
+        {
+          input_tokens: body.dig('usage', 'input_tokens').to_i,
+          output_tokens: body.dig('usage', 'output_tokens').to_i,
+          retries: retries,
+          request_count: retries + 1
+        }
+      end
     end
   end
 end

data/lib/i18n_context_generator/llm/openai_compatible.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module I18nContextGenerator
+  module LLM
+    # Explicit OpenAI Responses-compatible endpoint support. A separate
+    # credential variable prevents local or third-party endpoints from ever
+    # receiving the official OpenAI credential by accident.
+    class OpenAICompatible < OpenAI
+      DEFAULT_MODEL = nil
+
+      def initialize(endpoint:)
+        super(
+          api_url: endpoint,
+          api_key: ENV.fetch('OPENAI_COMPATIBLE_API_KEY', nil),
+          require_api_key: false
+        )
+      end
+    end
+  end
+end

data/lib/i18n_context_generator/llm/prompt_evidence.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module I18nContextGenerator
+  module LLM
+    # Converts application and supplemental inputs into prompt-safe evidence records.
+    module PromptEvidence
+      private
+
+      def detect_platform(matches)
+        return 'mobile' if matches.empty?
+
+        platforms = matches.filter_map { |match| FileClassifier.searchable_platform(match.file) }
+
+        if platforms.include?(:ios)
+          'iOS'
+        elsif platforms.include?(:android)
+          'Android'
+        else
+          'mobile'
+        end
+      end
+
+      def prompt_matches(matches, include_file_paths:, redact_prompts:)
+        matches.map do |match|
+          location = include_file_paths ? match.file : File.basename(match.file)
+          {
+            location: sanitized_prompt_value(location, redact: redact_prompts),
+            line: match.line,
+            enclosing_scope: sanitized_prompt_value(match.enclosing_scope, redact: redact_prompts),
+            matched_line: sanitized_prompt_value(match.match_line, redact: redact_prompts),
+            context: sanitized_prompt_value(match.context, redact: redact_prompts)
+          }.compact
+        end
+      end
+
+      def prompt_context_sources(sources, redact_prompts:)
+        sources.map do |source|
+          {
+            kind: sanitized_prompt_value(source.kind, redact: redact_prompts),
+            name: sanitized_prompt_value(source.name, redact: redact_prompts),
+            content: sanitized_prompt_value(source.content, redact: redact_prompts)
+          }
+        end
+      end
+    end
+  end
+end

data/lib/i18n_context_generator/llm/request_policy.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module I18nContextGenerator
+  module LLM
+    # Shared retry and HTTP error handling for remote LLM providers.
+    module RequestPolicy
+      RequestOutcome = Data.define(:response, :retries) do
+        def request_count = retries + 1
+      end
+
+      # Adds run-local attempt counters to a transport exception without
+      # changing its public exception class.
+      module FailureTelemetry
+        attr_reader :request_count, :retries
+
+        def record_request_failure(retries:)
+          @retries = retries
+          @request_count = retries + 1
+          self
+        end
+      end
+      private_constant :FailureTelemetry
+
+      MAX_RETRIES = 2
+      MAX_RETRY_DELAY = 30.0
+      RETRYABLE_STATUS_CODES = [408, 409, 425, 429, 500, 502, 503, 504, 529].freeze
+      TRANSIENT_NETWORK_ERRORS = [
+        Net::OpenTimeout,
+        Net::ReadTimeout,
+        Timeout::Error,
+        EOFError,
+        SocketError,
+        Errno::ECONNABORTED,
+        Errno::ECONNREFUSED,
+        Errno::ECONNRESET,
+        Errno::EHOSTUNREACH,
+        Errno::ENETUNREACH,
+        Errno::ETIMEDOUT,
+        OpenSSL::SSL::SSLError
+      ].freeze
+
+      protected
+
+      def request_with_retries(uri:)
+        retries = 0
+
+        loop do
+          response = yield
+          return RequestOutcome.new(response: response, retries: retries) unless retryable_response?(response) && retries < MAX_RETRIES
+
+          retries += 1
+          delay = retry_delay(response, retries)
+          reset_http_session(uri)
+          sleep(delay)
+        rescue *TRANSIENT_NETWORK_ERRORS => e
+          if retries >= MAX_RETRIES
+            e.extend(FailureTelemetry).record_request_failure(retries: retries)
+            raise
+          end
+
+          retries += 1
+          reset_http_session(uri)
+          sleep(retry_delay(nil, retries))
+          retry
+        end
+      end
+
+      def retryable_response?(response)
+        status = response.code.to_i
+        RETRYABLE_STATUS_CODES.include?(status)
+      end
+
+      def retry_delay(response, retry_number)
+        retry_after = parse_retry_after(response&.[]('retry-after'))
+        return [retry_after, MAX_RETRY_DELAY].min if retry_after
+
+        base = 0.5 * (2**(retry_number - 1))
+        [base + (rand * 0.25), MAX_RETRY_DELAY].min
+      end
+
+      def parse_retry_after(value)
+        return nil if value.nil? || value.to_s.strip.empty?
+
+        numeric = Float(value, exception: false)
+        return [numeric, 0].max if numeric&.finite?
+
+        [Time.httpdate(value) - Time.now, 0].max
+      rescue ArgumentError
+        nil
+      end
+
+      def http_error_result(response, retries: 0)
+        telemetry = request_telemetry(retries: retries)
+        case response.code.to_i
+        when 401
+          ContextResult.new(
+            description: 'Authentication failed',
+            error: 'Provider rejected the API credentials',
+            **telemetry
+          )
+        when 429
+          ContextResult.new(
+            description: 'Rate limited',
+            error: 'Rate limit exceeded - try reducing concurrency',
+            **telemetry
+          )
+        else
+          ContextResult.new(description: 'API error', error: provider_error_message(response), **telemetry)
+        end
+      end
+
+      def provider_error_message(response)
+        body = JSON.parse(response.body)
+        return "HTTP #{response.code}" unless body.is_a?(Hash)
+
+        message = body.dig('error', 'message') || body['message']
+        return "HTTP #{response.code}" unless message.is_a?(String) && !message.empty?
+
+        message.gsub(/[\u0000-\u001F\u007F]/, ' ')[0, 500]
+      rescue JSON::ParserError, TypeError
+        "HTTP #{response.code}"
+      end
+
+      def request_telemetry(retries:)
+        { request_count: retries + 1, retries: retries }
+      end
+
+      def failure_request_telemetry(error, outcome:)
+        return request_telemetry(retries: outcome.retries) if outcome
+        return { request_count: error.request_count, retries: error.retries } if
+          error.respond_to?(:request_count) && error.respond_to?(:retries)
+
+        {}
+      end
+
+      def reset_http_session(uri)
+        sessions = Thread.current.thread_variable_get(http_sessions_key)
+        return unless sessions
+
+        http = sessions.delete([uri.scheme, uri.host, uri.port])
+        http.finish if http&.started?
+      rescue IOError, SystemCallError
+        nil
+      end
+    end
+  end
+end

data/lib/i18n_context_generator/localization_syntax.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+require_relative 'android_resource'
+require_relative 'apple_string_literal'
+
+module I18nContextGenerator
+  # Registry of localization call/resource syntaxes shared by source search,
+  # source-first discovery, and Swift comment write-back.
+  class LocalizationSyntax
+    DEFAULT_SWIFT_FUNCTIONS = %w[
+      NSLocalizedString
+      String(localized:
+      Text(
+      LocalizedStringResource(
+    ].freeze
+
+    IOS_STATIC_SEARCH_BUILDERS = [
+      ->(key) { "LocalizedStringKey\\s*\\(\\s*\"#{key}\"" },
+      ->(key) { "LocalizedStringKey\\s*=\\s*\"#{key}\"" },
+      ->(key) { ":\\s*LocalizedStringResource\\s*=\\s*\"#{key}\"" },
+      ->(key) { "\"#{key}\"\\.localized" }
+    ].freeze
+    SWIFT_STRING_BODY_PATTERN = AppleStringLiteral::BODY_PATTERN
+    private_constant :SWIFT_STRING_BODY_PATTERN
+
+    IOS_STATIC_SINGLE_LINE_DISCOVERY_PATTERNS = [
+      /LocalizedStringKey\s*\(\s*"(?<key>#{SWIFT_STRING_BODY_PATTERN})"\s*\)/,
+      /:\s*LocalizedStringKey\s*=\s*"(?<key>#{SWIFT_STRING_BODY_PATTERN})"/,
+      /:\s*LocalizedStringResource\s*=\s*"(?<key>#{SWIFT_STRING_BODY_PATTERN})"/,
+      /"(?<key>#{SWIFT_STRING_BODY_PATTERN})"\.localized\b/
+    ].freeze
+
+    LOCALIZED_RESOURCE_SINGLE_LINE_DISCOVERY_PATTERNS = [
+      /LocalizedStringResource\s*\(\s*"(?<key>#{SWIFT_STRING_BODY_PATTERN})"[^\n]*?\bdefaultValue:\s*"(?<text>#{SWIFT_STRING_BODY_PATTERN})"/,
+      /LocalizedStringResource\s*\(\s*"(?<key>#{SWIFT_STRING_BODY_PATTERN})"/
+    ].freeze
+
+    IOS_STATIC_MULTILINE_DISCOVERY_PATTERNS = [
+      /Text\s*\(\s*LocalizedStringKey\s*\(\s*"(?<key>#{SWIFT_STRING_BODY_PATTERN})"\s*\)[\s\S]*?\)/
+    ].freeze
+
+    LOCALIZED_RESOURCE_MULTILINE_DISCOVERY_PATTERNS = [
+      /LocalizedStringResource\s*\(\s*"(?<key>#{SWIFT_STRING_BODY_PATTERN})"[\s\S]*?\bdefaultValue:\s*"(?<text>#{SWIFT_STRING_BODY_PATTERN})"/,
+      /LocalizedStringResource\s*\(\s*"(?<key>#{SWIFT_STRING_BODY_PATTERN})"/
+    ].freeze
+
+    OPTIONAL_ARGUMENT_LABEL_PATTERN = '(?:[A-Za-z_]\w*\s*:\s*)?'
+    private_constant :OPTIONAL_ARGUMENT_LABEL_PATTERN
+
+    ANDROID_DISCOVERY_PATTERNS = {
+      string: %r{R\.string\.(\w+)\b|@string/([\w.]+)\b|[(\s,=]string\.(\w+)\b}x,
+      plural: %r{R\.plurals\.(\w+)\b|@plurals/([\w.]+)\b|[(\s,=]plurals\.(\w+)\b}x,
+      array: %r{R\.array\.(\w+)\b|@array/([\w.]+)\b|[(\s,=]array\.(\w+)\b}x
+    }.freeze
+
+    def self.functions_with_defaults(functions)
+      configured = Array(functions).map(&:strip).reject(&:empty?)
+      (DEFAULT_SWIFT_FUNCTIONS + configured).uniq { |function| function.sub(/\(\s*\z/, '') }.freeze
+    end
+
+    def self.swift_string_content_pattern(value)
+      encoded = value.each_char.map do |character|
+        case character
+        when '\\' then '\\\\'
+        when '"' then '\\"'
+        when "\n" then '\n'
+        when "\r" then '\r'
+        when "\t" then '\t'
+        else character
+        end
+      end.join
+      Regexp.escape(encoded)
+    end
+
+    def initialize(swift_functions: nil)
+      @swift_functions = self.class.functions_with_defaults(swift_functions)
+    end
+
+    attr_reader :swift_functions
+
+    def search_patterns(key, platform:, resource_type: nil)
+      strings = case platform.to_sym
+                when :ios then ios_search_patterns(key)
+                when :android then android_search_patterns(key, resource_type: resource_type)
+                else
+                  ios_search_patterns(key) + android_search_patterns(key, resource_type: resource_type) +
+                  [Regexp.escape(key)]
+                end
+      strings.map { |pattern| Regexp.new(pattern) }
+    end
+
+    def ios_search_patterns(key)
+      escaped_key = self.class.swift_string_content_pattern(key)
+      function_patterns = swift_function_key_patterns(escaped_key)
+      function_patterns + IOS_STATIC_SEARCH_BUILDERS.map { |builder| builder.call(escaped_key) }
+    end
+
+    def ios_multiline_search_patterns(key)
+      escaped_key = self.class.swift_string_content_pattern(key)
+      swift_function_key_patterns(escaped_key).map { |pattern| Regexp.new(pattern) }
+    end
+
+    def android_search_patterns(key, resource_type: nil)
+      base_key = AndroidResource.base_key(key)
+      escaped_base = Regexp.escape(base_key)
+
+      case AndroidResource.type_for(key, explicit: resource_type)
+      when :plural then android_plural_patterns(escaped_base)
+      when :array then android_array_patterns(escaped_base)
+      else android_string_patterns(Regexp.escape(key))
+      end
+    end
+
+    def ios_single_line_discovery_patterns
+      @ios_single_line_discovery_patterns ||=
+        (LOCALIZED_RESOURCE_SINGLE_LINE_DISCOVERY_PATTERNS +
+          function_discovery_patterns(multiline: false) +
+          IOS_STATIC_SINGLE_LINE_DISCOVERY_PATTERNS).freeze
+    end
+
+    def ios_multiline_discovery_patterns
+      @ios_multiline_discovery_patterns ||=
+        (LOCALIZED_RESOURCE_MULTILINE_DISCOVERY_PATTERNS +
+          function_discovery_patterns(multiline: true) +
+          IOS_STATIC_MULTILINE_DISCOVERY_PATTERNS).freeze
+    end
+
+    def ios_call_start_patterns
+      @ios_call_start_patterns ||=
+        @swift_functions.map { |function| Regexp.new(swift_function_opener(function)) }.freeze
+    end
+
+    def ios_wrapper_definition_pattern
+      @ios_wrapper_definition_pattern ||= begin
+        functions = (@swift_functions.map { |function| swift_call_prefix(function) } +
+          ['LocalizedStringKey\\s*\\(']).join('|')
+        constructor = "\\s*=\\s*(?:#{functions})"
+        typed_resource = '\s*:\s*LocalizedStringResource\s*=\s*"'
+        /\bstatic\s+(?:let|var)\s+(?<member_name>\w+)(?:#{constructor}|#{typed_resource})/
+      end
+    end
+
+    def android_discovery_patterns
+      ANDROID_DISCOVERY_PATTERNS
+    end
+
+    def swift_writer_patterns(key)
+      escaped_key = self.class.swift_string_content_pattern(key)
+      comment = 'comment:\\s*"(?:\\\\.|[^"\\\\])*"'
+
+      patterns = @swift_functions.map do |function|
+        Regexp.new(
+          "#{swift_key_argument_prefix(function)}\"#{escaped_key}\"[^)]*#{comment}[^)]*\\)",
+          Regexp::MULTILINE
+        )
+      end
+      patterns << nested_text_writer_pattern(escaped_key, comment)
+      patterns
+    end
+
+    private
+
+    def function_discovery_patterns(multiline:)
+      tail = multiline ? '[\\s\\S]*?' : '[^\\n]*?'
+      @swift_functions.flat_map do |function|
+        prefix = swift_key_argument_prefix(function)
+        [
+          Regexp.new("#{prefix}\\s*@?\"(?<key>#{SWIFT_STRING_BODY_PATTERN})\"#{tail}comment:\\s*\"(?<comment>#{SWIFT_STRING_BODY_PATTERN})\""),
+          Regexp.new("#{prefix}\\s*@?\"(?<key>#{SWIFT_STRING_BODY_PATTERN})\"")
+        ]
+      end
+    end
+
+    def swift_function_key_patterns(escaped_key)
+      @swift_functions.map do |function|
+        "#{swift_key_argument_prefix(function)}@?\"#{escaped_key}\""
+      end
+    end
+
+    def swift_key_argument_prefix(function)
+      prefix = swift_call_prefix(function)
+      return "#{prefix}\\s*" if explicit_argument_fragment?(function) || DEFAULT_SWIFT_FUNCTIONS.include?(function)
+
+      "#{prefix}\\s*#{OPTIONAL_ARGUMENT_LABEL_PATTERN}"
+    end
+
+    def swift_call_prefix(function)
+      name, arguments = function.split('(', 2)
+      prefix = "#{Regexp.escape(name.strip)}\\s*\\("
+      return prefix unless arguments
+
+      arguments = arguments.strip
+      arguments.empty? ? prefix : "#{prefix}\\s*#{Regexp.escape(arguments)}"
+    end
+
+    def swift_function_opener(function)
+      name = function.split('(', 2).first
+      "#{Regexp.escape(name.strip)}\\s*\\("
+    end
+
+    def explicit_argument_fragment?(function)
+      _name, arguments = function.split('(', 2)
+      arguments && !arguments.strip.empty?
+    end
+
+    def nested_text_writer_pattern(escaped_key, comment)
+      Regexp.new(
+        "Text\\s*\\(\\s*LocalizedStringKey\\s*\\(\\s*\"#{escaped_key}\"\\s*\\)" \
+        "[^)]*#{comment}[^)]*\\)",
+        Regexp::MULTILINE
+      )
+    end
+
+    def android_plural_patterns(key)
+      [
+        "R\\.plurals\\.#{key}\\b", "@plurals/#{key}\\b",
+        "getQuantityString\\s*\\(\\s*R\\.plurals\\.#{key}",
+        "\\.getQuantityString\\s*\\(\\s*R\\.plurals\\.#{key}",
+        "pluralStringResource\\s*\\(\\s*R\\.plurals\\.#{key}",
+        "[\\(\\s,=]plurals\\.#{key}\\b"
+      ]
+    end
+
+    def android_array_patterns(key)
+      [
+        "R\\.array\\.#{key}\\b", "@array/#{key}\\b",
+        "getStringArray\\s*\\(\\s*R\\.array\\.#{key}",
+        "\\.getStringArray\\s*\\(\\s*R\\.array\\.#{key}",
+        "resources\\.getStringArray\\s*\\(\\s*R\\.array\\.#{key}",
+        "[\\(\\s,=]array\\.#{key}\\b"
+      ]
+    end
+
+    def android_string_patterns(key)
+      [
+        "R\\.string\\.#{key}\\b", "@string/#{key}\\b",
+        "getString\\s*\\(\\s*R\\.string\\.#{key}",
+        "\\.getString\\s*\\(\\s*R\\.string\\.#{key}",
+        "stringResource\\s*\\(\\s*R\\.string\\.#{key}",
+        "[\\(\\s,=]string\\.#{key}\\b",
+        "getString\\s*\\(\\s*string\\.#{key}",
+        "stringResource\\s*\\(\\s*string\\.#{key}"
+      ]
+    end
+  end
+end