func createBenchmarkTranslateFunc(b *testing.B, translationTemplate interface{}, count interface{}, expected string) func(data interface{}) {
bundle := New()
lang := "en-US"
translationID := "translation_id"
translation, err := translation.NewTranslation(map[string]interface{}{
"id": translationID,
"translation": translationTemplate,
})
if err != nil {
b.Fatal(err)
}
bundle.AddTranslation(languageWithTag(lang), translation)
tf, err := bundle.Tfunc(lang)
if err != nil {
b.Fatal(err)
}
return func(data interface{}) {
var result string
if count == nil {
result = tf(translationID, data)
} else {
result = tf(translationID, count, data)
}
if result != expected {
b.Fatalf("expected %q, got %q", expected, result)
}
}
}
func parseTranslationFile(filename string) ([]translation.Translation, error) {
var unmarshalFunc func([]byte, interface{}) error
switch format := filepath.Ext(filename); format {
case ".json":
unmarshalFunc = json.Unmarshal
/*
case ".yaml":
unmarshalFunc = goyaml.Unmarshal
*/
default:
return nil, fmt.Errorf("unsupported file extension %s", format)
}
fileBytes, err := ioutil.ReadFile(filename)
if err != nil {
return nil, err
}
var translationsData []map[string]interface{}
if len(fileBytes) > 0 {
if err := unmarshalFunc(fileBytes, &translationsData); err != nil {
return nil, err
}
}
translations := make([]translation.Translation, 0, len(translationsData))
for i, translationData := range translationsData {
t, err := translation.NewTranslation(translationData)
if err != nil {
return nil, fmt.Errorf("unable to parse translation #%d in %s because %s\n%v", i, filename, err, translationData)
}
translations = append(translations, t)
}
return translations, nil
}
func testNewTranslation(t *testing.T, data map[string]interface{}) translation.Translation {
translation, err := translation.NewTranslation(data)
if err != nil {
t.Fatal(err)
}
return translation
}
func (s *GoI18nSifter) Load() (StringMap, error) {
fileBytes, err := ioutil.ReadFile(s.json)
if err != nil {
return nil, err
}
var translationsData []map[string]interface{}
if len(fileBytes) > 0 {
if err := json.Unmarshal(fileBytes, &translationsData); err != nil {
return nil, err
}
}
translations := make([]translation.Translation, 0, len(translationsData))
for i, translationData := range translationsData {
t, err := translation.NewTranslation(translationData)
if err != nil {
return nil, fmt.Errorf("unable to parse translation #%d in %s because %s\n%v", i, s.json, err, translationData)
}
translations = append(translations, t)
}
result := make(StringMap)
for _, t := range translations {
result[t.ID()] = t
}
return result, nil
}
func createBenchmarkTranslateFunc(b *testing.B) func(data interface{}) {
bundle := New()
lang := "en-US"
translationID := "translation_id"
translation, err := translation.NewTranslation(map[string]interface{}{
"id": translationID,
"translation": map[string]interface{}{
"one": "{{.Person}} is {{.Count}} year old.",
"other": "{{.Person}} is {{.Count}} years old.",
},
})
if err != nil {
b.Fatal(err)
}
bundle.AddTranslation(languageWithTag(lang), translation)
expected := "Bob is 26 years old."
tf, err := bundle.Tfunc(lang)
if err != nil {
b.Fatal(err)
}
return func(data interface{}) {
if result := tf(translationID, 26, data); result != expected {
b.Fatalf("expected %q, got %q", expected, result)
}
}
}
func (s *GoI18nSifter) Filter(translated StringMap, sifted []*LocalizedString) StringMap {
untranslated := make(StringMap)
for _, xl := range sifted {
_, ok := translated[xl.String]
_, ok2 := untranslated[xl.String]
if !ok && !ok2 {
fmt.Printf("%s\n", xl.String)
t, err := translation.NewTranslation(map[string]interface{}{
"id": xl.String,
"translation": "",
})
if err != nil {
panic(err)
}
untranslated[xl.String] = t
}
}
return untranslated
}
// LoadJSON takes a json document of translations and manually
// loads them into the system
func LoadJSON(userLocale string, translationDocument string) error {
tracelog.Startedf("localize", "LoadJSON", "UserLocale[%s] Length[%d]", userLocale, len(translationDocument))
tranDocuments := []map[string]interface{}{}
err := json.Unmarshal([]byte(translationDocument), &tranDocuments)
if err != nil {
tracelog.CompletedErrorf(err, "localize", "LoadJSON", "**************>")
return err
}
for _, tranDocument := range tranDocuments {
tran, err := translation.NewTranslation(tranDocument)
if err != nil {
tracelog.CompletedError(err, "localize", "LoadJSON")
return err
}
i18n.AddTranslation(locale.MustNew(userLocale), tran)
}
tracelog.Completed("localize", "LoadJSON")
return nil
}
