locallingo 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ff4c0e72d7b3eb6d699b7cff03d8e2b8a61efb8a1c94c16cc906f2843b4dc53c
-  data.tar.gz: c4419498f0f7de3b334efab4c89471eb3a6a27da543992b5171aa3b67760c3d6
+  metadata.gz: 398a4540431fa5298a1eba1fedecef3c4b7344d2749f935a30882d8899ebcb69
+  data.tar.gz: c854c5c26ebee79b0d5663614207e0f75368c973058a5ac320f58ec4e45e3835
 SHA512:
-  metadata.gz: 7820e2f62b6784ae546cd7521303e434a0319099f1ac69fa7471aff9cb786ff3b844f1200ae711eab36df7e058b31742f03de231c5bd95d460889c1027209628
-  data.tar.gz: b727c0b6f89916f328f3c2b00831263d779b7a7139f478571d7b2e9015326ef8841873da7e72ddd6f963e7f0009dafe9cc4630c1d6883d091bb165672d70fc67
+  metadata.gz: 5969d9cac09643f81e6e37ae72ad79003373d1870bbaf37300c0e4c5a95449c6c422176aa6ea1938b66a53889669bbf3c0a0f5525e56d7f0afd0e8c9c2c33c44
+  data.tar.gz: 22e5a7d6ff926e04baa3e0de58d7cea8d4993356a3ac931de745dbc8e817298b99b2ff591b4e353e1adc9052dd44307fce4cd957605fcd5527c448e83e8d40f4

data/CHANGELOG.md

@@ -6,6 +6,28 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+### Fixed
+- `lingo sync` no longer destroys hand-edit protection: it now only refreshes
+  each entry's `source_hash` and preserves `target_hash` and `manual: true`
+  (the pre-extraction `bin/translate` behavior). Previously a single sync wiped
+  both fields for every key, blinding the `manual_edits` validator and causing
+  `manual` flags to flip back and forth across branches.
+- `translate --force-key` on a `manual`-flagged key keeps the flag. The value is
+  still retranslated on explicit request, but no command removes `manual: true`
+  anymore — unprotecting a key requires editing the state JSON by hand.
+- State files whose content is unchanged are no longer rewritten, so operations
+  never touch `.i18n-state/` files for unrelated namespaces.
+
+### Changed
+- Unscoped `lingo accept-edits` now accepts only the keys the `manual_edits`
+  validator flags (actually hand-edited), instead of stamping `manual: true` on
+  every key of the locale. Use the new `--key KEY` (repeatable) for surgical
+  accepts, or `--all` for the old blanket behavior (initial adoption).
+- Validator suggestions are scoped and safe to follow verbatim: `manual_edit`
+  violations suggest `accept-edits --locale <l> --key <key>`, and `outdated`
+  violations on manual keys tell you to update the value by hand and re-accept
+  it rather than force-translating over curated text.
+
 ### Added
 - `Locallingo.configure { |c| c.anthropic_api_key = ... }` — gem-level provider
   credentials as Strings or lazy callables, for apps whose keys don't live in

data/README.md

@@ -104,8 +104,10 @@ lingo validate --strict            # CI gate (exit 1 on strict-tier issues)
 lingo validate --strict-all        # stricter CI gate
 lingo quality --ai                 # quality linting (+ optional AI pass)
 lingo fix-quality --locale en      # auto-fix fixable issues
