CI: minor: use the new exclude-paths (dependabot PR approved some days ago)

Author: kataras

.github/dependabot.yml

@@ -2,9 +2,11 @@ version: 2
 updates:
   - package-ecosystem: "gomod"
     directory: "/"
+    exclude-paths:
+      - "_examples/"
     schedule:
-      interval: "weekly"
+      interval: "monthly"
   - package-ecosystem: "github-actions"
     directory: "/"
     schedule:
-      interval: "weekly"
+      interval: "monthly"

apps/switch_hosts.go

@@ -19,7 +19,7 @@ type (
 		Pattern string
 		// Target is the target Host that incoming requests will be redirected on pattern match
 		// or an Application's Name that will handle the incoming request matched the Pattern.
-		Target interface{} // It was a string in my initial design but let's do that interface{}, we may support more types here in the future, until generics are in, keep it interface{}.
+		Target any // It was a string in my initial design but let's do that any, we may support more types here in the future, until generics are in, keep it any.
 	}
 	// Hosts is a switch provider.
 	// It can be used as input argument to the `Switch` function

context/application.go

@@ -30,7 +30,7 @@ type Application interface {
 
 	// Validate validates a value and returns nil if passed or
 	// the failure reason if not.
-	Validate(interface{}) error
+	Validate(any) error
 
 	// Minifier returns the minifier instance.
 	// By default it can minifies:
@@ -44,7 +44,7 @@ type Application interface {
 	//
 	// Use context.View to render templates to the client instead.
 	// Returns an error on failure, otherwise nil.
-	View(writer io.Writer, filename string, layout string, bindingData interface{}) error
+	View(writer io.Writer, filename string, layout string, bindingData any) error
 
 	// GetContextPool returns the Iris sync.Pool which holds the contexts values.
 	// Iris automatically releases the request context, so you don't have to use it.

context/compress.go

@@ -170,7 +170,7 @@ func NewCompressReader(src io.Reader, encoding string) (*CompressReader, error)
 	}, nil
 }
 
-var compressWritersPool = sync.Pool{New: func() interface{} { return &CompressResponseWriter{} }}
+var compressWritersPool = sync.Pool{New: func() any { return &CompressResponseWriter{} }}
 
 // AddCompressHeaders just adds the headers "Vary" to "Accept-Encoding"
 // and "Content-Encoding" to the given encoding.

context/configuration.go

@@ -96,5 +96,5 @@ type ConfigurationReadOnly interface {
 	// GetHostProxyHeaders returns the HostProxyHeaders field.
 	GetHostProxyHeaders() map[string]bool
 	// GetOther returns the Other field.
-	GetOther() map[string]interface{}
+	GetOther() map[string]any
 }

context/context.go

@@ -13,16 +13,16 @@ var ErrInvalidArgs = errors.New("invalid arguments")
 // Func represents a function registered by the Context.
 // See its `buildMeta` and `call` internal methods.
 type Func struct {
-	RegisterName    string        // the name of which this function is registered, for information only.
-	Raw             interface{}   // the Raw function, can be used for custom casting.
-	PersistenceArgs []interface{} // the persistence input arguments given on registration.
+	RegisterName    string // the name of which this function is registered, for information only.
+	Raw             any    // the Raw function, can be used for custom casting.
+	PersistenceArgs []any  // the persistence input arguments given on registration.
 
 	once sync.Once // guards build once, on first call.
 	// Available after the first call.
 	Meta *FuncMeta
 }
 
