i18n sync of locals yaml keys

Question

Similar question, but for java, Keeping i18n resources synced

How to keep the i18n yaml locals' keys in sync? i.e. when a key is added to en.yml, how to get those to nb.yml or ru.yml?

if I add the key my_label: "some text in english" next to my_title: "a title" I'd like to get this to my other locals I specify, as I can't do all translations and it should fall back to english in other languages

e.g en.yml

somegroup:
  my_tile: "a title in english"
  my_label: "some text in english"
othergroup:
  ...

I'd like go issue a command and get the whole key and value inject into the norwegian translation and the corresponding position, if missing. Then git diff would show all translations to do in this language.

nb.yml

 somegroup:
   my_tile: "En tittel på norsk"
+  my_label: "some text in english"
 othergroup:
   ...

Are there any gems that do something like this? If you think it's a good idea, maybe I should take the time to make it myself. Other approaches?

Answer 1

Try the i18n_translation_spawner gem, it could be helpful.

Answer 2

I will check i18n_translation_spawner gem. In case that someone needs a not-so-fast but do the job, i use this script:

First we extend the Hash class in order to support deep_merge and to replace all their leaf values with some string.

require 'yaml'
class Hash
   def deep_merge(hash)
      target = dup

      hash.keys.each do |key|
         if hash[key].is_a? Hash and self[key].is_a? Hash
            target[key] = target[key].deep_merge(hash[key])
            next
         end
         target[key] = hash[key]
      end
      target
   end

   def fill_all_values value
      each_key do |key|
         if self[key].is_a?(String)
            store(key,value)
         else
            self[key].fill_all_values value
         end
      end
   end
end

Now we can use our merger of translations:

def merge_yaml_i18n_files(locale_code_A,locale_code_B,untranslated_message)
   hash_A = YAML.load_file("i18n/#{locale_code_A}.yml")
   hash_B = YAML.load_file("i18n/#{locale_code_B}.yml")

   hash_A_ut = Marshal.load(Marshal.dump(hash_A))
   hash_A_ut.fill_all_values(untranslated_message)

   hash_B_ut = Marshal.load(Marshal.dump(hash_B))
   hash_B_ut.fill_all_values(untranslated_message)

   hash_A = hash_B_ut.deep_merge(hash_A)
   hash_B = hash_A_ut.deep_merge(hash_B)

   puts hash_A.to_yaml
   puts hash_B.to_yaml
end

And finally, we call this method with:

merge_yaml_i18n_files('en','es','untranslated')

If we apply this function in the following i18n files:

es.yaml
test:
   hello: Hola
   only_es: abc

en.yaml
test:
   hello: Hello
   only_en: def

The result will be:

es.yaml
test:
   hello: Hola
   only_en: untranslated
   only_es: abc

en.yaml
test:
   hello: Hello
   only_en: def
   only_es: untranslated

Answer 3

You can use i18n-tasks gem for this.

It scans calls such as I18n.t('some.key') and provides reports on key usage, missing, and unused keys. It can also can pre-fill missing keys, including from Google Translate, and it can remove unused keys as well.