chore(deps): update dependencies

Author: rustatian

collects.go

@@ -7,7 +7,7 @@ import (
 func (e *Endure) collects() error {
 	vertices := e.graph.TopologicalOrder()
 
-	for i := 0; i < len(vertices); i++ {
+	for i := range vertices {
 		if !vertices[i].IsActive() {
 			continue
 		}
@@ -20,13 +20,13 @@ func (e *Endure) collects() error {
 		collects := vertices[i].Plugin().(Collector).Collects()
 
 		// get vals
-		for j := 0; j < len(collects); j++ {
+		for j := range collects {
 			impl := e.registar.ImplementsExcept(collects[j].Type, vertices[i].Plugin())
 			if len(impl) == 0 {
 				continue
 			}
 
-			for k := 0; k < len(impl); k++ {
+			for k := range impl {
 				value, ok := e.registar.TypeValue(impl[k].Plugin(), collects[j].Type)
 				if !ok {
 					return errors.E("this is likely a bug, nil value from the implements. Value should be initialized due to the topological order")

dep/out.go

@@ -27,7 +27,7 @@ func Bind(tp any, method any) *Out {
 		panic("second argument should be a function")
 	}
 
-	for i := 0; i < r.NumOut(); i++ {
+	for i := range r.NumOut() {
 		// skip errors
 		if r.Out(i) == reflect.TypeOf((*error)(nil)).Elem() {
 			continue

edges.go

@@ -15,10 +15,10 @@ func (e *Endure) resolveCollectorEdges(plugin any) error {
 	// retrieve the needed dependencies via Collects
 	inEntries := collector.Collects()
 
-	for i := 0; i < len(inEntries); i++ {
+	for i := range inEntries {
 		res := e.registar.ImplementsExcept(inEntries[i].Type, plugin)
 		if len(res) > 0 {
-			for j := 0; j < len(res); j++ {
+			for j := range res {
 				e.graph.AddEdge(graph.CollectsConnection, res[j].Plugin(), plugin)
 				e.log.Debug("collects edge found",
 					zap.String("method", res[j].Method()),
@@ -36,15 +36,15 @@ func (e *Endure) resolveCollectorEdges(plugin any) error {
 func (e *Endure) resolveEdges() error {
 	vertices := e.graph.Vertices()
 
-	for i := 0; i < len(vertices); i++ {
+	for i := range vertices {
 		vertex := e.graph.VertexById(vertices[i].Plugin())
 		initMethod, ok := vertex.ID().MethodByName(InitMethodName)
 		if !ok {
 			return errors.E("plugin should have the `Init(...) error` method")
 		}
 
 		args := make([]reflect.Type, initMethod.Type.NumIn())
-		for j := 0; j < initMethod.Type.NumIn(); j++ {
+		for j := range initMethod.Type.NumIn() {
 			if isPrimitive(initMethod.Type.In(j).String()) {
 				e.log.Error(
 					"primitive type in the function parameters",
@@ -72,7 +72,7 @@ func (e *Endure) resolveEdges() error {
 				res := e.registar.ImplementsExcept(args[j], vertices[i].Plugin())
 				if len(res) > 0 {
 					count += 1
-					for k := 0; k < len(res); k++ {
+					for k := range res {
 						// add graph edge
 						e.graph.AddEdge(graph.InitConnection, res[k].Plugin(), vertex.Plugin())
 						// log
@@ -89,7 +89,7 @@ func (e *Endure) resolveEdges() error {
 			if count != len(args[1:]) {
 				// if there are no plugins that implement Init deps, remove this vertex from the tree
 				del := e.graph.Remove(vertices[i].Plugin())
-				for k := 0; k < len(del); k++ {
+				for k := range del {
 					e.registar.Remove(del[k].Plugin())
 					e.log.Debug(
 						"plugin disabled, not enough Init dependencies",

endure.go

@@ -135,7 +135,7 @@ func (e *Endure) Register(vertex any) error {
 		outDeps := val.Provides()
 
 		// iter
-		for i := 0; i < len(outDeps); i++ {
+		for i := range outDeps {
 			e.registar.Insert(vertex, outDeps[i].Type, outDeps[i].Method, weight)
 			e.log.Debug(
 				"provided type registered",
@@ -237,7 +237,7 @@ func (e *Endure) Plugins() []string {
 	v := e.graph.TopologicalOrder()
 	plugins := make([]string, 0, len(v))
 
-	for i := 0; i < len(v); i++ {
+	for i := range v {
 		if !v[i].IsActive() {
 			continue
 		}

graph/graph.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"os"
 	"reflect"
+	"slices"
 	"strings"
 )
 
@@ -100,7 +101,7 @@ func (g *Graph) Remove(plugin any) []*Vertex {
 	}
 
 	edges := vertex.edges
-	for i := 0; i < len(edges); i++ {
+	for i := range edges {
 		if _, ok := g.vertices[reflect.TypeOf(edges[i].dest)]; !ok {
 			continue
 		}
@@ -112,7 +113,7 @@ func (g *Graph) Remove(plugin any) []*Vertex {
 
 			args := make([]reflect.Type, initMethod.Type.NumIn())
 			// receiver + other (should be other, since this is a dest vertex)
-			for j := 0; j < initMethod.Type.NumIn(); j++ {
+			for j := range initMethod.Type.NumIn() {
 				args[j] = initMethod.Type.In(j)
 			}
 
@@ -127,13 +128,13 @@ func (g *Graph) Remove(plugin any) []*Vertex {
 					continue
 				}
 
-				for j := 0; j < len(args); j++ {
+				for j := range args {
 					if reflect.TypeOf(v.Plugin()).Implements(args[j]) {
 						/*
 							we've found a plugin which may replace our dependency
 							now, since we modified the slice, start iteration again
 						*/
-						args = append(args[:j], args[j+1:]...)
+						args = slices.Delete(args, j, j+1)
 						goto retry
 					}
 				}
@@ -154,15 +155,15 @@ func (g *Graph) Remove(plugin any) []*Vertex {
 
 	// remove all edges where dest is our plugin prepared to delete
 	for _, v := range g.vertices {
-		for i := 0; i < len(v.edges); i++ {
+		for i := range v.edges {
 			if v.edges[i].dest == plugin {
-				v.edges = append(v.edges[:i], v.edges[i+1:]...)
+				v.edges = slices.Delete(v.edges, i, i+1)
 			}
 		}
 	}
 
-	for i := 0; i < len(g.topologicalOrder); i++ {
-		for j := 0; j < len(deletedVertices); j++ {
+	for i := range g.topologicalOrder {
+		for j := range deletedVertices {
 			if g.topologicalOrder[i] == deletedVertices[j] {
 				g.topologicalOrder[i].active = false
 			}
@@ -179,8 +180,8 @@ func (g *Graph) WriteDotString() {
 	s.WriteString("\tgraph [compound=true];\n")
 
 	seenEdges := make(map[string]struct{})
-	for i := 0; i < len(g.topologicalOrder); i++ {
-		for j := 0; j < len(g.topologicalOrder[i].edges); j++ {
+	for i := range g.topologicalOrder {
+		for j := range g.topologicalOrder[i].edges {
 			src := reflect.TypeOf(g.topologicalOrder[i].edges[j].src).String()
 			dest := reflect.TypeOf(g.topologicalOrder[i].edges[j].dest).String()
 

graph/heap.go

@@ -17,12 +17,12 @@ func (h *VertexHeap) Swap(i, j int) {
 	(*h)[i], (*h)[j] = (*h)[j], (*h)[i]
 }
 
-func (h *VertexHeap) Push(x interface{}) {
+func (h *VertexHeap) Push(x any) {
 	*h = append(*h, x.(*Vertex))
 	heap.Fix(h, len(*h)-1)
 }
 
-func (h *VertexHeap) Pop() interface{} {
+func (h *VertexHeap) Pop() any {
 	n := len(*h)
 	x := (*h)[n-1]
 	*h = (*h)[0 : n-1]

graph/toposort.go

@@ -24,7 +24,7 @@ func (g *Graph) TopologicalSort() {
 
 		// Decrement the indegree of each of the vertex's neighbors.
 		// If a neighbor's indegree becomes 0, add it to the priority queue.
-		for i := 0; i < len(v.edges); i++ {
+		for i := range v.edges {
 			dest := g.VertexById(v.edges[i].dest)
 			dest.indegree--
 

init.go

@@ -17,15 +17,15 @@ func (e *Endure) init() error {
 		return errors.E(errors.Str("error occurred, nothing to run"))
 	}
 
-	for i := 0; i < len(vertices); i++ {
+	for i := range vertices {
 		if !vertices[i].IsActive() {
 			continue
 		}
 
 		initMethod, _ := reflect.TypeOf(vertices[i].Plugin()).MethodByName(InitMethodName)
 
 		args := make([]reflect.Type, initMethod.Type.NumIn())
-		for j := 0; j < initMethod.Type.NumIn(); j++ {
+		for j := range initMethod.Type.NumIn() {
 			args[j] = initMethod.Type.In(j)
 		}
 
@@ -35,11 +35,11 @@ func (e *Endure) init() error {
 		if len(args) > 1 {
 			// exclude first arg (its receiver)
 			arg := args[1:]
-			for j := 0; j < len(arg); j++ {
+			for j := range arg {
 				plugin := e.registar.ImplementsExcept(arg[j], vertices[i].Plugin())
 				if len(plugin) == 0 {
 					del := e.graph.Remove(vertices[i].Plugin())
-					for k := 0; k < len(del); k++ {
+					for k := range del {
 						e.registar.Remove(del[k].Plugin())
 						e.log.Debug(
 							"plugin disabled, not enough Init dependencies",
@@ -97,7 +97,7 @@ func (e *Endure) init() error {
 				// delete vertex and continue
 				plugins := e.graph.Remove(vertices[i].Plugin())
 
-				for j := 0; j < len(plugins); j++ {
+				for j := range plugins {
 					e.log.Debug(
 						"destination plugin disabled because root was disabled",
 						zap.String("name", plugins[j].ID().String()),
@@ -120,7 +120,7 @@ func (e *Endure) init() error {
 
 		if provider, ok := vertices[i].Plugin().(Provider); ok {
 			out := provider.Provides()
-			for j := 0; j < len(out); j++ {
+			for j := range out {
 				providesMethod, okk := reflect.TypeOf(vertices[i].Plugin()).MethodByName(out[j].Method)
 				if !okk {
 					e.log.Warn("registered method doesn't exists ??")
@@ -143,7 +143,7 @@ func (e *Endure) init() error {
 	}
 
 	inactive := 0
-	for i := 0; i < len(vertices); i++ {
+	for i := range vertices {
 		if !vertices[i].IsActive() {
 			inactive++
 		}

registar/registar.go

@@ -41,7 +41,7 @@ func (r *Registar) Update(plugin any, tp reflect.Type, value func() reflect.Valu
 	// returned types
 	types := r.types[key].returnedTypes
 
-	for i := 0; i < len(types); i++ {
+	for i := range types {
 		if types[i].retType == tp {
 			types[i].value = value
 		}
@@ -56,7 +56,7 @@ func (r *Registar) Value(plugin any, tp reflect.Type) (reflect.Value, bool) {
 	// returned types
 	types := r.types[key].returnedTypes
 
-	for i := 0; i < len(types); i++ {
+	for i := range types {
 		if types[i].retType == tp {
 			return types[i].value(), true
 		}
@@ -75,7 +75,7 @@ func (r *Registar) TypeValue(plugin any, tp reflect.Type) (reflect.Value, bool)
 
 	retTp := r.types[key]
 
-	for i := 0; i < len(retTp.returnedTypes); i++ {
+	for i := range retTp.returnedTypes {
 		if retTp.returnedTypes[i].retType.Implements(tp) {
 			if retTp.returnedTypes[i].value == nil {
 				return reflect.Value{}, false
@@ -114,7 +114,7 @@ func (r *Registar) ImplementsExcept(tp reflect.Type, plugin any) []*implements {
 		}
 
 		// here we check that provides
-		for j := 0; j < len(entry.returnedTypes); j++ {
+		for j := range entry.returnedTypes {
 			provided := entry.returnedTypes[j]
 			if provided.retType.Implements(tp) {
 				impl = append(impl,

serve.go

@@ -25,7 +25,7 @@ func (e *Endure) serve() error {
 		return errors.E(errors.Str("error occurred, nothing to run"))
 	}
 
-	for i := 0; i < len(serveVertices); i++ {
+	for i := range serveVertices {
 		if !serveVertices[i].IsActive() {
 			continue
 		}