fix

Author: wxiaoguang

models/webhook/webhook.go

@@ -150,14 +150,7 @@ func init() {
 // AfterLoad updates the webhook object upon setting a column
 func (w *Webhook) AfterLoad() {
 	w.HookEvent = &webhook_module.HookEvent{}
-
-	events := w.Events
-	if events == "" {
-		// jsonv2 is unable to unmarshal an empty string
-		return
-	}
-
-	if err := json.Unmarshal([]byte(events), w.HookEvent); err != nil {
+	if err := json.Unmarshal([]byte(w.Events), w.HookEvent); err != nil {
 		log.Error("Unmarshal[%d]: %v", w.ID, err)
 	}
 }

modules/assetfs/embed.go

@@ -102,29 +102,12 @@ func NewEmbeddedFS(data []byte) fs.ReadDirFS {
 	efs := &embeddedFS{data: data, files: make(map[string]*embeddedFileInfo)}
 	efs.meta = sync.OnceValue(func() *EmbeddedMeta {
 		var meta EmbeddedMeta
-
-		// look for the separator newline between binary data and JSON metadata
-		// jsonv2 may end with an extra newline
 		p := bytes.LastIndexByte(data, '\n')
 		if p < 0 {
 			return &meta
 		}
-
-		// if the data ends with a newline, look for the previous newline
-		// to find the real separator
-		if p == len(data)-1 {
-			p = bytes.LastIndexByte(data[:p], '\n')
-			if p < 0 {
-				return &meta
-			}
-		}
-
-		jsonData := data[p+1:]
-		if err := json.Unmarshal(jsonData, &meta); err != nil {
-			panic("embedded file is not valid: " + err.Error())
-		}
-		if meta.Root == nil {
-			panic("embedded file metadata has nil root")
+		if err := json.Unmarshal(data[p+1:], &meta); err != nil {
+			panic("embedded file is not valid")
 		}
 		return &meta
 	})
@@ -167,15 +150,9 @@ func (e *embeddedFS) getFileInfo(fullName string) (*embeddedFileInfo, error) {
 
 	fields := strings.Split(fullName, "/")
 	fi = e.meta().Root
-	if fi == nil {
-		return nil, fs.ErrNotExist
-	}
 	if fullName != "." {
 		found := true
 		for _, field := range fields {
-			if fi.Children == nil {
-				return nil, fs.ErrNotExist
-			}
 			for _, child := range fi.Children {
 				if found = child.BaseName == field; found {
 					fi = child

modules/json/json.go

@@ -32,22 +32,12 @@ type Interface interface {
 }
 
 var (
-	// DefaultJSONHandler default json handler - uses JSON v2 if available, otherwise JSONiter
-	DefaultJSONHandler = getDefaultHandler()
+	DefaultJSONHandler = getDefaultJSONHandler()
 
 	_ Interface = StdJSON{}
 	_ Interface = JSONiter{}
-	_ Interface = JSONv2{}
 )
 
-// getDefaultHandler returns the expected JSON implementation
-func getDefaultHandler() Interface {
-	if isJSONv2Available() {
-		return JSONv2{}
-	}
-	return JSONiter{jsoniter.ConfigCompatibleWithStandardLibrary}
-}
-
 // StdJSON implements Interface via encoding/json
 type StdJSON struct{}
 
@@ -106,47 +96,6 @@ func (j JSONiter) Indent(dst *bytes.Buffer, src []byte, prefix, indent string) e
 	return json.Indent(dst, src, prefix, indent)
 }
 
-// JSONv2 implements Interface via encoding/json/v2
-// Requires GOEXPERIMENT=jsonv2 to be set at build time
-type JSONv2 struct{}
-
-// Marshal implements Interface using JSON v2 - fallback if v2 is not available
-func (JSONv2) Marshal(v any) ([]byte, error) {
-	if !isJSONv2Available() {
-		return json.Marshal(v)
-	}
-	return marshalV2(v)
-}
-
-// Unmarshal implements Interface using JSON v2 - fallback if v2 is not available
-func (JSONv2) Unmarshal(data []byte, v any) error {
-	if !isJSONv2Available() {
-		return json.Unmarshal(data, v)
-	}
-	return unmarshalV2(data, v)
-}
-
-// NewEncoder implements Interface using JSON v2 - fallback if v2 is not available
-func (JSONv2) NewEncoder(writer io.Writer) Encoder {
-	if !isJSONv2Available() {
-		return json.NewEncoder(writer)
-	}
-	return newEncoderV2(writer)
-}
-
-// NewDecoder implements Interface using JSON v2 - fallback if v2 is not available
-func (JSONv2) NewDecoder(reader io.Reader) Decoder {
-	if !isJSONv2Available() {
-		return json.NewDecoder(reader)
-	}
-	return newDecoderV2(reader)
-}
-
-// Indent implements Interface using standard library (JSON v2 doesn't have Indent yet)
-func (JSONv2) Indent(dst *bytes.Buffer, src []byte, prefix, indent string) error {
-	return json.Indent(dst, src, prefix, indent)
-}
-
 // Marshal converts object as bytes
 func Marshal(v any) ([]byte, error) {
 	return DefaultJSONHandler.Marshal(v)
@@ -174,7 +123,7 @@ func Indent(dst *bytes.Buffer, src []byte, prefix, indent string) error {
 
 // MarshalIndent copied from encoding/json
 func MarshalIndent(v any, prefix, indent string) ([]byte, error) {
-	b, err := DefaultJSONHandler.Marshal(v)
+	b, err := Marshal(v)
 	if err != nil {
 		return nil, err
 	}
@@ -200,12 +149,6 @@ func UnmarshalHandleDoubleEncode(bs []byte, v any) error {
 		// To be consistent, we should treat all empty inputs as success
 		return nil
 	}
-
-	trimmed := bytes.TrimSpace(bs)
-	if len(trimmed) == 0 {
-		return nil
-	}
-
 	err := DefaultJSONHandler.Unmarshal(bs, v)
 	if err != nil {
 		ok := true

modules/json/jsonlegacy.go

@@ -0,0 +1,9 @@
+//go:build !goexperiment.jsonv2
+
+package json
+
+import jsoniter "github.com/json-iterator/go"
+
+func getDefaultJSONHandler() Interface {
+	return JSONiter{jsoniter.ConfigCompatibleWithStandardLibrary}
+}

modules/json/jsonv2.go

@@ -11,95 +11,71 @@ import (
 	"io"
 )
 
-// isJSONv2Available returns true when JSON v2 is available (compiled with GOEXPERIMENT=jsonv2)
-func isJSONv2Available() bool {
-	return true
+// JSONv2 implements Interface via encoding/json/v2
+// Requires GOEXPERIMENT=jsonv2 to be set at build time
+type JSONv2 struct{}
+
+var _ Interface = JSONv2{}
+
+func getDefaultJSONHandler() Interface {
+	return JSONv2{}
 }
 
-// marshalV2Internal uses JSON v2 marshal with v1 compatibility options (no trailing newline)
-func marshalV2Internal(v any) ([]byte, error) {
-	opts := jsonv2.JoinOptions(
+func jsonv2DefaultMarshalOptions() jsonv2.Options {
+	return jsonv2.JoinOptions(
 		jsonv2.MatchCaseInsensitiveNames(true),
 		jsonv2.FormatNilSliceAsNull(true),
 		jsonv2.FormatNilMapAsNull(true),
 		jsonv2.Deterministic(true),
 	)
-	return jsonv2.Marshal(v, opts)
 }
 
-// marshalV2 uses JSON v2 marshal with v1 compatibility options (with trailing newline for compatibility with standard library)
-func marshalV2(v any) ([]byte, error) {
-	result, err := marshalV2Internal(v)
-	if err != nil {
-		return nil, err
-	}
-
-	return append(result, '\n'), nil
+func jsonv2DefaultUnmarshalOptions() jsonv2.Options {
+	return jsonv2.JoinOptions(
+		jsonv2.MatchCaseInsensitiveNames(true),
+	)
 }
 
-// unmarshalV2 uses JSON v2 unmarshal with v1 compatibility options
-func unmarshalV2(data []byte, v any) error {
-	if len(data) == 0 {
-		return nil
-	}
+func (JSONv2) Marshal(v any) ([]byte, error) {
+	return jsonv2.Marshal(v, jsonv2DefaultMarshalOptions())
+}
 
+func (JSONv2) Unmarshal(data []byte, v any) error {
+	// legacy behavior: treat empty or whitespace-only input as no input, it should be safe
 	data = bytes.TrimSpace(data)
 	if len(data) == 0 {
 		return nil
 	}
+	return jsonv2.Unmarshal(data, v, jsonv2DefaultUnmarshalOptions())
+}
 
-	opts := jsonv2.JoinOptions(
-		jsonv2.MatchCaseInsensitiveNames(true),
-	)
-	return jsonv2.Unmarshal(data, v, opts)
+func (JSONv2) NewEncoder(writer io.Writer) Encoder {
+	return &encoderV2{writer: writer, opts: jsonv2DefaultMarshalOptions()}
+}
+
+func (JSONv2) NewDecoder(reader io.Reader) Decoder {
+	return &decoderV2{reader: reader, opts: jsonv2DefaultMarshalOptions()}
+}
+
+// Indent implements Interface using standard library (JSON v2 doesn't have Indent yet)
+func (JSONv2) Indent(dst *bytes.Buffer, src []byte, prefix, indent string) error {
+	return json.Indent(dst, src, prefix, indent)
 }
 
-// encoderV2 wraps JSON v2 streaming encoder
 type encoderV2 struct {
 	writer io.Writer
 	opts   jsonv2.Options
 }
 
 func (e *encoderV2) Encode(v any) error {
-	err := jsonv2.MarshalWrite(e.writer, v, e.opts)
-	if err != nil {
-		return err
-	}
-
-	_, err = e.writer.Write([]byte{'\n'})
-	return err
+	return jsonv2.MarshalWrite(e.writer, v, e.opts)
 }
 
-// newEncoderV2 creates a new JSON v2 streaming encoder
-func newEncoderV2(writer io.Writer) Encoder {
-	opts := jsonv2.JoinOptions(
-		jsonv2.MatchCaseInsensitiveNames(true),
-		jsonv2.FormatNilSliceAsNull(true),
-		jsonv2.FormatNilMapAsNull(true),
-		jsonv2.Deterministic(true),
-	)
-	return &encoderV2{writer: writer, opts: opts}
-}
-
-// decoderV2 wraps JSON v2 streaming decoder
 type decoderV2 struct {
 	reader io.Reader
 	opts   jsonv2.Options
 }
 
 func (d *decoderV2) Decode(v any) error {
-	err := jsonv2.UnmarshalRead(d.reader, v, d.opts)
-	// Handle EOF more gracefully to match standard library behavior
-	if err != nil && err.Error() == "unexpected EOF" {
-		return io.EOF
-	}
-	return err
-}
-
-// newDecoderV2 creates a new JSON v2 streaming decoder
-func newDecoderV2(reader io.Reader) Decoder {
-	opts := jsonv2.JoinOptions(
-		jsonv2.MatchCaseInsensitiveNames(true),
-	)
-	return &decoderV2{reader: reader, opts: opts}
+	return jsonv2.UnmarshalRead(d.reader, v, d.opts)
 }

modules/json/jsonv2_fallback.go

@@ -142,13 +142,13 @@ func TestWebhookDeliverHookTask(t *testing.T) {
 			assert.NoError(t, err)
 			assert.Equal(t, `{"data": 42}`, string(body))
 
-		case "/webhook/4ddf3b1533e54f082ae6eadfc1b5530be36c8893":
+		case "/webhook/6db5dc1e282529a8c162c7fe93dd2667494eeb51":
 			// Version 2
 			assert.Equal(t, "push", r.Header.Get("X-GitHub-Event"))
 			assert.Equal(t, "application/json", r.Header.Get("Content-Type"))
 			body, err := io.ReadAll(r.Body)
 			assert.NoError(t, err)
-			assert.Len(t, body, 2047)
+			assert.Len(t, body, 2147)
 
 		default:
 			w.WriteHeader(http.StatusNotFound)

services/webhook/deliver_test.go

@@ -216,7 +216,7 @@ func TestMatrixJSONPayload(t *testing.T) {
 	require.NoError(t, err)
 
 	assert.Equal(t, "PUT", req.Method)
-	assert.Equal(t, "/_matrix/client/r0/rooms/ROOM_ID/send/m.room.message/4ddf3b1533e54f082ae6eadfc1b5530be36c8893", req.URL.Path)
+	assert.Equal(t, "/_matrix/client/r0/rooms/ROOM_ID/send/m.room.message/6db5dc1e282529a8c162c7fe93dd2667494eeb51", req.URL.Path)
 	assert.Equal(t, "sha256=", req.Header.Get("X-Hub-Signature-256"))
 	assert.Equal(t, "application/json", req.Header.Get("Content-Type"))
 	var body MatrixPayload

services/webhook/matrix_test.go

@@ -165,6 +165,6 @@ func TestPackageVagrant(t *testing.T) {
 		provider := version.Providers[0]
 		assert.Equal(t, packageProvider, provider.Name)
 		assert.Equal(t, "sha512", provider.ChecksumType)
-		assert.Equal(t, "c9967d88db2888a74778b5c62dbc2508921c8b54aca0e2ba34ab3e95e655cdb182bb2989b28e7ab4cab696f2ac7193d7ba9f57dea5191aad0c6a1082991c1ab8", provider.Checksum)
+		assert.Equal(t, "259bebd6160acad695016d22a45812e26f187aaf78e71a4c23ee3201528346293f991af3468a8c6c5d2a21d7d9e1bdc1bf79b87110b2fddfcc5a0d45963c7c30", provider.Checksum)
 	})
 }