⚡ ⚡ Improved performance by a significant margin.

✅ Updated tests.

Author: kaynetik

annotations.go

@@ -144,10 +144,6 @@ func mapIfLineContainsOASTag(lineText string, o *OAS) {
 	}
 }
 
-// Begin of oasAnnotations section.
-// This section is used mostly to abstract upon the []string,
-// so that future implementations are less susceptible to breaking changes.
-
 type oasAnnotations []string
 
 func (oa oasAnnotations) getHandlerFuncName() string {
@@ -161,5 +157,3 @@ func (oa oasAnnotations) getRoute() string {
 func (oa oasAnnotations) getHTTPMethod() string {
 	return oa[4]
 }
-
-// End of oasAnnotations section.

annotations_test.go

@@ -2,8 +2,13 @@ package docs
 
 import (
 	"errors"
+	"math/rand"
+	"os"
 	"path/filepath"
+	"reflect"
+	"runtime"
 	"testing"
+	"testing/quick"
 )
 
 const (
@@ -13,7 +18,7 @@ const (
 func TestUnitMapAnnotationsInPath(t *testing.T) {
 	t.Parallel()
 
-	o := prepForInitCallStack(t, false)
+	o := prepForInitCallStack(t)
 
 	_ = o.MapAnnotationsInPath(examplesDir)
 }
@@ -61,7 +66,7 @@ func TestUnitScanForChangesInPathErrWalk(t *testing.T) {
 		t.Error("expected an error, got none")
 	}
 
-	o := prepForInitCallStack(t, false)
+	o := prepForInitCallStack(t)
 	errConfig := configAnnotation{
 		getWD: wdErr,
 	}
@@ -80,3 +85,67 @@ func TestUnitScanForChangesInPathErrWalk(t *testing.T) {
 		t.Error("expected an error, got none")
 	}
 }
+
+type triggerNil struct {
+	trigger bool
+}
+
+func TestQuickUnitGetWD(t *testing.T) {
+	t.Parallel()
+
+	config := quick.Config{
+		Values: func(values []reflect.Value, rand *rand.Rand) {
+			ca := configAnnotation{}
+			rndNm := rand.Int()
+			tn := triggerNil{trigger: false}
+			if rndNm%2 == 0 {
+				tn.trigger = true
+				ca.getWD = func() (dir string, err error) {
+					return "", nil
+				}
+			} else {
+				ca.getWD = os.Getwd
+			}
+
+			values[0] = reflect.ValueOf(ca)
+			values[1] = reflect.ValueOf(tn)
+		},
+	}
+
+	gwdFetcher := func(ca configAnnotation, tn triggerNil) bool {
+		got := ca.getCurrentDirFetcher()
+
+		return reflect.TypeOf(got) == reflect.TypeOf(ca.getWD)
+	}
+
+	if err := quick.Check(gwdFetcher, &config); err != nil {
+		t.Errorf("Check failed: %#v", err)
+	}
+}
+
+func TestUnitGWD(t *testing.T) {
+	t.Parallel()
+
+	ca := configAnnotation{
+		getWD: func() (dir string, err error) {
+			return "", nil
+		},
+	}
+
+	got := ca.getCurrentDirFetcher()
+	if reflect.TypeOf(got) != reflect.TypeOf(ca.getWD) {
+		t.Error("functions differ")
+	}
+
+	caNil := configAnnotation{}.getCurrentDirFetcher()
+
+	if gFnName(t, caNil) != gFnName(t, os.Getwd) {
+		t.Error("functions differ")
+	}
+}
+
+func gFnName(t *testing.T, i interface{}) string {
+	t.Helper()
+
+	return runtime.FuncForPC(reflect.ValueOf(i).Pointer()).Name()
+}

build.go

@@ -36,10 +36,7 @@ func getPathFromFirstElement(cbs []ConfigBuilder) string {
 //
 // Returns an error if there is any.
 func (o *OAS) BuildDocs(conf ...ConfigBuilder) error {
-	err := o.initCallStackForRoutes()
-	if err != nil {
-		return fmt.Errorf("failed initiating call stack for registered routes: %w", err)
-	}
+	o.initCallStackForRoutes()
 
 	yml, err := marshalToYAML(o)
 	if err != nil {

build_test.go

@@ -5,7 +5,7 @@ import "testing"
 func TestUnitBuild(t *testing.T) {
 	t.Parallel()
 
-	oasPrep := prepForInitCallStack(t, false)
+	oasPrep := prepForInitCallStack(t)
 
 	setInfoForTest(t, &oasPrep.Info)
 	setPathForTest(t, &oasPrep.Paths[0])

caller.go

@@ -1,42 +1,27 @@
 package docs
 
 import (
-	"fmt"
 	"reflect"
 )
 
-func (o *OAS) Call(name string, params ...interface{}) (result []reflect.Value, err error) {
-	f := reflect.ValueOf(o.RegisteredRoutes[name])
-	paramNum := len(params)
-	fnParamNum := f.Type().NumIn()
+// routePostfix will get exported by v1.3.
+const routePostfix = "Route"
 
-	if paramNum != fnParamNum {
-		return result, fmt.Errorf(
-			"param number differs -> expected %d, got %d",
-			paramNum, fnParamNum,
-		)
-	}
+func (o *OAS) Call(name string, params ...interface{}) (result []reflect.Value) {
+	f := reflect.ValueOf(o.RegisteredRoutes[name])
 
-	in := make([]reflect.Value, paramNum)
+	in := make([]reflect.Value, len(params))
 	for k, param := range params {
 		in[k] = reflect.ValueOf(param)
 	}
 
 	result = f.Call(in)
 
-	return result, nil
+	return result
 }
 
-// should this be flexible for change?
-const routePostfix = "Route"
-
-func (o *OAS) initCallStackForRoutes() error {
-	for oasPathIndex, oasPath := range o.Paths { //nolint:gocritic //fixme: troubleshoot if this will be an issue.
-		_, err := o.Call(oasPath.HandlerFuncName+routePostfix, oasPathIndex, o)
-		if err != nil {
-			return fmt.Errorf(" :%w", err)
-		}
+func (o *OAS) initCallStackForRoutes() {
+	for oasPathIndex := range o.Paths {
+		o.Call(o.Paths[oasPathIndex].HandlerFuncName+routePostfix, oasPathIndex, o)
 	}
-
-	return nil
 }

caller_test.go

@@ -9,58 +9,10 @@ import (
 
 const testingPostfix = "Testing"
 
-func TestQuickUnitCallerErr(t *testing.T) {
-	t.Parallel()
-
-	config := quick.Config{
-		Values: func(args []reflect.Value, rand *rand.Rand) {
-			rr := make(RegRoutes)
-			count := rand.Intn(550-1) + 1
-			paths := getPaths(t, count, RandomString(t, count))
-
-			for _, p := range paths {
-				rr[p.Route+testingPostfix] = getPaths
-			}
-
-			oas := OAS{
-				Paths:            getPaths(t, count, RandomString(t, count)),
-				RegisteredRoutes: rr,
-			}
-
-			var routes []interface{}
-			for _, r := range rr {
-				routes = append(routes, r)
-			}
-
-			args[0] = reflect.ValueOf(oas)
-			args[1] = reflect.ValueOf(routes)
-		},
-	}
-
-	callerWrongParamNumber := func(oas OAS, routes []interface{}) bool {
-		oas.AttachRoutes(routes)
-
-		for oasPathIndex := range oas.Paths {
-			_, err := oas.Call("getPaths", oasPathIndex, oas)
-			if err == nil {
-				t.Errorf("failing (OAS).Call() with err : %s", err)
-
-				return false
-			}
-		}
-
-		return true
-	}
-
-	if err := quick.Check(callerWrongParamNumber, &config); err != nil {
-		t.Errorf("Check failed: %#v", err)
-	}
-}
-
 func TestQuickUnitCaller(t *testing.T) {
 	t.Parallel()
 
-	successParamNumber := func(name string, oas *OAS) {}
+	successParamNumber := func(i int, oas *OAS) {}
 	config := quick.Config{
 		Values: func(args []reflect.Value, rand *rand.Rand) {
 			rr := make(RegRoutes)
@@ -81,10 +33,11 @@ func TestQuickUnitCaller(t *testing.T) {
 	}
 
 	callerCorrectParamNumber := func(oas OAS) bool {
-		for _, oasPath := range oas.Paths {
-			_, err := oas.Call(oasPath.Route+testingPostfix, oasPath.Route, &oas)
-			if err != nil {
-				t.Errorf("failed executing (OAS).Call() with err : %s", err)
+		for i, oasPath := range oas.Paths {
+			res := oas.Call(oasPath.Route+testingPostfix, i, &oas)
+
+			if len(res) > 0 {
+				t.Error("failed executing (OAS).Call() with")
 
 				return false
 			}
@@ -101,7 +54,7 @@ func TestQuickUnitCaller(t *testing.T) {
 func TestUnitCaller(t *testing.T) {
 	t.Parallel()
 
-	successParamNumber := func(name string, oas *OAS) {}
+	successParamNumber := func(i int, oas *OAS) {}
 	routeName := "testRouteTesting"
 	rr := make(RegRoutes)
 	rr[routeName] = successParamNumber
@@ -110,45 +63,24 @@ func TestUnitCaller(t *testing.T) {
 		RegisteredRoutes: rr,
 	}
 
-	_, err := o.Call(routeName, routeName, &o)
-	if err != nil {
-		t.Errorf("failed executing (OAS).Call() with err : %s", err)
-	}
+	_ = o.Call(routeName, 0, &o)
 }
 
 func TestUnitInitCallStack(t *testing.T) {
 	t.Parallel()
 
-	o := prepForInitCallStack(t, false)
+	o := prepForInitCallStack(t)
 
-	err := o.initCallStackForRoutes()
-	if err != nil {
-		t.Errorf("failed executing (OAS).initCallStackForRoutes() with err : %s", err)
-	}
+	o.initCallStackForRoutes()
 }
 
-func TestUnitInitCallStackErr(t *testing.T) {
-	t.Parallel()
-
-	o := prepForInitCallStack(t, true)
-
-	err := o.initCallStackForRoutes()
-	if err == nil {
-		t.Errorf("failed executing (OAS).initCallStackForRoutes() with err : %s", err)
-	}
-}
-
-func prepForInitCallStack(t *testing.T, triggerErr bool) OAS {
+func prepForInitCallStack(t *testing.T) OAS {
 	t.Helper()
 
 	routeName := "testRoute" + routePostfix
 	rr := make(RegRoutes)
 
-	if !triggerErr {
-		rr[routeName] = getSuccessParamNumber
-	} else {
-		rr[routeName] = getFailureParamNumber
-	}
+	rr[routeName] = getSuccessParamNumber
 
 	path := Path{
 		HandlerFuncName: "testRoute",
@@ -161,5 +93,6 @@ func prepForInitCallStack(t *testing.T, triggerErr bool) OAS {
 	return o
 }
 
-func getSuccessParamNumber(_ int, _ *OAS)               {}
-func getFailureParamNumber(t *testing.T, _ int, _ *OAS) { t.Helper() }
+func getSuccessParamNumber(_ int, _ *OAS) {}
+
+// func getFailureParamNumber(t *testing.T, _ int, _ *OAS) { t.Helper() }

routing.go

@@ -11,7 +11,8 @@ type (
 	RouteFn func(index int, oas *OAS)
 
 	// RegRoutes represent a map of RouteFn's.
-	// TODO: Will this get Deprecated?
+	//
+	// Note: Considering to un-export it.
 	RegRoutes map[string]RouteFn
 )