1
0
mirror of https://github.com/go-gitea/gitea.git synced 2024-12-04 14:46:57 -05:00
gitea/vendor/github.com/unknwon/i18n/i18n.go

232 lines
5.2 KiB
Go
Raw Normal View History

2016-11-03 18:16:01 -04:00
// Copyright 2013 Unknwon
//
// Licensed under the Apache License, Version 2.0 (the "License"): you may
// not use this file except in compliance with the License. You may obtain
// a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
// License for the specific language governing permissions and limitations
// under the License.
// Package i18n is for app Internationalization and Localization.
package i18n
import (
"errors"
"fmt"
"reflect"
"strings"
"gopkg.in/ini.v1"
)
var (
ErrLangAlreadyExist = errors.New("Lang already exists")
locales = &localeStore{store: make(map[string]*locale)}
)
type locale struct {
id int
lang string
langDesc string
message *ini.File
}
type localeStore struct {
langs []string
langDescs []string
store map[string]*locale
defaultLang string
}
// Get target language string
func (d *localeStore) Get(lang, section, format string) (string, bool) {
if locale, ok := d.store[lang]; ok {
if key, err := locale.message.Section(section).GetKey(format); err == nil {
return key.Value(), true
}
}
if len(d.defaultLang) > 0 && lang != d.defaultLang {
return d.Get(d.defaultLang, section, format)
}
return "", false
}
func (d *localeStore) Add(lc *locale) bool {
if _, ok := d.store[lc.lang]; ok {
return false
}
lc.id = len(d.langs)
d.langs = append(d.langs, lc.lang)
d.langDescs = append(d.langDescs, lc.langDesc)
d.store[lc.lang] = lc
return true
}
func (d *localeStore) Reload(langs ...string) (err error) {
if len(langs) == 0 {
for _, lc := range d.store {
if err = lc.message.Reload(); err != nil {
return err
}
}
} else {
for _, lang := range langs {
if lc, ok := d.store[lang]; ok {
if err = lc.message.Reload(); err != nil {
return err
}
}
}
}
return nil
}
// SetDefaultLang sets default language which is a indicator that
// when target language is not found, try find in default language again.
func SetDefaultLang(lang string) {
locales.defaultLang = lang
}
// ReloadLangs reloads locale files.
func ReloadLangs(langs ...string) error {
return locales.Reload(langs...)
}
// Count returns number of languages that are registered.
func Count() int {
return len(locales.langs)
}
// ListLangs returns list of all locale languages.
func ListLangs() []string {
langs := make([]string, len(locales.langs))
copy(langs, locales.langs)
return langs
}
func ListLangDescs() []string {
langDescs := make([]string, len(locales.langDescs))
copy(langDescs, locales.langDescs)
return langDescs
}
// IsExist returns true if given language locale exists.
func IsExist(lang string) bool {
_, ok := locales.store[lang]
return ok
}
// IndexLang returns index of language locale,
// it returns -1 if locale not exists.
func IndexLang(lang string) int {
if lc, ok := locales.store[lang]; ok {
return lc.id
}
return -1
}
// GetLangByIndex return language by given index.
func GetLangByIndex(index int) string {
if index < 0 || index >= len(locales.langs) {
return ""
}
return locales.langs[index]
}
func GetDescriptionByIndex(index int) string {
if index < 0 || index >= len(locales.langDescs) {
return ""
}
return locales.langDescs[index]
}
func GetDescriptionByLang(lang string) string {
return GetDescriptionByIndex(IndexLang(lang))
}
func SetMessageWithDesc(lang, langDesc string, localeFile interface{}, otherLocaleFiles ...interface{}) error {
message, err := ini.LoadSources(ini.LoadOptions{
IgnoreInlineComment: true,
UnescapeValueCommentSymbols: true,
}, localeFile, otherLocaleFiles...)
2016-11-03 18:16:01 -04:00
if err == nil {
message.BlockMode = false
lc := new(locale)
lc.lang = lang
lc.langDesc = langDesc
lc.message = message
if locales.Add(lc) == false {
return ErrLangAlreadyExist
}
}
return err
}
// SetMessage sets the message file for localization.
func SetMessage(lang string, localeFile interface{}, otherLocaleFiles ...interface{}) error {
return SetMessageWithDesc(lang, lang, localeFile, otherLocaleFiles...)
}
// Locale represents the information of localization.
type Locale struct {
Lang string
}
// Tr translates content to target language.
func (l Locale) Tr(format string, args ...interface{}) string {
return Tr(l.Lang, format, args...)
}
// Index returns lang index of LangStore.
func (l Locale) Index() int {
return IndexLang(l.Lang)
}
// Tr translates content to target language.
func Tr(lang, format string, args ...interface{}) string {
var section string
idx := strings.IndexByte(format, '.')
if idx > 0 {
section = format[:idx]
format = format[idx+1:]
2016-11-03 18:16:01 -04:00
}
value, ok := locales.Get(lang, section, format)
if ok {
format = value
}
if len(args) > 0 {
params := make([]interface{}, 0, len(args))
for _, arg := range args {
if arg == nil {
continue
}
val := reflect.ValueOf(arg)
if val.Kind() == reflect.Slice {
for i := 0; i < val.Len(); i++ {
params = append(params, val.Index(i).Interface())
2016-11-03 18:16:01 -04:00
}
} else {
params = append(params, arg)
2016-11-03 18:16:01 -04:00
}
}
return fmt.Sprintf(format, params...)
}
return format
}