Merge 312cd7c9bddf3280c4aac6b438221289e34a8182 into 2a794cd0b0faa7d829291375b27a3467ea972b0d

.github/workflows/gin.yml

@@ -65,7 +65,7 @@ jobs:
         with:
           ref: ${{ github.ref }}
 
-      - uses: actions/cache@v5
+      - uses: actions/cache@v4
         with:
           path: |
             ${{ matrix.go-build }}

context.go

@@ -55,6 +55,14 @@ const ContextRequestKey ContextKeyType = 0
 // abortIndex represents a typical value used in abort functions.
 const abortIndex int8 = math.MaxInt8 >> 1
 
+// safeInt8 converts int to int8 safely, capping at math.MaxInt8
+func safeInt8(n int) int8 {
+	if n > math.MaxInt8 {
+		return math.MaxInt8
+	}
+	return int8(n)
+}
+
 // Context is the most important part of gin. It allows us to pass variables between middleware,
 // manage the flow, validate the JSON of a request and render a JSON response for example.
 type Context struct {

debug.go

@@ -15,8 +15,6 @@ import (
 
 const ginSupportMinGoVer = 24
 
-var runtimeVersion = runtime.Version()
-
 // IsDebugging returns true if the framework is running in debug mode.
 // Use SetMode(gin.ReleaseMode) to disable debug mode.
 func IsDebugging() bool {
@@ -79,7 +77,7 @@ func getMinVer(v string) (uint64, error) {
 }
 
 func debugPrintWARNINGDefault() {
-	if v, e := getMinVer(runtimeVersion); e == nil && v < ginSupportMinGoVer {
+	if v, e := getMinVer(runtime.Version()); e == nil && v < ginSupportMinGoVer {
 		debugPrint(`[WARNING] Now Gin requires Go 1.24+.
 
 `)

debug_test.go

@@ -12,6 +12,7 @@ import (
 	"log"
 	"net/http"
 	"os"
+	"runtime"
 	"strings"
 	"sync"
 	"testing"
@@ -20,6 +21,10 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+// TODO
+// func debugRoute(httpMethod, absolutePath string, handlers HandlersChain) {
+// func debugPrint(format string, values ...any) {
+
 func TestIsDebugging(t *testing.T) {
 	SetMode(DebugMode)
 	assert.True(t, IsDebugging())
@@ -43,18 +48,6 @@ func TestDebugPrint(t *testing.T) {
 	assert.Equal(t, "[GIN-debug] these are 2 error messages\n", re)
 }
 
-func TestDebugPrintFunc(t *testing.T) {
-	DebugPrintFunc = func(format string, values ...any) {
-		fmt.Fprintf(DefaultWriter, "[GIN-debug] "+format, values...)
-	}
-	re := captureOutput(t, func() {
-		SetMode(DebugMode)
-		debugPrint("debug print func test: %d", 123)
-		SetMode(TestMode)
-	})
-	assert.Regexp(t, `^\[GIN-debug\] debug print func test: 123`, re)
-}
-
 func TestDebugPrintError(t *testing.T) {
 	re := captureOutput(t, func() {
 		SetMode(DebugMode)
@@ -111,17 +104,12 @@ func TestDebugPrintWARNINGDefault(t *testing.T) {
 		debugPrintWARNINGDefault()
 		SetMode(TestMode)
 	})
-	assert.Equal(t, "[GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.\n\n", re)
-}
-
-func TestDebugPrintWARNINGDefaultWithUnsupportedVersion(t *testing.T) {
-	runtimeVersion = "go1.23.12"
-	re := captureOutput(t, func() {
-		SetMode(DebugMode)
-		debugPrintWARNINGDefault()
-		SetMode(TestMode)
-	})
-	assert.Equal(t, "[GIN-debug] [WARNING] Now Gin requires Go 1.24+.\n\n[GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.\n\n", re)
+	m, e := getMinVer(runtime.Version())
+	if e == nil && m < ginSupportMinGoVer {
+		assert.Equal(t, "[GIN-debug] [WARNING] Now Gin requires Go 1.24+.\n\n[GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.\n\n", re)
+	} else {
+		assert.Equal(t, "[GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.\n\n", re)
+	}
 }
 
 func TestDebugPrintWARNINGNew(t *testing.T) {

recovery.go

@@ -5,9 +5,7 @@
 package gin
 
 import (
-	"bufio"
 	"bytes"
-	"cmp"
 	"errors"
 	"fmt"
 	"io"
@@ -23,10 +21,9 @@ import (
 	"github.com/gin-gonic/gin/internal/bytesconv"
 )
 
-const (
-	dunno     = "???"
-	stackSkip = 3
-)
+const dunno = "???"
+
+var dunnoBytes = []byte(dunno)
 
 // RecoveryFunc defines the function passable to CustomRecovery.
 type RecoveryFunc func(c *Context, err any)
@@ -75,6 +72,7 @@ func CustomRecoveryWithWriter(out io.Writer, handle RecoveryFunc) HandlerFunc {
 					brokenPipe = true
 				}
 				if logger != nil {
+					const stackSkip = 3
 					if brokenPipe {
 						logger.Printf("%s\n%s%s", err, secureRequestDump(c.Request), reset)
 					} else if IsDebugging() {
@@ -122,11 +120,8 @@ func stack(skip int) []byte {
 	buf := new(bytes.Buffer) // the returned data
 	// As we loop, we open files and read them. These variables record the currently
 	// loaded file.
-	var (
-		nLine    string
-		lastFile string
-		err      error
-	)
+	var lines [][]byte
+	var lastFile string
 	for i := skip; ; i++ { // Skip the expected number of frames
 		pc, file, line, ok := runtime.Caller(i)
 		if !ok {
@@ -135,44 +130,25 @@ func stack(skip int) []byte {
 		// Print this much at least.  If we can't find the source, it won't show.
 		fmt.Fprintf(buf, "%s:%d (0x%x)\n", file, line, pc)
 		if file != lastFile {
-			nLine, err = readNthLine(file, line-1)
+			data, err := os.ReadFile(file)
 			if err != nil {
 				continue
 			}
+			lines = bytes.Split(data, []byte{'\n'})
 			lastFile = file
 		}
-		fmt.Fprintf(buf, "\t%s: %s\n", function(pc), cmp.Or(nLine, dunno))
+		fmt.Fprintf(buf, "\t%s: %s\n", function(pc), source(lines, line))
 	}
 	return buf.Bytes()
 }
 
-// readNthLine reads the nth line from the file.
-// It returns the trimmed content of the line if found,
-// or an empty string if the line doesn't exist.
-// If there's an error opening the file, it returns the error.
-func readNthLine(file string, n int) (string, error) {
-	if n < 0 {
-		return "", nil
+// source returns a space-trimmed slice of the n'th line.
+func source(lines [][]byte, n int) []byte {
+	n-- // in stack trace, lines are 1-indexed but our array is 0-indexed
+	if n < 0 || n >= len(lines) {
+		return dunnoBytes
 	}
-
-	f, err := os.Open(file)
-	if err != nil {
-		return "", err
-	}
-	defer f.Close()
-
-	scanner := bufio.NewScanner(f)
-	for i := 0; i < n; i++ {
-		if !scanner.Scan() {
-			return "", nil
-		}
-	}
-
-	if scanner.Scan() {
-		return strings.TrimSpace(scanner.Text()), nil
-	}
-
-	return "", nil
+	return bytes.TrimSpace(lines[n])
 }
 
 // function returns, if possible, the name of the function containing the PC.

recovery_test.go

@@ -88,6 +88,21 @@ func TestPanicWithAbort(t *testing.T) {
 	assert.Equal(t, http.StatusBadRequest, w.Code)
 }
 
+func TestSource(t *testing.T) {
+	bs := source(nil, 0)
+	assert.Equal(t, dunnoBytes, bs)
+
+	in := [][]byte{
+		[]byte("Hello world."),
+		[]byte("Hi, gin.."),
+	}
+	bs = source(in, 10)
+	assert.Equal(t, dunnoBytes, bs)
+
+	bs = source(in, 1)
+	assert.Equal(t, []byte("Hello world."), bs)
+}
+
 func TestFunction(t *testing.T) {
 	bs := function(1)
 	assert.Equal(t, dunno, bs)
@@ -316,53 +331,3 @@ func TestSecureRequestDump(t *testing.T) {
 		})
 	}
 }
-
-// TestReadNthLine tests the readNthLine function with various scenarios.
-func TestReadNthLine(t *testing.T) {
-	// Create a temporary test file
-	testContent := "line 0 \n line 1  \nline 2 \nline 3  \nline 4"
-	tempFile, err := os.CreateTemp("", "testfile*.txt")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.Remove(tempFile.Name())
-
-	// Write test content to the temporary file
-	if _, err := tempFile.WriteString(testContent); err != nil {
-		t.Fatal(err)
-	}
-	if err := tempFile.Close(); err != nil {
-		t.Fatal(err)
-	}
-
-	// Test cases
-	tests := []struct {
-		name     string
-		lineNum  int
-		fileName string
-		want     string
-		wantErr  bool
-	}{
-		{name: "Read first line", lineNum: 0, fileName: tempFile.Name(), want: "line 0", wantErr: false},
-		{name: "Read middle line", lineNum: 2, fileName: tempFile.Name(), want: "line 2", wantErr: false},
-		{name: "Read last line", lineNum: 4, fileName: tempFile.Name(), want: "line 4", wantErr: false},
-		{name: "Line number exceeds file length", lineNum: 10, fileName: tempFile.Name(), want: "", wantErr: false},
-		{name: "Negative line number", lineNum: -1, fileName: tempFile.Name(), want: "", wantErr: false},
-		{name: "Non-existent file", lineNum: 1, fileName: "/non/existent/file.txt", want: "", wantErr: true},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got, err := readNthLine(tt.fileName, tt.lineNum)
-			assert.Equal(t, tt.wantErr, err != nil)
-			assert.Equal(t, tt.want, got)
-		})
-	}
-}
-
-func BenchmarkStack(b *testing.B) {
-	b.ReportAllocs()
-	for b.Loop() {
-		_ = stack(stackSkip)
-	}
-}

response_writer.go

@@ -128,9 +128,7 @@ func (w *responseWriter) CloseNotify() <-chan bool {
 // Flush implements the http.Flusher interface.
 func (w *responseWriter) Flush() {
 	w.WriteHeaderNow()
-	if f, ok := w.ResponseWriter.(http.Flusher); ok {
-		f.Flush()
-	}
+	w.ResponseWriter.(http.Flusher).Flush()
 }
 
 func (w *responseWriter) Pusher() (pusher http.Pusher) {

tree.go

@@ -5,6 +5,7 @@
 package gin
 
 import (
+	"math"
 	"net/url"
 	"strings"
 	"unicode"
@@ -77,6 +78,14 @@ func (n *node) addChild(child *node) {
 	}
 }
 
+// safeUint16 converts int to uint16 safely, capping at math.MaxUint16
+func safeUint16(n int) uint16 {
+	if n > math.MaxUint16 {
+		return math.MaxUint16
+	}
+	return uint16(n)
+}
+
 func countParams(path string) uint16 {
 	colons := strings.Count(path, ":")
 	stars := strings.Count(path, "*")

utils.go

@@ -6,7 +6,6 @@ package gin
 
 import (
 	"encoding/xml"
-	"math"
 	"net/http"
 	"os"
 	"path"
@@ -163,19 +162,3 @@ func isASCII(s string) bool {
 	}
 	return true
 }
-
-// safeInt8 converts int to int8 safely, capping at math.MaxInt8
-func safeInt8(n int) int8 {
-	if n > math.MaxInt8 {
-		return math.MaxInt8
-	}
-	return int8(n)
-}
-
-// safeUint16 converts int to uint16 safely, capping at math.MaxUint16
-func safeUint16(n int) uint16 {
-	if n > math.MaxUint16 {
-		return math.MaxUint16
-	}
-	return uint16(n)
-}

utils_test.go

@@ -8,7 +8,6 @@ import (
 	"bytes"
 	"encoding/xml"
 	"fmt"
-	"math"
 	"net/http"
 	"testing"
 
@@ -149,13 +148,3 @@ func TestIsASCII(t *testing.T) {
 	assert.True(t, isASCII("test"))
 	assert.False(t, isASCII("🧡💛💚💙💜"))
 }
-
-func TestSafeInt8(t *testing.T) {
-	assert.Equal(t, int8(100), safeInt8(100))
-	assert.Equal(t, int8(math.MaxInt8), safeInt8(int(math.MaxInt8)+123))
-}
-
-func TestSafeUint16(t *testing.T) {
-	assert.Equal(t, uint16(100), safeUint16(100))
-	assert.Equal(t, uint16(math.MaxUint16), safeUint16(int(math.MaxUint16)+123))
-}