-lingo accept-edits --locale de     # mark current translations as intentional
-lingo sync                         # rebuild drift state from current files
+lingo accept-edits --locale de     # protect hand-edited translations (drifted keys only)
+lingo accept-edits --key a.b.c     # protect a specific key
+lingo accept-edits --all           # protect everything (initial adoption)
+lingo sync                         # refresh drift state (preserves manual flags)
 lingo hash                         # source-translation fingerprint
 ```
 

data/lib/locallingo/cli.rb

@@ -109,6 +109,10 @@ module Locallingo
         opts.on("--force-key KEY", "Force re-translation of a specific key") do |v|
           (@options[:force_keys] ||= []) << v
         end
+        opts.on("--key KEY", "accept-edits: accept a specific key (repeatable)") do |v|
+          (@options[:keys] ||= []) << v
+        end
+        opts.on("--all", "accept-edits: mark every translated key as manual") { @options[:all] = true }
         opts.on("-v", "--verbose", "Verbose output") { @options[:verbose] = true }
         opts.on("-n", "--dry-run", "Show what would be done without changing files") { @options[:dry_run] = true }
         opts.on("--strict", "Fail on strict-tier issues (for CI)") { @options[:strict] = true }
@@ -185,11 +189,25 @@ module Locallingo
         warn "manual_edits validator is disabled in .locallingo.yml — nothing to accept."
         return
       end
-      manager(config, options).accept_edits!(locale: options[:locale])
-      puts "✅ Marked current translations as intentional."
+
+      results = manager(config, options).accept_edits!(
+        locale: options[:locale], keys: options[:keys] || [], all: options.fetch(:all, false)
+      )
+      report_accepted(results)
       puts "(dry run - no changes made)" if options[:dry_run]
     end
 
+    def report_accepted(results)
+      total = results.values.sum(&:size)
+      if total.zero?
+        puts "Nothing to accept — no hand-edited translations found."
+        return
+      end
+
+      results.each { |locale, keys| puts "  #{locale}: #{keys.size} key(s)" if keys.any? }
+      puts "✅ Marked #{total} translation(s) as intentional."
+    end
+
     def cmd_hash(config, options)
       hash = manager(config, options).source_hash
       options[:format] == :json ? puts(JSON.generate({ hash: })) : puts(hash)

data/lib/locallingo/manager.rb

@@ -97,27 +97,35 @@ module Locallingo
       locales_to_process.each { |target_locale| translate_locale(source, target_locale, force:, force_keys:) }
     end
 
-    # Mark every current target value as intentional (source_hash + target_hash +
-    # manual flag) so the manual-edits validator stops flagging it.
-    def accept_edits!(locale: nil)
+    # Mark hand-edited target values as intentional (source_hash + target_hash +
+    # manual flag) so the manual-edits validator stops flagging them and
+    # translate won't overwrite them. Unscoped, it accepts exactly the keys the
+    # manual-edits validator flags; `keys:` accepts the named keys regardless of
+    # drift; `all: true` marks every translated key (initial adoption). Returns
+    # `{ locale => accepted_keys }`.
+    def accept_edits!(locale: nil, keys: [], all: false)
       source = load_source_translations
       locales = locale ? [locale] : config.target_locales
 
-      locales.each do |target_locale|
+      plans = locales.map do |target_locale|
         target = load_locale_translations(target_locale)
         locale_state = @state.load(target_locale)
+        accepted = keys_to_accept(source, target, locale_state, keys:, all:)
+        [target_locale, target, locale_state, accepted]
+      end
 
-        target.each do |key, value|
-          next unless source[key]
+      ensure_keys_matched!(keys, plans)
 
+      plans.each_with_object({}) do |(target_locale, target, locale_state, accepted), results|
+        accepted.each do |key|
           locale_state[key] = {
             "source_hash" => @state.hash(source[key]),
-            "target_hash" => @state.hash(value),
+            "target_hash" => @state.hash(target[key]),
             "manual" => true
           }
         end
-
         @state.save(target_locale, locale_state) unless dry_run
+        results[target_locale] = accepted
       end
     end
 
@@ -126,8 +134,11 @@ module Locallingo
       format("%08x", Zlib.crc32(load_source_translations.to_json))
     end
 
-    # Rewrite state from the current translation files (initial setup / after
-    # manual edits). Returns the combined state.
+    # Refresh source hashes from the current translation files and prune state
+    # for keys that no longer exist. Existing `target_hash`/`manual` fields are
+    # preserved — hand-edit protection is never dropped by a sync; use
+    # `accept_edits!` to resolve hand-edit drift explicitly. Returns the
+    # combined state.
     def sync_state!
       source = load_source_translations
 
@@ -136,18 +147,7 @@ module Locallingo
       en_state.each_key { |key| en_state.delete(key) unless source.key?(key) }
       @state.save(config.source_locale, en_state) unless dry_run
 
-      config.target_locales.each do |locale|
-        target = load_locale_translations(locale)
-        locale_state = @state.load(locale)
-
-        target.each_key do |key|
-          next unless source[key]
-
-          locale_state[key] = { "source_hash" => @state.hash(source[key]) }
-        end
-        locale_state.each_key { |key| locale_state.delete(key) unless target.key?(key) }
-        @state.save(locale, locale_state) unless dry_run
-      end
+      config.target_locales.each { |locale| sync_locale_state(source, locale) }
 
       combined = { config.source_locale => @state.load(config.source_locale) }
       config.target_locales.each { |locale| combined[locale] = @state.load(locale) }
@@ -167,6 +167,44 @@ module Locallingo
     def missing_validator = @missing_validator ||= Validators::Missing.new(cli_name:)
     def outdated_validator = @outdated_validator ||= Validators::Outdated.new(cli_name:)
 
+    def sync_locale_state(source, locale)
+      target = load_locale_translations(locale)
+      locale_state = @state.load(locale)
+
+      target.each_key do |key|
+        next unless source[key]
+
+        existing = locale_state[key]
+        entry = existing.is_a?(Hash) ? existing.dup : {}
+        entry["source_hash"] = @state.hash(source[key])
+        locale_state[key] = entry
+      end
+      locale_state.each_key { |key| locale_state.delete(key) unless target.key?(key) }
+      @state.save(locale, locale_state) unless dry_run
+    end
+
+    def keys_to_accept(source, target, locale_state, keys:, all:)
+      return keys.select { |key| source.key?(key) && target.key?(key) } if keys.any?
+      return target.keys.select { |key| source.key?(key) } if all
+
+      target.keys.select do |key|
+        entry = locale_state[key]
+        next false unless source.key?(key) && entry.is_a?(Hash) && !entry["manual"]
+
+        entry["target_hash"] && entry["target_hash"] != @state.hash(target[key])
+      end
+    end
+
+    def ensure_keys_matched!(keys, plans)
+      return if keys.empty?
+
+      matched = plans.flat_map { |_, _, _, accepted| accepted }
+      missing = keys - matched
+      return if missing.empty?
+
+      raise Error, "accept-edits: key(s) not found in any target locale: #{missing.join(", ")}"
+    end
+
     def translate_locale(source, target_locale, force:, force_keys:)
       log("Processing #{target_locale}...")
 
@@ -301,10 +339,15 @@ module Locallingo
       translations.each_key do |key|
         next unless source[key]
 
-        locale_state[key] = {
+        existing = locale_state[key]
+        entry = {
           "source_hash" => @state.hash(source[key]),
           "target_hash" => @state.hash(translations[key])
         }
+        # A force-keyed retranslation may overwrite a manual value on explicit
+        # request, but the protection flag itself must survive.
+        entry["manual"] = true if existing.is_a?(Hash) && existing["manual"]
+        locale_state[key] = entry
       end
     end
 

data/lib/locallingo/state_store.rb

@@ -40,8 +40,9 @@ module Locallingo
             "This would cause state loss. Fix the JSON manually or restore from git."
     end
 
-    # Save a locale's state, split back into per-namespace files. Namespace files
-    # that no longer have keys are removed.
+    # Save a locale's state, split back into per-namespace files. Files whose
+    # content is unchanged are left untouched so unrelated namespaces never
+    # churn in diffs. Namespace files that no longer have keys are removed.
     def save(locale, locale_state)
       by_namespace = locale_state.each_with_object({}) do |(key, value), groups|
         namespace = key.split(".").first
@@ -50,7 +51,10 @@ module Locallingo
 
       by_namespace.each do |namespace, keys|
         state_file = File.join(state_dir, "#{namespace}.#{locale}.json")
-        File.write(state_file, JSON.pretty_generate(keys.sort.to_h))
+        content = JSON.pretty_generate(keys.sort.to_h)
+        next if File.exist?(state_file) && File.read(state_file) == content
+
+        File.write(state_file, content)
       end
 
       Dir.glob(File.join(state_dir, "*.#{locale}.json")).each do |file|

data/lib/locallingo/validators/manual_edits.rb

@@ -30,7 +30,7 @@ module Locallingo
             type: :manual_edit,
             locale:,
             key:,
-            suggestion: "Value was hand-edited. Protect it: #{@cli_name} accept-edits --locale #{locale}"
+            suggestion: "Value was hand-edited. Protect it: #{@cli_name} accept-edits --locale #{locale} --key #{key}"
           }
         end
       end

data/lib/locallingo/validators/outdated.rb

@@ -19,7 +19,7 @@ module Locallingo
             type: :outdated,
             locale:,
             key:,
-            suggestion: "Source changed. Run: #{@cli_name} translate --locale #{locale} --force-key #{key}"
+            suggestion: suggestion_for(key, locale, locale_state)
           }
         end
       end
@@ -31,6 +31,19 @@ module Locallingo
           key if stored && stored != StateStore.hash(value)
         end
       end
+
+      private
+
+      # Manual keys must not be pushed toward machine retranslation — the value
+      # is hand-curated, so the human updates it and re-accepts.
+      def suggestion_for(key, locale, locale_state)
+        if locale_state.dig(key, "manual")
+          "Source changed for a manually-curated key. Update the #{locale} value by hand, " \
+            "then run: #{@cli_name} accept-edits --locale #{locale} --key #{key}"
+        else
+          "Source changed. Run: #{@cli_name} translate --locale #{locale} --force-key #{key}"
+        end
+      end
     end
   end
 end

data/lib/locallingo/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: locallingo
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Mikael Henriksson