taldir

loader.go (6657B)

---

 package i18n
 
 import (
 	"encoding/json"
 	"fmt"
 	"io"
 	"io/fs"
 	"os"
 	"path/filepath"
 	"strings"
 
 	"github.com/kataras/i18n/internal"
 
 	"github.com/BurntSushi/toml"
 	"gopkg.in/ini.v1"
 	"gopkg.in/yaml.v3"
 )
 
 // LoaderConfig the configuration structure which contains
 // some options about how the template loader should act.
 //
 // See `Glob` and `Assets` package-level functions.
 type LoaderConfig = internal.Options
 
 // Glob accepts a glob pattern (see: https://golang.org/pkg/path/filepath/#Glob)
 // and loads the locale files based on any "options".
 //
 // The "globPattern" input parameter is a glob pattern which the default loader should
 // search and load for locale files.
 //
 // See `New` and `LoaderConfig` too.
 func Glob(globPattern string, options ...LoaderConfig) Loader {
 	assetNames, err := filepath.Glob(globPattern)
 	if err != nil {
 		panic(err)
 	}
 
 	return load(assetNames, os.ReadFile, options...)
 }
 
 // FS is a virtual or local locale file system Loader.
 // It accepts embed.FS or fs.FS or http.FileSystem.
 // The "pattern" is a classic glob pattern.
 //
 // See `Glob`, `Assets`, `New` and `LoaderConfig` too.
 func FS(fileSystem fs.FS, pattern string, options ...LoaderConfig) (Loader, error) {
 	pattern = strings.TrimPrefix(pattern, "./")
 
 	assetNames, err := fs.Glob(fileSystem, pattern)
 	if err != nil {
 		return nil, err
 	}
 
 	assetFunc := func(name string) ([]byte, error) {
 		f, err := fileSystem.Open(name)
 		if err != nil {
 			return nil, err
 		}
 
 		return io.ReadAll(f)
 	}
 
 	return load(assetNames, assetFunc, options...), nil
 }
 
 // Assets accepts a function that returns a list of filenames (physical or virtual),
 // another a function that should return the contents of a specific file
 // and any Loader options. Go-bindata usage.
 // It returns a valid `Loader` which loads and maps the locale files.
 //
 // See `Glob`, `Assets`, `New` and `LoaderConfig` too.
 func Assets(assetNames func() []string, asset func(string) ([]byte, error), options ...LoaderConfig) Loader {
 	return load(assetNames(), asset, options...)
 }
 
 // LangMap key as language (e.g. "el-GR") and value as a map of key-value pairs (e.g. "hello": "Γειά").
 type LangMap = map[string]Map
 
 // KV is a loader which accepts a map of language(key) and the available key-value pairs.
 // Example Code:
 //
 //	m := LangMap{
 //		"en-US": Map{
 //			"hello": "Hello",
 //		},
 //		"el-GR": Map{
 //			"hello": "Γειά",
 //		},
 //	}
 //
 // loader := KV(m, i18n.DefaultLoaderConfig)
 // I18n, err := New(loader)
 // I18N.SetDefault("en-US")
 func KV(langMap LangMap, opts ...LoaderConfig) Loader {
 	return func(m *Matcher) (Localizer, error) {
 		options := DefaultLoaderConfig
 		if len(opts) > 0 {
 			options = opts[0]
 		}
 
 		languageIndexes := make([]int, 0, len(langMap))
 		keyValuesMulti := make([]Map, 0, len(langMap))
 
 		for languageName, pairs := range langMap {
 			langIndex := parseLanguageName(m, languageName) // matches and adds the language tag to m.Languages.
 			languageIndexes = append(languageIndexes, langIndex)
 			keyValuesMulti = append(keyValuesMulti, pairs)
 		}
 
 		cat, err := internal.NewCatalog(m.Languages, options)
 		if err != nil {
 			return nil, err
 		}
 
 		for _, langIndex := range languageIndexes {
 			if langIndex == -1 {
 				// If loader has more languages than defined for use in New function,
 				// e.g. when New(KV(m), "en-US") contains el-GR and en-US but only "en-US" passed.
 				continue
 			}
 
 			kv := keyValuesMulti[langIndex]
 			err := cat.Store(langIndex, kv)
 			if err != nil {
 				return nil, err
 			}
 		}
 
 		if n := len(cat.Locales); n == 0 {
 			return nil, fmt.Errorf("locales not found in map")
 		} else if options.Strict && n < len(m.Languages) {
 			return nil, fmt.Errorf("locales expected to be %d but %d parsed", len(m.Languages), n)
 		}
 
 		return cat, nil
 	}
 }
 
 // DefaultLoaderConfig represents the default loader configuration.
 var DefaultLoaderConfig = LoaderConfig{
 	Left:               "{{",
 	Right:              "}}",
 	Strict:             false,
 	DefaultMessageFunc: nil,
 	PluralFormDecoder:  internal.DefaultPluralFormDecoder,
 	Funcs:              nil,
 }
 
 // load accepts a list of filenames (physical or virtual),
 // a function that should return the contents of a specific file
 // and any Loader options.
 // It returns a valid `Loader` which loads and maps the locale files.
 //
 // See `FS`, Glob`, `Assets` and `LoaderConfig` too.
 func load(assetNames []string, asset func(string) ([]byte, error), opts ...LoaderConfig) Loader {
 	return func(m *Matcher) (Localizer, error) {
 		languageFiles, err := m.ParseLanguageFiles(assetNames)
 		if err != nil {
 			return nil, err
 		}
 
 		options := DefaultLoaderConfig
 
 		if len(opts) > 0 {
 			options = opts[0]
 		}
 
 		if options.DefaultMessageFunc == nil {
 			options.DefaultMessageFunc = m.defaultMessageFunc
 		}
 
 		cat, err := internal.NewCatalog(m.Languages, options)
 		if err != nil {
 			return nil, err
 		}
 
 		for langIndex, langFiles := range languageFiles {
 			keyValues := make(map[string]interface{})
 
 			for _, fileName := range langFiles {
 				unmarshal := yaml.Unmarshal
 				if idx := strings.LastIndexByte(fileName, '.'); idx > 1 {
 					switch fileName[idx:] {
 					case ".toml", ".tml":
 						unmarshal = toml.Unmarshal
 					case ".json":
 						unmarshal = json.Unmarshal
 					case ".ini":
 						unmarshal = unmarshalINI
 					}
 				}
 
 				b, err := asset(fileName)
 				if err != nil {
 					return nil, err
 				}
 
 				if err = unmarshal(b, &keyValues); err != nil {
 					return nil, err
 				}
 			}
 
 			err = cat.Store(langIndex, keyValues)
 			if err != nil {
 				return nil, err
 			}
 		}
 
 		if n := len(cat.Locales); n == 0 {
 			return nil, fmt.Errorf("locales not found in %s", strings.Join(assetNames, ", "))
 		} else if options.Strict && n < len(m.Languages) {
 			return nil, fmt.Errorf("locales expected to be %d but %d parsed", len(m.Languages), n)
 		}
 
 		return cat, nil
 	}
 }
 
 func unmarshalINI(data []byte, v interface{}) error {
 	f, err := ini.Load(data)
 	if err != nil {
 		return err
 	}
 
 	m := *v.(*map[string]interface{})
 
 	// Includes the ini.DefaultSection which has the root keys too.
 	// We don't have to iterate to each section to find the subsection,
 	// the Sections() returns all sections, sub-sections are separated by dot '.'
 	// and we match the dot with a section on the translate function, so we just save the values as they are,
 	// so we don't have to do section lookup on every translate call.
 	for _, section := range f.Sections() {
 		keyPrefix := ""
 		if name := section.Name(); name != ini.DefaultSection {
 			keyPrefix = name + "."
 		}
 
 		for _, key := range section.Keys() {
 			m[keyPrefix+key.Name()] = key.Value()
 		}
 	}
 
 	return nil
 }