i18n sync of locals yaml keys

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?

Try the i18n_translation_spawner gem, it could be helpful.

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

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.