inertia_i18n 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc3b1063cb9d177edbf18129f392d70249ae7d15afedf9a933eeeba81ae8c9b6
-  data.tar.gz: 573079aff7dc0032cf2d40036c026474343c9fb221e198b593920870444cbac5
+  metadata.gz: f6aedf82d5304993ab58a1dc1b6f1fedee2bd08328be799da83d0bafd50cba32
+  data.tar.gz: cfe3ce966e7359e38c3ec0752f4c902735f9f60c79e33b9eac903ef002e41ed0
 SHA512:
-  metadata.gz: 11c00ed36396cd3d20cd7938fc34d0b7e98b89f7eeaaa5d4576865ea390685f6c7c3ffd1deac376c08252317b4c716b88da4cc3d265d58a6870df05b5980bba4
-  data.tar.gz: d245a9bb60931d7d75f416497ef578640db298e06d31d1eeb1670b140089dd74e29b52bf496fbeb0501fe3c1a8186531f4844832e7f4466d85fcbc3159450ffc
+  metadata.gz: 249f0dc540b501b336b89a3f69bb32e294a005f510cbfc7ae81c5c1b2c40a40184f046342c2286cbbf561c8eb76d452983a60859b45f066e77db9fffbe745e66
+  data.tar.gz: cf6145d5310f3162d36dcdcdabdcd9760e8088b5507f874ef6e6b10f97ad8a6584fa17d609e72158f39fd30af4ab9c997f4d310bbfe777cdda6632ae22a7d0fd

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 ## [Unreleased]
 
+## [0.3.0] - 2026-01-19
+
+### Added
+
+- Configuration options for tuning health checks: `key_properties`, `sibling_detection`, and`missing_key_filters`
+- Support for extracting translation keys from object properties (e.g., `titleKey: "some.key"`)
+- Support for detecting string concatenation patterns as dynamic keys (e.g., `t('prefix.' + var)`)
+
+### Improved
+
+- Health Checker now intelligently handles i18next plural suffixes:
+  - Missing check: `t('key', { count: n })` won't report missing if `key_one`/`key_other` exist
+  - Unused check: `key_one`/`key_other` won't report unused if base `key` is used in code
+- Added "sibling detection" to automatically handle enum-like keys (e.g., if `status.open` is used, all`status.*` are considered used)
+- Added default filters for false-positive missing keys (ignores short keys, keys without dots, URLs,constants, incomplete keys ending with `.`)
+
 ## [0.2.0] - 2026-01-18
 
 ### Added

data/lib/inertia_i18n/configuration.rb

@@ -35,6 +35,15 @@ module InertiaI18n
     # Keys to ignore during missing check
     attr_accessor :ignore_missing
 
+    # Object properties that contain translation keys (e.g., titleKey: "some.key")
+    attr_accessor :key_properties
+
+    # Sibling detection settings for enum-like keys (status, types, etc.)
+    attr_accessor :sibling_detection
+
+    # Filters for false-positive missing keys
+    attr_accessor :missing_key_filters
+
     def initialize
       @source_paths = ["config/locales/frontend"]
       @target_path = "app/frontend/locales"
@@ -52,6 +61,21 @@ module InertiaI18n
       @dynamic_patterns = {}
       @ignore_unused = []
       @ignore_missing = []
+      @key_properties = %w[titleKey labelKey messageKey descriptionKey placeholderKey key]
+      @sibling_detection = {
+        enabled: true,
+        suffixes: %w[status statuses types type priorities priority]
+      }
+      @missing_key_filters = {
+        min_length: 4,
+        require_dot: true,
+        exclude_patterns: [
+          /^\/[\w\/-]*$/,           # URL paths (/hr/applications)
+          /^[A-Z_]+$/,               # Constants (HTTP, POST)
+          /^\w+_id$/,                # ID fields (user_id, parent_id)
+          /^[a-z]{2}(-[A-Z]{2})?$/   # Locales (en, ru-RU)
+        ]
+      }
     end
 
     def primary_locale

data/lib/inertia_i18n/health_checker.rb

@@ -42,6 +42,12 @@ module InertiaI18n
 
       missing = used_keys - available_keys
 
+      # Apply built-in filters for false positives
+      missing = apply_missing_filters(missing)
+
+      # Filter out keys that have i18next plural suffixes (e.g., key_one, key_other)
+      missing = filter_plural_keys(missing, available_keys)
+
       # Filter out keys covered by ignore_missing config
       missing = filter_ignored_keys(missing, @config.ignore_missing)
 
@@ -72,6 +78,18 @@ module InertiaI18n
         dynamic_prefixes.any? { |prefix| key.start_with?(prefix) }
       end
 
+      # Apply sibling detection for enum-like keys (status, types, etc.)
+      if @config.sibling_detection[:enabled]
+        sibling_prefixes = detect_sibling_prefixes(used_keys)
+        unused = unused.reject do |key|
+          sibling_prefixes.any? { |prefix| key.start_with?(prefix) }
+        end
+      end
+
+      # Filter out i18next plural variant keys when base key is used
+      # e.g., if "key" is used, don't mark "key_one", "key_other" as unused
+      unused = filter_plural_variant_keys(unused, used_keys)
+
       # Filter out keys covered by ignore_unused config
       unused = filter_ignored_keys(unused, @config.ignore_unused)
 
