feat: weblate

vendor/github.com/leonelquinteros/gotext/gotext.go

@@ -0,0 +1,427 @@
+/*
+Package gotext implements GNU gettext utilities.
+
+For quick/simple translations you can use the package level functions directly.
+
+	    import (
+		    "fmt"
+		    "github.com/leonelquinteros/gotext"
+	    )
+
+	    func main() {
+	        // Configure package
+	        gotext.Configure("/path/to/locales/root/dir", "en_UK", "domain-name")
+
+	        // Translate text from default domain
+	        fmt.Println(gotext.Get("My text on 'domain-name' domain"))
+
+	        // Translate text from a different domain without reconfigure
+	        fmt.Println(gotext.GetD("domain2", "Another text on a different domain"))
+	    }
+*/
+package gotext
+
+import (
+	"encoding/gob"
+	"strings"
+	"sync"
+)
+
+// Global environment variables
+type config struct {
+	sync.RWMutex
+
+	// Path to library directory where all locale directories and Translation files are.
+	library string
+
+	// Default domain to look at when no domain is specified. Used by package level functions.
+	domain string
+
+	// Language set.
+	languages []string
+
+	// Storage for package level methods
+	locales []*Locale
+}
+
+var globalConfig *config
+
+// FallbackLocale is the default language to be used when no language is set.
+var FallbackLocale = "en_US"
+
+func init() {
+	// Init default configuration
+	globalConfig = &config{
+		domain:    "default",
+		languages: []string{FallbackLocale},
+		library:   "/usr/local/share/locale",
+		locales:   nil,
+	}
+
+	// Register Translator types for gob encoding
+	gob.Register(TranslatorEncoding{})
+}
+
+// loadLocales creates a new Locale object for every language (specified using Configure)
+// at package level based on the configuration of global configuration .
+// It is called when trying to use Get or GetD methods.
+func loadLocales(rebuildCache bool) {
+	globalConfig.Lock()
+
+	if globalConfig.locales == nil || rebuildCache {
+		var locales []*Locale
+		for _, language := range globalConfig.languages {
+			locales = append(locales, NewLocale(globalConfig.library, language))
+		}
+		globalConfig.locales = locales
+	}
+
+	for _, locale := range globalConfig.locales {
+		if _, ok := locale.Domains[globalConfig.domain]; !ok || rebuildCache {
+			locale.AddDomain(globalConfig.domain)
+		}
+		locale.SetDomain(globalConfig.domain)
+	}
+
+	globalConfig.Unlock()
+}
+
+// GetDomain is the domain getter for the package configuration
+func GetDomain() string {
+	var dom string
+	globalConfig.RLock()
+	if globalConfig.locales != nil {
+		// All locales have the same domain
+		dom = globalConfig.locales[0].GetDomain()
+	}
+	if dom == "" {
+		dom = globalConfig.domain
+	}
+	globalConfig.RUnlock()
+
+	return dom
+}
+
+// SetDomain sets the name for the domain to be used at package level.
+// It reloads the corresponding Translation file.
+func SetDomain(dom string) {
+	globalConfig.Lock()
+	globalConfig.domain = dom
+	if globalConfig.locales != nil {
+		for _, locale := range globalConfig.locales {
+			locale.SetDomain(dom)
+		}
+	}
+	globalConfig.Unlock()
+
+	loadLocales(true)
+}
+
+// GetLanguage returns the language gotext will translate into.
+// If multiple languages have been supplied, the first one will be returned.
+// If no language has been supplied, the fallback will be returned.
+func GetLanguage() string {
+	languages := GetLanguages()
+	if len(languages) == 0 {
+		return FallbackLocale
+	}
+	return languages[0]
+}
+
+// GetLanguages returns all languages that have been supplied.
+func GetLanguages() []string {
+	globalConfig.RLock()
+	defer globalConfig.RUnlock()
+	return globalConfig.languages
+}
+
+// SetLanguage sets the language code (or colon separated language codes) to be used at package level.
+// It reloads the corresponding Translation file.
+func SetLanguage(lang string) {
+	globalConfig.Lock()
+	var languages []string
+	for _, language := range strings.Split(lang, ":") {
+		languages = append(languages, SimplifiedLocale(language))
+	}
+	globalConfig.languages = languages
+	globalConfig.Unlock()
+
+	loadLocales(true)
+}
+
+// GetLibrary is the library getter for the package configuration
+func GetLibrary() string {
+	globalConfig.RLock()
+	lib := globalConfig.library
+	globalConfig.RUnlock()
+
+	return lib
+}
+
+// SetLibrary sets the root path for the locale directories and files to be used at package level.
+// It reloads the corresponding Translation file.
+func SetLibrary(lib string) {
+	globalConfig.Lock()
+	globalConfig.library = lib
+	globalConfig.Unlock()
+
+	loadLocales(true)
+}
+
+// GetLocales returns the locales that have been set for the package configuration.
+func GetLocales() []*Locale {
+	globalConfig.RLock()
+	defer globalConfig.RUnlock()
+	return globalConfig.locales
+}
+
+// GetStorage is the locale storage getter for the package configuration.
+//
+// Deprecated: Storage has been renamed to Locale for consistency, use GetLocales instead.
+func GetStorage() *Locale {
+	locales := GetLocales()
+	if len(locales) > 0 {
+		return locales[0]
+	}
+	return nil
+}
+
+// SetLocales allows for overriding the global Locale objects with ones built manually with
+// NewLocale(). This makes it possible to attach custom Domain objects from in-memory po/mo.
+// The library, language and domain of the first Locale will set the default global configuration.
+func SetLocales(locales []*Locale) {
+	globalConfig.Lock()
+	defer globalConfig.Unlock()
+
+	globalConfig.locales = locales
+	globalConfig.library = locales[0].path
+	globalConfig.domain = locales[0].defaultDomain
+
+	var languages []string
+	for _, locale := range locales {
+		languages = append(languages, locale.lang)
+	}
+	globalConfig.languages = languages
+}
+
+// SetStorage allows overriding the global Locale object with one built manually with NewLocale().
+//
+// Deprecated: Storage has been renamed to Locale for consistency, use SetLocales instead.
+func SetStorage(locale *Locale) {
+	SetLocales([]*Locale{locale})
+}
+
+// Configure sets all configuration variables to be used at package level and reloads the corresponding Translation file.
+// It receives the library path, language code and domain name.
+// This function is recommended to be used when changing more than one setting,
+// as using each setter will introduce a I/O overhead because the Translation file will be loaded after each set.
+func Configure(lib, lang, dom string) {
+	globalConfig.Lock()
+	globalConfig.library = lib
+	var languages []string
+	for _, language := range strings.Split(lang, ":") {
+		languages = append(languages, SimplifiedLocale(language))
+	}
+	globalConfig.languages = languages
+	globalConfig.domain = dom
+	globalConfig.Unlock()
+
+	loadLocales(true)
+}
+
+// Get uses the default domain globally set to return the corresponding Translation of a given string.
+// Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
+func Get(str string, vars ...interface{}) string {
+	return GetD(GetDomain(), str, vars...)
+}
+
+// GetN retrieves the (N)th plural form of Translation for the given string in the default domain.
+// Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
+func GetN(str, plural string, n int, vars ...interface{}) string {
+	return GetND(GetDomain(), str, plural, n, vars...)
+}
+
+// GetD returns the corresponding Translation in the given domain for a given string.
+// Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
+func GetD(dom, str string, vars ...interface{}) string {
+	// Try to load default package Locales
+	loadLocales(false)
+
+	globalConfig.RLock()
+	defer globalConfig.RUnlock()
+
+	var tr string
+	for i, locale := range globalConfig.locales {
+		if _, ok := locale.Domains[dom]; !ok {
+			locale.AddDomain(dom)
+		}
+		if !locale.IsTranslatedD(dom, str) && i < (len(globalConfig.locales)-1) {
+			continue
+		}
+		tr = locale.GetD(dom, str, vars...)
+		break
+	}
+	return tr
+}
+
+// GetND retrieves the (N)th plural form of Translation in the given domain for a given string.
+// Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
+func GetND(dom, str, plural string, n int, vars ...interface{}) string {
+	// Try to load default package Locales
+	loadLocales(false)
+
+	globalConfig.RLock()
+	defer globalConfig.RUnlock()
+
+	var tr string
+	for i, locale := range globalConfig.locales {
+		if _, ok := locale.Domains[dom]; !ok {
+			locale.AddDomain(dom)
+		}
+		if !locale.IsTranslatedND(dom, str, n) && i < (len(globalConfig.locales)-1) {
+			continue
+		}
+		tr = locale.GetND(dom, str, plural, n, vars...)
+		break
+	}
+	return tr
+}
+
+// GetC uses the default domain globally set to return the corresponding Translation of the given string in the given context.
+// Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
+func GetC(str, ctx string, vars ...interface{}) string {
+	return GetDC(GetDomain(), str, ctx, vars...)
+}
+
+// GetNC retrieves the (N)th plural form of Translation for the given string in the given context in the default domain.
+// Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
+func GetNC(str, plural string, n int, ctx string, vars ...interface{}) string {
+	return GetNDC(GetDomain(), str, plural, n, ctx, vars...)
+}
+
+// GetDC returns the corresponding Translation in the given domain for the given string in the given context.
+// Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
+func GetDC(dom, str, ctx string, vars ...interface{}) string {
+	// Try to load default package Locales
+	loadLocales(false)
+
+	globalConfig.RLock()
+	defer globalConfig.RUnlock()
+
+	var tr string
+	for i, locale := range globalConfig.locales {
+		if !locale.IsTranslatedDC(dom, str, ctx) && i < (len(globalConfig.locales)-1) {
+			continue
+		}
+		tr = locale.GetDC(dom, str, ctx, vars...)
+		break
+	}
+	return tr
+}
+
+// GetNDC retrieves the (N)th plural form of Translation in the given domain for a given string.
+// Supports optional parameters (vars... interface{}) to be inserted on the formatted string using the fmt.Printf syntax.
+func GetNDC(dom, str, plural string, n int, ctx string, vars ...interface{}) string {
+	// Try to load default package Locales
+	loadLocales(false)
+
+	// Return Translation
+	globalConfig.RLock()
+	defer globalConfig.RUnlock()
+
+	var tr string
+	for i, locale := range globalConfig.locales {
+		if !locale.IsTranslatedNDC(dom, str, n, ctx) && i < (len(globalConfig.locales)-1) {
+			continue
+		}
+		tr = locale.GetNDC(dom, str, plural, n, ctx, vars...)
+		break
+	}
+	return tr
+}
+
+// IsTranslated reports whether a string is translated in given languages.
+// When the langs argument is omitted, the output of GetLanguages is used.
+func IsTranslated(str string, langs ...string) bool {
+	return IsTranslatedND(GetDomain(), str, 1, langs...)
+}
+
+// IsTranslatedN reports whether a plural string is translated in given languages.
+// When the langs argument is omitted, the output of GetLanguages is used.
+func IsTranslatedN(str string, n int, langs ...string) bool {
+	return IsTranslatedND(GetDomain(), str, n, langs...)
+}
+
+// IsTranslatedD reports whether a domain string is translated in given languages.
+// When the langs argument is omitted, the output of GetLanguages is used.
+func IsTranslatedD(dom, str string, langs ...string) bool {
+	return IsTranslatedND(dom, str, 1, langs...)
+}
+
+// IsTranslatedND reports whether a plural domain string is translated in any of given languages.
+// When the langs argument is omitted, the output of GetLanguages is used.
+func IsTranslatedND(dom, str string, n int, langs ...string) bool {
+	if len(langs) == 0 {
+		langs = GetLanguages()
+	}
+
+	loadLocales(false)
+
+	globalConfig.RLock()
+	defer globalConfig.RUnlock()
+
+	for _, lang := range langs {
+		lang = SimplifiedLocale(lang)
+
+		for _, supportedLocale := range globalConfig.locales {
+			if lang != supportedLocale.GetActualLanguage(dom) {
+				continue
+			}
+			return supportedLocale.IsTranslatedND(dom, str, n)
+		}
+	}
+	return false
+}
+
+// IsTranslatedC reports whether a context string is translated in given languages.
+// When the langs argument is omitted, the output of GetLanguages is used.
+func IsTranslatedC(str, ctx string, langs ...string) bool {
+	return IsTranslatedNDC(GetDomain(), str, 1, ctx, langs...)
+}
+
+// IsTranslatedNC reports whether a plural context string is translated in given languages.
+// When the langs argument is omitted, the output of GetLanguages is used.
+func IsTranslatedNC(str string, n int, ctx string, langs ...string) bool {
+	return IsTranslatedNDC(GetDomain(), str, n, ctx, langs...)
+}
+
+// IsTranslatedDC reports whether a domain context string is translated in given languages.
+// When the langs argument is omitted, the output of GetLanguages is used.
+func IsTranslatedDC(dom, str, ctx string, langs ...string) bool {
+	return IsTranslatedNDC(dom, str, 0, ctx, langs...)
+}
+
+// IsTranslatedNDC reports whether a plural domain context string is translated in any of given languages.
+// When the langs argument is omitted, the output of GetLanguages is used.
+func IsTranslatedNDC(dom, str string, n int, ctx string, langs ...string) bool {
+	if len(langs) == 0 {
+		langs = GetLanguages()
+	}
+
+	loadLocales(false)
+
+	globalConfig.RLock()
+	defer globalConfig.RUnlock()
+
+	for _, lang := range langs {
+		lang = SimplifiedLocale(lang)
+
+		for _, locale := range globalConfig.locales {
+			if lang != locale.GetActualLanguage(dom) {
+				continue
+			}
+			return locale.IsTranslatedNDC(dom, str, n, ctx)
+		}
+	}
+	return false
+}