// LoadTranslationFile loads the translations from filename in a specific namespace.
//
// The language that the translations are associated with is parsed from the filename (e.g. en-US.json).
//
// Generally you should load translation files once during your program's initialization.
func LoadTranslationFile(namespace string, filename string) error {
bundle := defaultbundles[namespace]
if bundle == nil {
return fmt.Errorf("there is no namespace %s", namespace)
}
return bundle.LoadTranslationFile(filename)
}
func (mc *mergeCommand) execute() error {
if len(mc.translationFiles) < 1 {
return fmt.Errorf("need at least one translation file to parse")
}
if lang := language.Parse(mc.sourceLanguage); lang == nil {
return fmt.Errorf("invalid source locale: %s", mc.sourceLanguage)
}
marshal, err := newMarshalFunc(mc.format)
if err != nil {
return err
}
bundle := bundle.New()
for _, tf := range mc.translationFiles {
if err := bundle.LoadTranslationFile(tf); err != nil {
return fmt.Errorf("failed to load translation file %s because %s\n", tf, err)
}
}
translations := bundle.Translations()
sourceLanguageTag := language.NormalizeTag(mc.sourceLanguage)
sourceTranslations := translations[sourceLanguageTag]
if sourceTranslations == nil {
return fmt.Errorf("no translations found for source locale %s", sourceLanguageTag)
}
for translationID, src := range sourceTranslations {
for _, localeTranslations := range translations {
if dst := localeTranslations[translationID]; dst == nil || reflect.TypeOf(src) != reflect.TypeOf(dst) {
localeTranslations[translationID] = src.UntranslatedCopy()
}
}
}
for localeID, localeTranslations := range translations {
lang := language.MustParse(localeID)[0]
all := filter(localeTranslations, func(t translation.Translation) translation.Translation {
return t.Normalize(lang)
})
if err := mc.writeFile("all", all, localeID, marshal); err != nil {
return err
}
untranslated := filter(localeTranslations, func(t translation.Translation) translation.Translation {
if t.Incomplete(lang) {
return t.Normalize(lang).Backfill(sourceTranslations[t.ID()])
}
return nil
})
if err := mc.writeFile("untranslated", untranslated, localeID, marshal); err != nil {
return err
}
}
return nil
}
func (cc *constantsCommand) execute() error {
if len(cc.translationFiles) != 1 {
return fmt.Errorf("need one translation file")
}
bundle := bundle.New()
if err := bundle.LoadTranslationFile(cc.translationFiles[0]); err != nil {
return fmt.Errorf("failed to load translation file %s because %s\n", cc.translationFiles[0], err)
}
translations := bundle.Translations()
lang := translations[bundle.LanguageTags()[0]]
// create an array of id to organize
keys := make([]string, len(lang))
i := 0
for id := range lang {
keys[i] = id
i++
}
sort.Strings(keys)
tmpl := &templateHeader{
PackageName: cc.packageName,
Constants: make([]templateConstants, len(keys)),
}
for i, id := range keys {
tmpl.Constants[i].ID = id
tmpl.Constants[i].Name = toCamelCase(id)
tmpl.Constants[i].Comments = toComments(lang[id])
}
filename := filepath.Join(cc.outdir, cc.packageName+".go")
f, err := os.Create(filename)
if err != nil {
return fmt.Errorf("failed to create file %s because %s", filename, err)
}
defer f.Close()
if err = constTemplate.Execute(f, tmpl); err != nil {
return fmt.Errorf("failed to write file %s because %s", filename, err)
}
return nil
}