Upgrade to go 1.19 and update dependencies (#3069)

* Update to go 1.19
* Update dependencies
* Update cross-compile script
* Add missing targets to cross-compile-all
* Update cache action to remove warning

vendor/github.com/asticode/go-astikit/translator.go

@@ -7,32 +7,42 @@ import (
 	"net/http"
 	"os"
 	"path/filepath"
+	"sort"
+	"strconv"
 	"strings"
 	"sync"
 )
 
 // Translator represents an object capable of translating stuff
 type Translator struct {
-	m *sync.RWMutex // Lock p
-	o TranslatorOptions
-	p map[string]string
+	defaultLanguage string
+	m               *sync.RWMutex // Lock p
+	p               map[string]string
+	validLanguages  map[string]bool
 }
 
 // TranslatorOptions represents Translator options
 type TranslatorOptions struct {
 	DefaultLanguage string
+	ValidLanguages  []string
 }
 
 // NewTranslator creates a new Translator
-func NewTranslator(o TranslatorOptions) *Translator {
-	return &Translator{
-		m: &sync.RWMutex{},
-		o: o,
-		p: make(map[string]string),
+func NewTranslator(o TranslatorOptions) (t *Translator) {
+	t = &Translator{
+		defaultLanguage: o.DefaultLanguage,
+		m:               &sync.RWMutex{},
+		p:               make(map[string]string),
+		validLanguages:  make(map[string]bool),
 	}
+	for _, l := range o.ValidLanguages {
+		t.validLanguages[l] = true
+	}
+	return
 }
 
 // ParseDir adds translations located in ".json" files in the specified dir
+// If ".json" files are located in child dirs, keys will be prefixed with their paths
 func (t *Translator) ParseDir(dirPath string) (err error) {
 	// Default dir path
 	if dirPath == "" {
@@ -50,11 +60,8 @@ func (t *Translator) ParseDir(dirPath string) (err error) {
 			return
 		}
 
-		// Only process first level files
+		// Only process files
 		if info.IsDir() {
-			if path != dirPath {
-				err = filepath.SkipDir
-			}
 			return
 		}
 
@@ -64,7 +71,7 @@ func (t *Translator) ParseDir(dirPath string) (err error) {
 		}
 
 		// Parse file
-		if err = t.ParseFile(path); err != nil {
+		if err = t.ParseFile(dirPath, path); err != nil {
 			err = fmt.Errorf("astikit: parsing %s failed: %w", path, err)
 			return
 		}
@@ -77,7 +84,7 @@ func (t *Translator) ParseDir(dirPath string) (err error) {
 }
 
 // ParseFile adds translation located in the provided path
-func (t *Translator) ParseFile(path string) (err error) {
+func (t *Translator) ParseFile(dirPath, path string) (err error) {
 	// Lock
 	t.m.Lock()
 	defer t.m.Unlock()
@@ -97,8 +104,26 @@ func (t *Translator) ParseFile(path string) (err error) {
 		return
 	}
 
+	// Get language
+	language := strings.TrimSuffix(filepath.Base(path), filepath.Ext(path))
+
+	// Update valid languages
+	t.validLanguages[language] = true
+
+	// Get prefix
+	prefix := language
+	if dp := filepath.Dir(path); dp != dirPath {
+		var fs []string
+		for _, v := range strings.Split(strings.TrimPrefix(dp, dirPath), string(os.PathSeparator)) {
+			if v != "" {
+				fs = append(fs, v)
+			}
+		}
+		prefix += "." + strings.Join(fs, ".")
+	}
+
 	// Parse
-	t.parse(p, strings.TrimSuffix(filepath.Base(path), filepath.Ext(path)))
+	t.parse(p, prefix)
 	return
 }
 
@@ -123,7 +148,7 @@ func (t *Translator) HTTPMiddleware(h http.Handler) http.Handler {
 	return http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
 		// Store language in context
 		if l := r.Header.Get("Accept-Language"); l != "" {
-			*r = *r.WithContext(contextWithTranslatorLanguage(r.Context(), l))
+			*r = *r.WithContext(contextWithTranslatorLanguage(r.Context(), t.parseAcceptLanguage(l)))
 		}
 
 		// Next handler
@@ -131,7 +156,56 @@ func (t *Translator) HTTPMiddleware(h http.Handler) http.Handler {
 	})
 }
 
-const contextKeyTranslatorLanguage = "astikit.translator.language"
+func (t *Translator) parseAcceptLanguage(h string) string {
+	// Split on comma
+	var qs []float64
+	ls := make(map[float64][]string)
+	for _, c := range strings.Split(strings.TrimSpace(h), ",") {
+		// Empty
+		c = strings.TrimSpace(c)
+		if c == "" {
+			continue
+		}
+
+		// Split on semi colon
+		ss := strings.Split(c, ";")
+
+		// Parse coefficient
+		q := float64(1)
+		if len(ss) > 1 {
+			s := strings.TrimSpace(ss[1])
+			if strings.HasPrefix(s, "q=") {
+				var err error
+				if q, err = strconv.ParseFloat(strings.TrimPrefix(s, "q="), 64); err != nil {
+					q = 1
+				}
+			}
+		}
+
+		// Add
+		if _, ok := ls[q]; !ok {
+			qs = append(qs, q)
+		}
+		ls[q] = append(ls[q], strings.TrimSpace(ss[0]))
+	}
+
+	// Order coefficients
+	sort.Float64s(qs)
+
+	// Loop through coefficients in reverse order
+	for idx := len(qs) - 1; idx >= 0; idx-- {
+		for _, l := range ls[qs[idx]] {
+			if _, ok := t.validLanguages[l]; ok {
+				return l
+			}
+		}
+	}
+	return ""
+}
+
+const contextKeyTranslatorLanguage = contextKey("astikit.translator.language")
+
+type contextKey string
 
 func contextWithTranslatorLanguage(ctx context.Context, language string) context.Context {
 	return context.WithValue(ctx, contextKeyTranslatorLanguage, language)
@@ -147,7 +221,7 @@ func translatorLanguageFromContext(ctx context.Context) string {
 
 func (t *Translator) language(language string) string {
 	if language == "" {
-		return t.o.DefaultLanguage
+		return t.defaultLanguage
 	}
 	return language
 }
@@ -171,14 +245,28 @@ func (t *Translator) Translate(language, key string) string {
 	}
 
 	// Default translation
-	k2 := t.key(t.o.DefaultLanguage, key)
+	k2 := t.key(t.defaultLanguage, key)
 	if v, ok = t.p[k2]; ok {
 		return v
 	}
 	return k1
 }
 
-// TranslateCtx translates a key using the language specified in the context
+// Translatef translates a key into a specific language with optional formatting args
+func (t *Translator) Translatef(language, key string, args ...interface{}) string {
+	return fmt.Sprintf(t.Translate(language, key), args...)
+}
+
+// TranslateCtx is an alias for TranslateC
 func (t *Translator) TranslateCtx(ctx context.Context, key string) string {
+	return t.TranslateC(ctx, key)
+}
+
+// TranslateC translates a key using the language specified in the context
+func (t *Translator) TranslateC(ctx context.Context, key string) string {
 	return t.Translate(translatorLanguageFromContext(ctx), key)
 }
+
+func (t *Translator) TranslateCf(ctx context.Context, key string, args ...interface{}) string {
+	return t.Translatef(translatorLanguageFromContext(ctx), key, args...)
+}