@@ -128,5 +146,93 @@ module InertiaI18n
         end
       end
     end
+
+    # Filter out keys that have i18next pluralization suffixes present
+    # e.g., if "key_one" or "key_other" exists, consider "key" as present
+    def filter_plural_keys(keys, available_keys)
+      # i18next plural suffixes
+      plural_suffixes = %w[_zero _one _two _few _many _other]
+
+      keys.reject do |key|
+        plural_suffixes.any? do |suffix|
+          available_keys.include?("#{key}#{suffix}")
+        end
+      end
+    end
+
+    # Filter out i18next plural variant keys when base key is used
+    # e.g., if "key" is used in code, don't mark "key_one", "key_other" as unused
+    def filter_plural_variant_keys(keys, used_keys)
+      plural_suffixes = %w[_zero _one _two _few _many _other]
+
+      keys.reject do |key|
+        # Check if this key ends with a plural suffix
+        plural_suffixes.any? do |suffix|
+          next false unless key.end_with?(suffix)
+
+          # Extract base key and check if it's used
+          base_key = key.chomp(suffix)
+          used_keys.include?(base_key)
+        end
+      end
+    end
+
+    # Filter out false-positive missing keys based on configured filters
+    def apply_missing_filters(keys)
+      filters = @config.missing_key_filters
+      return keys if filters.nil? || filters.empty?
+
+      keys.reject do |key|
+        # Filter by minimum length
+        if filters[:min_length] && key.length < filters[:min_length]
+          next true
+        end
+
+        # Require at least one dot (namespace separator)
+        if filters[:require_dot] && !key.include?(".")
+          next true
+        end
+
+        # Filter out incomplete keys ending with dot (string concatenation patterns)
+        if key.end_with?(".")
+          next true
+        end
+
+        # Apply exclusion patterns
+        if filters[:exclude_patterns]
+          next true if filters[:exclude_patterns].any? { |p| key.match?(p) }
+        end
+
+        false
+      end
+    end
+
+    # Detect sibling prefixes from used keys for enum-like namespaces
+    # If code uses "hr.vacancies.status.open", consider all "hr.vacancies.status.*" as potentially used
+    def detect_sibling_prefixes(used_keys)
+      prefixes = Set.new
+      suffixes = @config.sibling_detection[:suffixes] || []
+
+      used_keys.each do |key|
+        parts = key.split(".")
+        next if parts.length < 2
+
+        # Check if any suffix matches a part of the key
+        suffixes.each do |suffix|
+          # Find index of suffix in key parts (handle both singular and plural)
+          idx = parts.index(suffix) ||
+            parts.index("#{suffix}s") ||
+            parts.index(suffix.chomp("s"))
+
+          # If found and there's at least one more segment after it
+          if idx && idx < parts.length - 1
+            prefix = parts[0..idx].join(".") + "."
+            prefixes.add(prefix)
+          end
+        end
+      end
+
+      prefixes.to_a
+    end
   end
 end

data/lib/inertia_i18n/parsers/javascript_parsing.rb

@@ -37,6 +37,14 @@ module InertiaI18n
           end
         end
 
+        # Extract keys from object properties (e.g., titleKey: "some.key")
+        config.key_properties.each do |prop|
+          # Matches: titleKey: "some.key" or titleKey: 'some.key'
+          content.scan(/#{Regexp.escape(prop)}\s*:\s*(['"])([^'"]+)\1/) do |_quote, key|
+            keys << key if looks_like_i18n_key?(key)
+          end
+        end
+
         keys
       end
 
@@ -49,18 +57,34 @@ module InertiaI18n
           escaped_func = Regexp.escape(func)
 
           # Matches t(`prefix.${var}`)
-
           content.scan(/(?<!\w)#{escaped_func}\(\s*`([^`]*\$\{.+?)`/) do |match|
             template = match[0]
-
             prefix = template.split("${").first
-
             patterns << {pattern: prefix, type: :template_literal, raw: template}
           end
+
+          # Matches t('prefix.' + var) or t("prefix." + var) - string concatenation
+          content.scan(/(?<!\w)#{escaped_func}\(\s*(['"])([^'"]+\.)\1\s*\+/) do |match|
+            prefix = match[1]
+            patterns << {pattern: prefix, type: :string_concat, raw: "#{prefix} + ..."}
+          end
         end
 
         patterns
       end
+
+      private
+
+      # Check if a string looks like an i18n key (has dots, proper length, not a URL)
+      def looks_like_i18n_key?(key)
+        return false if key.nil? || key.empty?
+        return false if key.length < 4
+        return false unless key.include?(".")
+        return false if key.start_with?("/")
+        return false if key.match?(/^https?:/)
+        return false if key.match?(/\s/) # Contains whitespace
+        true
+      end
     end
   end
 end

data/lib/inertia_i18n/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module InertiaI18n
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: inertia_i18n
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Alexey Poimtsev
@@ -121,6 +121,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: lefthook
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Convert Rails YAML locales to i18next JSON, scan frontend code for translation
   usage, detect missing/unused keys, and check locale synchronization. Supports Svelte,
   React, and Vue frontends.