#237 return i18n key instead of empty string and #239 implemented i18n interface (#241)

Author: jeevatkm

aah.go

@@ -116,7 +116,7 @@ type Application struct {
 	router         *router.Router
 	eventStore     *EventStore
 	bindMgr        *bindManager
-	i18n           *i18n.I18n
+	i18n           i18n.I18ner
 	securityMgr    *security.Manager
 	viewMgr        *viewManager
 	staticMgr      *staticManager
@@ -739,15 +739,23 @@ func (a *Application) initLog() error {
 
 const keyLocale = "Locale"
 
+// RegisterI18n method is used to register the i18n message store
+// into aah appplication the implements interface `i18n.I18ner`.
+func (a *Application) RegisterI18n(ms i18n.I18ner) {
+	a.Lock()
+	defer a.Unlock()
+	a.i18n = ms
+}
+
 // I18n method returns aah application I18n store instance.
-func (a *Application) I18n() *i18n.I18n {
+func (a *Application) I18n() i18n.I18ner {
 	return a.i18n
 }
 
 // DefaultI18nLang method returns application i18n default language if
 // configured otherwise framework defaults to "en".
 func (a *Application) DefaultI18nLang() string {
-	return a.Config().StringDefault("i18n.default", "en")
+	return a.I18n().DefaultLocale()
 }
 
 func (a *Application) initI18n() error {
@@ -756,14 +764,16 @@ func (a *Application) initI18n() error {
 		// i18n directory not exists, scenario could be only API application
 		return nil
 	}
-
-	ai18n := i18n.NewWithVFS(a.VFS())
-	ai18n.DefaultLocale = a.DefaultI18nLang()
-	if err := ai18n.Load(i18nPath); err != nil {
+	ai18n := i18n.New(
+		a.Log(),
+		i18n.DefaultLocale(a.Config().StringDefault("i18n.default", "en")),
+		i18n.VFS(a.VFS()),
+		i18n.Dirs(i18nPath),
+	)
+	if err := ai18n.Init(); err != nil {
 		return err
 	}
-
-	a.i18n = ai18n
+	a.RegisterI18n(ai18n)
 	return nil
 }
 

i18n/i18n.go

@@ -3,16 +3,18 @@
 // license that can be found in the LICENSE file.
 
 // Package i18n is internationalization and localization support for aah
-// framework. Messages config format is `forge` config syntax (go-aah/config)
-// which is similar to HOCON syntax aka typesafe config.
+// framework. Messages store config format is same as aah configuration.
+// Refer to https://docs.aahframework.org/configuration.html.
 //
 // Message filename format is `message.<Language-ID>`. Language ID is combination
 // of `Language + Region` or `Language` value. aah framework implements Language
 // code is as per two-letter `ISO 639-1` standard and Region code is as per two-letter
 // `ISO 3166-1` standard.
 //
 // Supported message file extension formats are (incasesensitive)
+//
 // 	1) Language + Region => en-us | en-US
+//
 // 	2) Language          => en
 //
 // 	For Example:
@@ -34,73 +36,123 @@ import (
 	"path/filepath"
 	"regexp"
 	"strings"
+	"sync"
 
 	"aahframe.work/ahttp"
 	"aahframe.work/config"
-	"aahframe.work/essentials"
 	"aahframe.work/log"
 	"aahframe.work/vfs"
 )
 
+// I18ner interface is used to implement i18n message store.
+type I18ner interface {
+	Lookup(locale *ahttp.Locale, key string, args ...interface{}) string
+	DefaultLocale() string
+	Locales() []string
+}
+
 //‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
 // Package methods
 //______________________________________________________________________________
 
-// New method creates aah i18n message store
-func New() *I18n {
-	return NewWithVFS(nil)
-}
-
-// NewWithVFS method creates aah i18n message store with given Virtual FileSystem.
-func NewWithVFS(fs *vfs.VFS) *I18n {
-	return &I18n{
-		Store:        make(map[string]*config.Config),
-		fileExtRegex: `messages\.[a-z]{2}(\-[a-zA-Z]{2})?$`,
-		vfs:          fs,
+// New method creates aah i18n message store with given options.
+func New(l log.Loggerer, opts ...Option) *I18n {
+	msgStore := &I18n{
+		RWMutex:       sync.RWMutex{},
+		store:         make(map[string]*config.Config),
+		fileExtRegex:  regexp.MustCompile(`messages\.[a-z]{2}(\-[a-zA-Z]{2})?$`),
+		defaultLocale: "en",
+		files:         make([]string, 0),
+		log:           l,
 	}
+	for _, opt := range opts {
+		opt(msgStore)
+	}
+	return msgStore
 }
 
 //‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
-// I18n methods
+// I18n options type and methods
 //______________________________________________________________________________
 
-// I18n holds the message store and related information for internationalization
-// and localization.
-type I18n struct {
-	Store         map[string]*config.Config
-	DefaultLocale string
+// Option type to provide configuration options
+// to create i18n message store.
+type Option func(*I18n)
 
-	fileExtRegex string
-	vfs          *vfs.VFS
+// DefaultLocale option func is to message store default locale.
+func DefaultLocale(locale string) Option {
+	return func(i *I18n) {
+		i.Lock()
+		defer i.Unlock()
+		i.defaultLocale = locale
+	}
 }
 
-// Load processes the given message file or directory and adds to the
-// message store
-func (s *I18n) Load(paths ...string) error {
-	for _, path := range paths {
-		if !vfs.IsExists(s.vfs, path) {
-			log.Warnf("Path: %v not exists, let's move on", path)
-			continue
-		}
+// Dirs option func is to set aah VFS instance.
+func VFS(fs vfs.FileSystem) Option {
+	return func(i *I18n) {
+		i.Lock()
+		defer i.Unlock()
+		i.fs = fs
+	}
+}
 
-		if s.isDir(path) {
-			_ = vfs.Walk(s.vfs, path, func(fpath string, f os.FileInfo, _ error) error {
-				if !f.IsDir() {
-					match, err := regexp.MatchString(s.fileExtRegex, f.Name())
-					if err == nil && match {
-						s.processMsgFile(fpath)
+// Dirs option func is to supply n no. of directory path.
+func Dirs(dirs ...string) Option {
+	return func(i *I18n) {
+		i.Lock()
+		defer i.Unlock()
+		for _, d := range dirs {
+			if !vfs.IsDir(i.fs, d) {
+				i.log.Warnf("i18n: %v not exists or error, let's move on", d)
+				continue
+			}
+			_ = vfs.Walk(i.fs, d, func(fpath string, fi os.FileInfo, _ error) error {
+				if !fi.IsDir() {
+					if i.fileExtRegex.MatchString(fi.Name()) {
+						i.files = append(i.files, fpath)
 					}
 				}
 				return nil
 			})
-		} else { // if it's a file
-			s.processMsgFile(path)
 		}
 	}
+}
 
-	return nil
+// Files option func is to supply n no. of file path.
+func Files(files ...string) Option {
+	return func(i *I18n) {
+		i.Lock()
+		defer i.Unlock()
+		for _, f := range files {
+			if !vfs.IsExists(i.fs, f) {
+				i.log.Warnf("i18n: %v not exists, let's move on", f)
+				continue
+			}
+			i.files = append(i.files, f)
+		}
+	}
 }
 
+//‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
+// I18n methods
+//______________________________________________________________________________
+
+// I18n holds the message store and related information for internationalization
+// and localization.
+type I18n struct {
+	sync.RWMutex
+	store         map[string]*config.Config
+	defaultLocale string
+	files         []string
+	fileExtRegex  *regexp.Regexp
+	fs            vfs.FileSystem
+	log           log.Loggerer
+}
+
+// interface check
+var _ I18ner = (*I18n)(nil)
+
 // Lookup returns value by given key, locale and it supports formatting a message
 // before its return. If given message key or store doesn't exists for given locale;
 // Lookup method returns empty string.
@@ -109,82 +161,104 @@ func (s *I18n) Load(paths ...string) error {
 // 	* language and region-id (e.g.: en-US)
 // 	* language (e.g.: en)
 func (s *I18n) Lookup(locale *ahttp.Locale, key string, args ...interface{}) string {
+	s.RLock()
+	defer s.RUnlock()
 	// assign default locale if nil
 	if locale == nil {
-		locale = ahttp.NewLocale(s.DefaultLocale)
+		locale = ahttp.NewLocale(s.defaultLocale)
 	}
 
 	// Lookup by language and region-id. For eg.: en-us
 	store := s.findStoreByLocale(locale.String())
 	if store == nil {
-		log.Tracef("Locale (%v) doesn't exists in message store", locale)
 		goto langStore
 	}
-	log.Tracef("Message is retrieved from locale: %v, key: %v", locale, key)
 	if msg, found := retriveValue(store, key, args...); found {
+		s.log.Tracef("i18n message is retrieved from locale: %v, key: %v", locale, key)
 		return msg
 	}
 
 langStore:
+	// Lookup by language. For eg.: en
 	store = s.findStoreByLocale(locale.Language)
 	if store == nil {
-		log.Tracef("Locale (%v) doesn't exists in message store", locale.Language)
 		goto defaultStore
 	}
-	log.Tracef("Message is retrieved from locale: %v, key: %v", locale.Language, key)
 	if msg, found := retriveValue(store, key, args...); found {
+		s.log.Tracef("i18n message is retrieved from locale: %v, key: %v", locale.Language, key)
 		return msg
 	}
 
 defaultStore: // fallback to `i18n.default` config value.
-	store = s.findStoreByLocale(s.DefaultLocale)
+	store = s.findStoreByLocale(s.defaultLocale)
 	if store == nil {
 		goto notExists
 	}
-	log.Tracef("Message is retrieved with 'i18n.default': %v, key: %v", s.DefaultLocale, key)
 	if msg, found := retriveValue(store, key, args...); found {
+		s.log.Tracef("i18n message is retrieved from locale: %v, key: %v", s.defaultLocale, key)
 		return msg
 	}
 
 notExists:
-	log.Warnf("i18n key not found: %s", key)
-	return ""
+	return key
+}
+
+// DefaultLocale method returns the i18n store's default locale.
+func (s *I18n) DefaultLocale() string {
+	s.RLock()
+	defer s.RUnlock()
+	return s.defaultLocale
 }
 
 // Locales returns all the loaded locales from message store
 func (s *I18n) Locales() []string {
+	s.RLock()
+	defer s.RUnlock()
 	var locales []string
-	for l := range s.Store {
+	for l := range s.store {
 		locales = append(locales, l)
 	}
 	return locales
 }
 
+// Load method loads message files into message store.
+// Returns error for any failures.
+func (s *I18n) Init() error {
+	for _, f := range s.files {
+		if err := s.add2Store(f); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
 //‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
 // I18n Unexported methods
 //______________________________________________________________________________
 
-func (s *I18n) processMsgFile(file string) {
+func (s *I18n) add2Store(file string) error {
 	key := strings.ToLower(filepath.Ext(file)[1:])
+	s.log.Tracef("Adding into i18n message store [%v: %v]", key, file)
 	msgFile, err := config.LoadFile(file)
 	if err != nil {
-		log.Errorf("Unable to load message file: %v, error: %v", file, err)
+		return fmt.Errorf("i18n: unable to process message file: %v, error: %v", file, err)
 	}
 
 	// merge messages if key is already exists otherwise add it
-	if ms, exists := s.Store[key]; exists {
-		log.Tracef("Key[%v] is already exists, let's merge it", key)
+	s.Lock()
+	defer s.Unlock()
+	if ms, exists := s.store[key]; exists {
 		if err = ms.Merge(msgFile); err != nil {
-			log.Errorf("Error while merging message file: %v", file)
+			return fmt.Errorf("i18n: error while adding into message store file: %v", file)
 		}
 	} else {
-		log.Tracef("Adding to message store [%v: %v]", key, file)
-		s.Store[key] = msgFile
+		s.store[key] = msgFile
 	}
+	return nil
 }
 
 func (s *I18n) findStoreByLocale(locale string) *config.Config {
-	if store, exists := s.Store[strings.ToLower(locale)]; exists {
+	if store, exists := s.store[strings.ToLower(locale)]; exists {
 		return store
 	}
 	return nil
@@ -201,17 +275,5 @@ func retriveValue(store *config.Config, key string, args ...interface{}) (string
 		}
 		return msg, found
 	}
-	return "", false
-}
-
-func (s *I18n) isDir(name string) bool {
-	if s.vfs == nil {
-		return ess.IsDir(name)
-	}
-
-	fi, err := s.vfs.Lstat(name)
-	if err != nil {
-		return false
-	}
-	return fi.IsDir()
+	return key, false
 }