func (b *Bundle) translatedLanguage(src string) *language.Language {
langs := language.Parse(src)
for _, lang := range langs {
if len(b.translations[lang.Tag]) > 0 {
return lang
}
}
return nil
}
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 supportedLanguages() []*language.Language {
assetNames := resources.AssetNames()
languages := []*language.Language{}
for _, assetName := range assetNames {
assetLocale := strings.TrimSuffix(path.Base(assetName), resourceSuffix)
languages = append(languages, language.Parse(assetLocale)...)
}
return languages
}
func IsSupportedLocale(locale string) bool {
for _, supportedLanguage := range supportedLanguages() {
for _, l := range language.Parse(locale) {
if supportedLanguage.String() == l.String() {
return true
}
}
}
return false
}
// GetFallbackLanguage tries to obtain a requested language via the session,
// or the Accept-Language request header, or the LANG or LC_MESSAGES
// environment variables
func GetFallbackLanguage(c context.Context, r *http.Request, fallback ...string) string {
if val, ok := c.Get(r, context.BaseCtxKey("session")); ok {
sess := val.(context.Session)
if language, ok := sess.Get("language"); ok {
return language.(string)
}
}
langs := lng.Parse(r.Header.Get("Accept-Language"))
if len(langs) > 0 {
return langs[0].String()
}
language := os.Getenv("LANG")
if language == "" {
language = os.Getenv("LC_MESSAGES")
language = localeRegexp.ReplaceAllLiteralString(language, "")
}
if language == "" {
if len(fallback) > 0 {
language = fallback[0]
} else {
language = "en"
}
} else {
langs := lng.Parse(language)
if len(langs) > 0 {
return langs[0].String()
}
}
return language
}
// ParseTranslationFileBytes is similar to LoadTranslationFile except it parses the bytes in buf.
//
// It is useful for parsing translation files embedded with go-bindata.
func (b *Bundle) ParseTranslationFileBytes(filename string, buf []byte) error {
basename := filepath.Base(filename)
langs := language.Parse(basename)
switch l := len(langs); {
case l == 0:
return fmt.Errorf("no language found in %q", basename)
case l > 1:
return fmt.Errorf("multiple languages found in filename %q: %v; expected one", basename, langs)
}
translations, err := parseTranslations(filename, buf)
if err != nil {
return err
}
b.AddTranslation(langs[0], translations...)
return nil
}
func Init(config core_config.Reader) go_i18n.TranslateFunc {
sources := []string{
config.Locale(),
os.Getenv(lcAll),
os.Getenv(lang),
defaultLocale,
}
assetNames := resources.AssetNames()
for _, source := range sources {
if source == "" {
continue
}
for _, l := range language.Parse(source) {
if l.Tag == zhTW || l.Tag == zhHK {
l.Tag = zhHant
}
for _, assetName := range assetNames {
assetLocale := strings.ToLower(strings.Replace(path.Base(assetName), underscore, hyphen, -1))
if strings.HasPrefix(assetLocale, l.Tag) {
assetBytes, err := resources.Asset(assetName)
if err != nil {
panic(fmt.Sprintf("Could not load asset '%s': %s", assetName, err.Error()))
}
err = go_i18n.ParseTranslationFileBytes(assetName, assetBytes)
if err != nil {
panic(fmt.Sprintf("Could not load translations '%s': %s", assetName, err.Error()))
}
T, err := go_i18n.Tfunc(source)
if err == nil {
return T
}
}
}
}
}
panic("Unable to find suitable translation")
}
func Init(config LocalReader) go_i18n.TranslateFunc {
loadAsset("cf/i18n/resources/" + defaultLocale + resourceSuffix)
defaultTfunc := go_i18n.MustTfunc(defaultLocale)
assetNames := resources.AssetNames()
sources := []string{
config.Locale(),
os.Getenv(lcAll),
os.Getenv(lang),
}
for _, source := range sources {
if source == "" {
continue
}
for _, l := range language.Parse(source) {
if l.Tag == zhTW || l.Tag == zhHK {
l.Tag = zhHant
}
for _, assetName := range assetNames {
assetLocale := strings.ToLower(strings.Replace(path.Base(assetName), underscore, hyphen, -1))
if strings.HasPrefix(assetLocale, l.Tag) {
loadAsset(assetName)
t := go_i18n.MustTfunc(source)
return func(translationID string, args ...interface{}) string {
if translated := t(translationID, args...); translated != translationID {
return translated
}
return defaultTfunc(translationID, args...)
}
}
}
}
}
return defaultTfunc
}
func getConfiguredLocal(config Config) (i18n.TranslateFunc, error) {
source := config.Locale()
assetNames := resources.AssetNames()
for _, l := range language.Parse(source) {
if l.Tag == zhTW || l.Tag == zhHK {
l.Tag = zhHant
}
for _, assetName := range assetNames {
assetLocale := strings.ToLower(strings.Replace(path.Base(assetName), underscore, hyphen, -1))
if strings.HasPrefix(assetLocale, l.Tag) {
err := loadAsset(assetName)
if err != nil {
return nil, err
}
return i18n.MustTfunc(l.Tag), nil
}
}
}
return nil, nil
}