-func newFunc(name string, fn interface{}, persistenceArgs ...interface{}) *Func {
+func newFunc(name string, fn any, persistenceArgs ...any) *Func {
 	return &Func{
 		RegisterName:    name,
 		Raw:             fn,
@@ -37,8 +37,8 @@ type FuncMeta struct {
 	HandlerWithErr     func(*Context) error // when it's just a handler which returns an error.
 	RawFunc            func()               // when it's just a func.
 	RawFuncWithErr     func() error         // when it's just a func which returns an error.
-	RawFuncArgs        func(...interface{})
-	RawFuncArgsWithErr func(...interface{}) error
+	RawFuncArgs        func(...any)
+	RawFuncArgsWithErr func(...any) error
 
 	Value                   reflect.Value
 	Type                    reflect.Type
@@ -65,10 +65,10 @@ func (f *Func) buildMeta() {
 	case func() error:
 		f.Meta = &FuncMeta{RawFuncWithErr: fn}
 		return
-	case func(...interface{}):
+	case func(...any):
 		f.Meta = &FuncMeta{RawFuncArgs: fn}
 		return
-	case func(...interface{}) error:
+	case func(...any) error:
 		f.Meta = &FuncMeta{RawFuncArgsWithErr: fn}
 		return
 	}
@@ -119,7 +119,7 @@ func (f *Func) buildMeta() {
 	f.Meta = &meta
 }
 
-func (f *Func) call(ctx *Context, args ...interface{}) ([]reflect.Value, error) {
+func (f *Func) call(ctx *Context, args ...any) ([]reflect.Value, error) {
 	f.once.Do(f.buildMeta)
 	meta := f.Meta
 

context/context_func.go

@@ -34,7 +34,7 @@ var ErrNotSupported = errors.New("not supported")
 // - UserPartial (a wrapper by SetUser)
 type User interface {
 	// GetRaw should return the raw instance of the user, if supported.
-	GetRaw() (interface{}, error)
+	GetRaw() (any, error)
 	// GetAuthorization should return the authorization method,
 	// e.g. Basic Authentication.
 	GetAuthorization() (string, error)
@@ -60,12 +60,12 @@ type User interface {
 	// GetField should optionally return a dynamic field
 	// based on its key. Useful for custom user fields.
 	// Keep in mind that these fields are encoded as a separate JSON key.
-	GetField(key string) (interface{}, error)
+	GetField(key string) (any, error)
 } /* Notes:
 We could use a structure of User wrapper and separate interfaces for each of the methods
 so they return ErrNotSupported if the implementation is missing it, so the `Features`
 field and HasUserFeature can be omitted and
-add a Raw() interface{} to return the underline User implementation too.
+add a Raw() any to return the underline User implementation too.
 The advandages of the above idea is that we don't have to add new methods
 for each of the builtin features and we can keep the (assumed) struct small.
 But we dont as it has many disadvantages, unless is requested.
@@ -95,7 +95,7 @@ type SimpleUser struct {
 var _ User = (*SimpleUser)(nil)
 
 // GetRaw returns itself.
-func (u *SimpleUser) GetRaw() (interface{}, error) {
+func (u *SimpleUser) GetRaw() (any, error) {
 	return u, nil
 }
 
@@ -156,18 +156,18 @@ func (u *SimpleUser) GetToken() ([]byte, error) {
 
 // GetField optionally returns a dynamic field from the `Fields` field
 // based on its key.
-func (u *SimpleUser) GetField(key string) (interface{}, error) {
+func (u *SimpleUser) GetField(key string) (any, error) {
 	if u.Fields == nil {
 		return nil, ErrNotSupported
 	}
 
 	return u.Fields[key], nil
 }
 
-// UserMap can be used to convert a common map[string]interface{} to a User.
+// UserMap can be used to convert a common map[string]any to a User.
 // Usage:
 //
-//	user := map[string]interface{}{
+//	user := map[string]any{
 //	  "username": "kataras",
 //	  "age"     : 27,
 //	}
@@ -189,7 +189,7 @@ type UserMap Map
 var _ User = UserMap{}
 
 // GetRaw returns the underline map.
-func (u UserMap) GetRaw() (interface{}, error) {
+func (u UserMap) GetRaw() (any, error) {
 	return Map(u), nil
 }
 
@@ -235,11 +235,11 @@ func (u UserMap) GetToken() ([]byte, error) {
 
 // GetField returns the raw map's value based on its "key".
 // It's not kind of useful here as you can just use the map.
-func (u UserMap) GetField(key string) (interface{}, error) {
+func (u UserMap) GetField(key string) (any, error) {
 	return u[key], nil
 }
 
-func (u UserMap) val(key string) interface{} {
+func (u UserMap) val(key string) any {
 	isTitle := unicode.IsTitle(rune(key[0])) // if starts with uppercase.
 	if isTitle {
 		key = strings.ToLower(key)
@@ -333,15 +333,15 @@ type (
 	}
 
 	userGetField interface {
-		GetField(string) interface{}
+		GetField(string) any
 	}
 
 	// UserPartial is a User.
 	// It's a helper which wraps a struct value that
 	// may or may not complete the whole User interface.
 	// See Context.SetUser.
 	UserPartial struct {
-		Raw                  interface{} `json:"raw"`
+		Raw                  any `json:"raw"`
 		userGetAuthorization `json:",omitempty"`
 		userGetAuthorizedAt  `json:",omitempty"`
 		userGetID            `json:",omitempty"`
@@ -356,7 +356,7 @@ type (
 
 var _ User = (*UserPartial)(nil)
 
-func newUserPartial(i interface{}) *UserPartial {
+func newUserPartial(i any) *UserPartial {
 	if i == nil {
 		return nil
 	}
@@ -407,7 +407,7 @@ func newUserPartial(i interface{}) *UserPartial {
 }
 
 // GetRaw returns the original raw instance of the user.
-func (u *UserPartial) GetRaw() (interface{}, error) {
+func (u *UserPartial) GetRaw() (any, error) {
 	if u == nil {
 		return nil, ErrNotSupported
 	}
@@ -496,7 +496,7 @@ func (u *UserPartial) GetToken() ([]byte, error) {
 // GetField should optionally return a dynamic field
 // based on its key. Useful for custom user fields.
 // Keep in mind that these fields are encoded as a separate JSON key.
-func (u *UserPartial) GetField(key string) (interface{}, error) {
+func (u *UserPartial) GetField(key string) (any, error) {
 	if v := u.userGetField; v != nil {
 		return v.GetField(key), nil
 	}

context/context_user.go

@@ -17,7 +17,7 @@ import (
 // It affects the view engine's filesystem resolver.
 //
 // This package-level variable can be modified on initialization.
-var ResolveFS = func(fsOrDir interface{}) fs.FS {
+var ResolveFS = func(fsOrDir any) fs.FS {
 	if fsOrDir == nil {
 		return noOpFS{}
 	}
@@ -101,7 +101,7 @@ func (f *httpFS) ReadDir(name string) ([]fs.DirEntry, error) {
 // It affects the Application's API Builder's `HandleDir` method.
 //
 // This package-level variable can be modified on initialization.
-var ResolveHTTPFS = func(fsOrDir interface{}) http.FileSystem {
+var ResolveHTTPFS = func(fsOrDir any) http.FileSystem {
 	var fileSystem http.FileSystem
 	switch v := fsOrDir.(type) {
 	case string:

context/fs.go

@@ -131,7 +131,7 @@ type Handler = func(*Context)
 // See `Handler` for more.
 type Handlers = []Handler
 
-func valueOf(v interface{}) reflect.Value {
+func valueOf(v any) reflect.Value {
 	if val, ok := v.(reflect.Value); ok {
 		return val
 	}
@@ -142,7 +142,7 @@ func valueOf(v interface{}) reflect.Value {
 // HandlerName returns the handler's function name.
 // See `Context.HandlerName` method to get function name of the current running handler in the chain.
 // See `SetHandlerName` too.
-func HandlerName(h interface{}) string {
+func HandlerName(h any) string {
 	pc := valueOf(h).Pointer()
 	fn := runtime.FuncForPC(pc)
 	name := fn.Name()
@@ -166,10 +166,10 @@ func HandlerName(h interface{}) string {
 // or to determinate if end-developer
 // called the same exactly Use/UseRouter/Done... API methods
 // so framework can give a warning.
-func HandlersNames(handlers ...interface{}) string {
+func HandlersNames(handlers ...any) string {
 	if len(handlers) == 1 {
 		if hs, ok := handlers[0].(Handlers); ok {
-			asInterfaces := make([]interface{}, 0, len(hs))
+			asInterfaces := make([]any, 0, len(hs))
 			for _, h := range hs {
 				asInterfaces = append(asInterfaces, h)
 			}
@@ -188,14 +188,14 @@ func HandlersNames(handlers ...interface{}) string {
 
 // HandlerFileLine returns the handler's file and line information.
 // See `context.HandlerFileLine` to get the file, line of the current running handler in the chain.
-func HandlerFileLine(h interface{}) (file string, line int) {
+func HandlerFileLine(h any) (file string, line int) {
 	pc := valueOf(h).Pointer()
 	return runtime.FuncForPC(pc).FileLine(pc)
 }
 
 // HandlerFileLineRel same as `HandlerFileLine` but it returns the path
 // corresponding to its relative based on the package-level "WorkingDir" variable.
-func HandlerFileLineRel(h interface{}) (file string, line int) {
+func HandlerFileLineRel(h any) (file string, line int) {
 	file, line = HandlerFileLine(h)
 	if relFile, err := filepath.Rel(WorkingDir, file); err == nil {
 		if !strings.HasPrefix(relFile, "..") {
@@ -209,13 +209,13 @@ func HandlerFileLineRel(h interface{}) (file string, line int) {
 
 // MainHandlerName tries to find the main handler that end-developer
 // registered on the provided chain of handlers and returns its function name.
-func MainHandlerName(handlers ...interface{}) (name string, index int) {
+func MainHandlerName(handlers ...any) (name string, index int) {
 	if len(handlers) == 0 {
 		return
 	}
 
 	if hs, ok := handlers[0].(Handlers); ok {
-		tmp := make([]interface{}, 0, len(hs))
+		tmp := make([]any, 0, len(hs))
 		for _, h := range hs {
 			tmp = append(tmp, h)
 		}