Mirrors/kararas_iris
1
0
Fork 0
mirror of https://github.com/kataras/iris.git synced 2026-01-08 20:41:57 +00:00
Code Releases Activity

implement path prefx for i18n middleware, as requested at: #1369

Browse Source 
Former-commit-id: b0d6b6e7f368e710b01faad9b70dfa4cebdd8c4d
This commit is contained in:
Gerasimos (Makis) Maropoulos
2019-11-19 23:36:18 +02:00
parent 1faea8b2e8
commit 0844c109d9
16 changed files with 304 additions and 130 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
middleware/i18n/config.go
View File

@@ -1,18 +0,0 @@
package i18n
// Config the i18n options
type Config struct {
// Default set it if you want a default language
//
// Checked: Configuration state, not at runtime
Default string
// URLParameter is the name of the url parameter which the language can be indentified
//
// Checked: Serving state, runtime
URLParameter string
// Languages is a map[string]string which the key is the language i81n and the value is the file location
//
// Example of key is: 'en-US'
// Example of value is: './locales/en-US.ini'
Languages map[string]string
}

264
middleware/i18n/i18n.go
View File

@@ -3,6 +3,8 @@
package i18n
import (
"fmt"
"net/http"
"reflect"
"strings"
@@ -10,80 +12,84 @@ import (
"github.com/kataras/iris/v12/context"
)
// test file: ../../_examples/miscellaneous/i18n/main_test.go
type i18nMiddleware struct {
config Config
// Config the i18n options.
type Config struct {
// Default set it if you want a default language.
//
// Checked: Configuration state, not at runtime.
Default string
// URLParameter is the name of the url parameter which the language can be indentified,
// e.g. "lang" for ?lang=.
//
// Checked: Serving state, runtime.
URLParameter string
// PathParameter is the name of the path parameter which the language can be indentified,
// e.g. "lang" for "{lang:string}".
//
// Checked: Serving state, runtime.
//
// You can set custom handler to set the language too.
// Example:
// setLangMiddleware := func(ctx iris.Context){
// langKey := ctx.Application().ConfigurationReadOnly().GetTranslateLanguageContextKey()
// languageByPath := ctx.Params().Get("lang") // see {lang}
// ctx.Values().Set(langKey, languageByPath)
// ctx.Next()
// }
// app.Use(setLangMiddleware)
// app.Use(theI18nMiddlewareInstance)
PathParameter string
// Languages is a map[string]string which the key is the language i81n and the value is the file location.
//
// Example of key is: 'en-US'.
// Example of value is: './locales/en-US.ini'.
Languages map[string]string
// Alternatives is a language map which if it's filled,
// it tries to associate its keys with a value of "Languages" field when a possible value of "Language" was not present.
// Example of
// Languages: map[string]string{"en-US": "./locales/en-US.ini"} set
// Alternatives: map[string]string{ "en":"en-US", "english": "en-US"}.
Alternatives map[string]string
// If SetCookie is true then it will set the cookie to the language found by URLParameter, PathParameter or by Context's Value's "lang" key.
// Defaults to false.
SetCookie bool
}
// ServeHTTP serves the request, the actual middleware's job is here
func (i *i18nMiddleware) ServeHTTP(ctx context.Context) {
wasByCookie := false
langKey := ctx.Application().ConfigurationReadOnly().GetTranslateLanguageContextKey()
language := ctx.Values().GetString(langKey)
if language == "" {
// try to get by url parameter
language = ctx.URLParam(i.config.URLParameter)
if language == "" {
// then try to take the lang field from the cookie
language = ctx.GetCookie(langKey)
if len(language) > 0 {
wasByCookie = true
} else {
// try to get by the request headers.
langHeader := ctx.GetHeader("Accept-Language")
if len(langHeader) > 0 {
for _, langEntry := range strings.Split(langHeader, ",") {
lc := strings.Split(langEntry, ";")[0]
if lc, ok := i18n.IsExistSimilar(lc); ok {
language = lc
break
}
}
}
}
// Exists returns true if the language, or something similar
// exists (e.g. en-US maps to en or Alternatives[key] == lang).
// it returns the found name and whether it was able to match something.
func (c *Config) Exists(lang string) (string, bool) {
for k, v := range c.Alternatives {
if k == lang {
lang = v
break
}
// if it was not taken by the cookie, then set the cookie in order to have it
if !wasByCookie {
ctx.SetCookieKV(langKey, language)
}
if language == "" {
language = i.config.Default
}
ctx.Values().Set(langKey, language)
}
locale := i18n.Locale{Lang: language}
// if unexpected language given, the middleware will transtlate to the default language, the language key should be
// also this language instead of the user-given
if indexLang := locale.Index(); indexLang == -1 {
locale.Lang = i.config.Default
}
translateFuncKey := ctx.Application().ConfigurationReadOnly().GetTranslateFunctionContextKey()
ctx.Values().Set(translateFuncKey, locale.Tr)
ctx.Next()
return i18n.IsExistSimilar(lang)
}
// Translate returns the translated word from a context
// the second parameter is the key of the world or line inside the .ini file
// the third parameter is the '%s' of the world or line inside the .ini file
func Translate(ctx context.Context, format string, args ...interface{}) string {
return ctx.Translate(format, args...)
}
// New returns a new i18n middleware
func New(c Config) context.Handler {
func (c *Config) loadLanguages() {
if len(c.Languages) == 0 {
panic("You cannot use this middleware without set the Languages option, please try again and read the _example.")
panic("field Languages is empty")
}
i := &i18nMiddleware{config: c}
for k, v := range c.Alternatives {
if _, ok := c.Languages[v]; !ok {
panic(fmt.Sprintf("language alternative '%s' does not map to a valid language '%s'", k, v))
}
}
firstlanguage := ""
// load the files
for k, langFileOrFiles := range c.Languages {
if i18n.IsExist(k) {
// if it is already stored through middleware (`New`) then skip it.
continue
}
// remove all spaces.
langFileOrFiles = strings.Replace(langFileOrFiles, " ", "", -1)
// note: if only one, then the first element is the "v".
@@ -93,24 +99,152 @@ func New(c Config) context.Handler {
if !strings.HasSuffix(v, ".ini") {
v += ".ini"
}
err := i18n.SetMessage(k, v)
if err != nil && err != i18n.ErrLangAlreadyExist {
panic("Failed to set locale file'" + k + "' Error:" + err.Error())
panic(fmt.Sprintf("Failed to set locale file' %s' with error: %v", k, err))
}
if firstlanguage == "" {
firstlanguage = k
}
}
}
// if not default language set then set to the first of the i.config.Languages
// if not default language set then set to the first of the "Languages".
if c.Default == "" {
c.Default = firstlanguage
}
i18n.SetDefaultLang(i.config.Default)
i18n.SetDefaultLang(c.Default)
}
// test file: ../../_examples/miscellaneous/i18n/main_test.go
type i18nMiddleware struct {
config Config
}
// New returns a new i18n middleware.
func New(c Config) context.Handler {
c.loadLanguages()
i := &i18nMiddleware{config: c}
return i.ServeHTTP
}
// ServeHTTP serves the request, the actual middleware's job is located here.
func (i *i18nMiddleware) ServeHTTP(ctx context.Context) {
wasByCookie := false
langKey := ctx.Application().ConfigurationReadOnly().GetTranslateLanguageContextKey()
language := ctx.Values().GetString(langKey)
if language == "" {
// try to get by path parameter
if i.config.PathParameter != "" {
language = ctx.Params().Get(i.config.PathParameter)
}
if language == "" {
// try to get by url parameter
language = ctx.URLParam(i.config.URLParameter)
if language == "" {
// then try to take the lang field from the cookie
language = ctx.GetCookie(langKey)
if len(language) > 0 {
wasByCookie = true
} else {
// try to get by the request headers.
langHeader := ctx.GetHeader("Accept-Language")
if len(langHeader) > 0 {
for _, langEntry := range strings.Split(langHeader, ",") {
lc := strings.Split(langEntry, ";")[0]
if lc, ok := i.config.Exists(lc); ok {
language = lc
break
}
}
}
}
}
}
}
// returns the original key of the language and true
// when the language, or something similar exists (e.g. en-US maps to en).
if lc, ok := i.config.Exists(language); ok {
language = lc
} else {
// if unexpected language given, the middleware will translate to the default language,
// the language key should be also this language instead of the user-given.
language = i.config.Default
}
// if it was not taken by the cookie, then set the cookie in order to have it.
if !wasByCookie && i.config.SetCookie {
ctx.SetCookieKV(langKey, language)
}
ctx.Values().Set(langKey, language)
// Set iris.translate and iris.translateLang functions (they can be passed to templates as they are later on).
ctx.Values().Set(ctx.Application().ConfigurationReadOnly().GetTranslateFunctionContextKey(), getTranslateFunction(language))
// Note: translate (global) language function input argument should match exactly, case-sensitive and "Alternatives" field is not part of the fetch progress.
ctx.Values().Set(ctx.Application().ConfigurationReadOnly().GetTranslateLangFunctionContextKey(), i18n.Tr)
ctx.Next()
}
func getTranslateFunction(lang string) func(string, ...interface{}) string {
return func(format string, args ...interface{}) string {
return i18n.Tr(lang, format, args...)
}
}
// NewWrapper accepts a Config and returns a new router wrapper.
// The result function can be passed on `Application.WrapRouter`.
// It compares the path prefix for translated language and
// local redirects the requested path with the selected (from the path) language to the router.
//
// In order this to work as expected, it should be combined with `Application.Use(New)`
// which registers the i18n middleware itself.
func NewWrapper(c Config) func(http.ResponseWriter, *http.Request, http.HandlerFunc) {
c.loadLanguages()
return func(w http.ResponseWriter, r *http.Request, routerHandler http.HandlerFunc) {
path := r.URL.Path[1:]
if idx := strings.IndexRune(path, '/'); idx > 0 {
path = path[:idx]
}
if lang, ok := c.Exists(path); ok {
path = r.URL.Path[len(path)+1:]
if path == "" {
path = "/"
}
r.RequestURI = path
r.URL.Path = path
r.Header.Set("Accept-Language", lang)
}
routerHandler(w, r)
}
}
// Translate returns the translated word from a context based on the current selected locale.
// The second parameter is the key of the world or line inside the .ini file and
// the third parameter is the '%s' of the world or line inside the .ini file
func Translate(ctx context.Context, format string, args ...interface{}) string {
return ctx.Translate(format, args...)
}
// TranslateLang returns the translated word from a context based on the given "lang".
// The second parameter is the language key which the word "format" is translated to and
// the third parameter is the key of the world or line inside the .ini file and
// the forth parameter is the '%s' of the world or line inside the .ini file
func TranslateLang(ctx context.Context, lang, format string, args ...interface{}) string {
return ctx.TranslateLang(lang, format, args...)
}
// TranslatedMap returns translated map[string]interface{} from i18n structure.
func TranslatedMap(ctx context.Context, sourceInterface interface{}) map[string]interface{} {
iType := reflect.TypeOf(sourceInterface).Elem()