Merge pull request #69 from shamaton/fix/v2-format

Format v2 branch files

Author: shamaton

.github/workflows/test.yml

@@ -14,7 +14,7 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest, macos-latest, windows-latest]
-        go: ['1.22', '1.23', '1.24']
+        go: ["1.22", "1.23", "1.24"]
     name: ${{ matrix.os }} @ Go ${{ matrix.go }}
     runs-on: ${{ matrix.os }}
     steps:
@@ -36,7 +36,6 @@ jobs:
           restore-keys: |
             ${{ runner.os }}-go-
 
-
       - name: Build
         run: go build -v ./...
 

README.md

@@ -7,11 +7,13 @@
 [![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2Fshamaton%2Fmsgpack.svg?type=shield)](https://app.fossa.com/projects/git%2Bgithub.com%2Fshamaton%2Fmsgpack?ref=badge_shield)
 
 ## 📣 Announcement: `time.Time` decoding defaults to **UTC** in v3
+
 Starting with **v3.0.0**, when decoding MessagePack **Timestamp** into Go’s `time.Time`,
 the default `Location` will be **UTC** (previously `Local`). The instant is unchanged.
 To keep the old behavior, use `SetDecodedTimeAsLocal()`.
 
 ## Features
+
 * Supported types : primitive / array / slice / struct / map / interface{} and time.Time
 * Renaming fields via `msgpack:"field_name"`
 * Omitting fields via `msgpack:"-"`
@@ -22,11 +24,13 @@ To keep the old behavior, use `SetDecodedTimeAsLocal()`.
 ## Installation
 
 Current version is **msgpack/v2**.
+
 ```sh
 go get -u github.com/shamaton/msgpack/v2
 ```
 
 ## Quick Start
+
 ```go
 package main
 
@@ -36,36 +40,36 @@ import (
 )
 
 type Struct struct {
-	String string
+  String string
 }
 
 // simple
 func main() {
-	v := Struct{String: "msgpack"}
-
-	d, err := msgpack.Marshal(v)
-	if err != nil {
-		panic(err)
-	}
-	r := Struct{}
-	if err =  msgpack.Unmarshal(d, &r); err != nil {
-		panic(err)
-	}
+  v := Struct{String: "msgpack"}
+
+  d, err := msgpack.Marshal(v)
+    if err != nil {
+      panic(err)
+  }
+  r := Struct{}
+  if err =  msgpack.Unmarshal(d, &r); err != nil {
+    panic(err)
+  }
 }
 
 // streaming
 func handle(w http.ResponseWriter, r *http.Request) {
-	var body Struct
-	if err := msgpack.UnmarshalRead(r, &body); err != nil {
-		panic(err)
-    }
-	if err := msgpack.MarshalWrite(w, body); err != nil {
-		panic(err)
-    }
+  var body Struct
+  if err := msgpack.UnmarshalRead(r, &body); err != nil {
+    panic(err)
+  }
+  if err := msgpack.MarshalWrite(w, body); err != nil {
+    panic(err)
+  }
 }
 ```
 
-## 📣 Announcement: `time.Time` decoding defaults to **UTC** in v3
+## v3: `time.Time` decoding defaults to **UTC**
 
 **TL;DR:** Starting with **v3.0.0**, when decoding MessagePack **Timestamp** into Go’s `time.Time`, the default `Location` will be **UTC** (previously `Local`). The **instant** is unchanged—only the display/location changes. This avoids host-dependent differences and aligns with common distributed systems practice.
 
@@ -111,6 +115,7 @@ msgpack.SetDecodedTimeAsUTC()
 ```
 
 ## Benchmark
+
 This result made from [shamaton/msgpack_bench](https://github.com/shamaton/msgpack_bench)
 
 ![msgpack_bench](https://github.com/user-attachments/assets/ed5bc4c5-a149-4083-98b8-ee6820c00eae)

crash_test.go

@@ -45,7 +45,8 @@ func check(t *testing.T, wg *sync.WaitGroup, ch <-chan string) {
 	defer wg.Done()
 	defer func() {
 		if e := recover(); e != nil {
-			t.Logf("panic occurred.\nfile: %s\nlen: %d\nbin: % x\nerr: %+v",
+			t.Logf(
+				"panic occurred.\nfile: %s\nlen: %d\nbin: % x\nerr: %+v",
 				path, len(data), data, e,
 			)
 		}
@@ -74,7 +75,8 @@ func check(t *testing.T, wg *sync.WaitGroup, ch <-chan string) {
 		var r interface{}
 		err = msgpack.Unmarshal(data, &r)
 		if err == nil {
-			t.Logf("err should be occurred.\nname: %s\nlen: %d\nbin: % x",
+			t.Logf(
+				"err should be occurred.\nname: %s\nlen: %d\nbin: % x",
 				file.Name(), len(data), data,
 			)
 			t.Fail()

ext/decode.go

@@ -23,8 +23,7 @@ type Decoder interface {
 }
 
 // DecoderCommon provides common utility methods for decoding data from bytes.
-type DecoderCommon struct {
-}
+type DecoderCommon struct{}
 
 // ReadSize1 reads a single byte from the given index in the byte slice.
 // Returns the byte and the new index after reading.

ext/encode.go

@@ -26,8 +26,7 @@ type Encoder interface {
 // EncoderCommon provides utility methods for encoding various types of values into bytes.
 // It includes methods to encode integers and unsigned integers of different sizes,
 // as well as methods to write raw byte slices into a target byte slice.
-type EncoderCommon struct {
-}
+type EncoderCommon struct{}
 
 // SetByte1Int64 encodes a single byte from the given int64 value into the byte slice at the specified offset.
 // Returns the new offset after writing the byte.

ext/encode_stream.go

@@ -32,22 +32,25 @@ func CreateStreamWriter(w io.Writer, buf *common.Buffer) StreamWriter {
 
 // WriteByte1Int64 writes a single byte representation of an int64 value.
 func (w *StreamWriter) WriteByte1Int64(value int64) error {
-	return w.buf.Write(w.w,
+	return w.buf.Write(
+		w.w,
 		byte(value),
 	)
 }
 
 // WriteByte2Int64 writes a two-byte representation of an int64 value.
 func (w *StreamWriter) WriteByte2Int64(value int64) error {
-	return w.buf.Write(w.w,
+	return w.buf.Write(
+		w.w,
 		byte(value>>8),
 		byte(value),
 	)
 }
 
 // WriteByte4Int64 writes a four-byte representation of an int64 value.
 func (w *StreamWriter) WriteByte4Int64(value int64) error {
-	return w.buf.Write(w.w,
+	return w.buf.Write(
+		w.w,
 		byte(value>>24),
 		byte(value>>16),
 		byte(value>>8),
@@ -57,7 +60,8 @@ func (w *StreamWriter) WriteByte4Int64(value int64) error {
 
 // WriteByte8Int64 writes an eight-byte representation of an int64 value.
 func (w *StreamWriter) WriteByte8Int64(value int64) error {
-	return w.buf.Write(w.w,
+	return w.buf.Write(
+		w.w,
 		byte(value>>56),
 		byte(value>>48),
 		byte(value>>40),
@@ -71,22 +75,25 @@ func (w *StreamWriter) WriteByte8Int64(value int64) error {
 
 // WriteByte1Uint64 writes a single byte representation of a uint64 value.
 func (w *StreamWriter) WriteByte1Uint64(value uint64) error {
-	return w.buf.Write(w.w,
+	return w.buf.Write(
+		w.w,
 		byte(value),
 	)
 }
 
 // WriteByte2Uint64 writes a two-byte representation of a uint64 value.
 func (w *StreamWriter) WriteByte2Uint64(value uint64) error {
-	return w.buf.Write(w.w,
+	return w.buf.Write(
+		w.w,
 		byte(value>>8),
 		byte(value),
 	)
 }
 
 // WriteByte4Uint64 writes a four-byte representation of a uint64 value.
 func (w *StreamWriter) WriteByte4Uint64(value uint64) error {
-	return w.buf.Write(w.w,
+	return w.buf.Write(
+		w.w,
 		byte(value>>24),
 		byte(value>>16),
 		byte(value>>8),
@@ -96,7 +103,8 @@ func (w *StreamWriter) WriteByte4Uint64(value uint64) error {
 
 // WriteByte8Uint64 writes an eight-byte representation of a uint64 value.
 func (w *StreamWriter) WriteByte8Uint64(value uint64) error {
-	return w.buf.Write(w.w,
+	return w.buf.Write(
+		w.w,
 		byte(value>>56),
 		byte(value>>48),
 		byte(value>>40),
@@ -110,22 +118,25 @@ func (w *StreamWriter) WriteByte8Uint64(value uint64) error {
 
 // WriteByte1Int writes a single byte representation of an int value.
 func (w *StreamWriter) WriteByte1Int(value int) error {
-	return w.buf.Write(w.w,
+	return w.buf.Write(
+		w.w,
 		byte(value),
 	)
 }
 
 // WriteByte2Int writes a two-byte representation of an int value.
 func (w *StreamWriter) WriteByte2Int(value int) error {
-	return w.buf.Write(w.w,
+	return w.buf.Write(
+		w.w,
 		byte(value>>8),
 		byte(value),
 	)
 }
 
 // WriteByte4Int writes a four-byte representation of an int value.
 func (w *StreamWriter) WriteByte4Int(value int) error {
-	return w.buf.Write(w.w,
+	return w.buf.Write(
+		w.w,
 		byte(value>>24),
 		byte(value>>16),
 		byte(value>>8),
@@ -135,7 +146,8 @@ func (w *StreamWriter) WriteByte4Int(value int) error {
 
 // WriteByte4Uint32 writes a four-byte representation of a uint32 value.
 func (w *StreamWriter) WriteByte4Uint32(value uint32) error {
-	return w.buf.Write(w.w,
+	return w.buf.Write(
+		w.w,
 		byte(value>>24),
 		byte(value>>16),
 		byte(value>>8),

internal/common/common.go

@@ -6,8 +6,7 @@ import (
 )
 
 // Common is used encoding/decoding
-type Common struct {
-}
+type Common struct{}
 
 // CheckField returns flag whether should encode/decode or not and field name
 func (c *Common) CheckField(field reflect.StructField) (public, omit bool, name string) {

internal/decoding/bool_test.go

@@ -1,9 +1,10 @@
 package decoding
 
 import (
-	"github.com/shamaton/msgpack/v2/def"
 	"reflect"
 	"testing"
+
+	"github.com/shamaton/msgpack/v2/def"
 )
 
 func Test_asBool(t *testing.T) {

internal/decoding/complex_test.go

@@ -62,8 +62,10 @@ func Test_asComplex64(t *testing.T) {
 		},
 		{
 			Name: "Fixext16.ok",
-			Data: []byte{def.Fixext16, byte(def.ComplexTypeCode()),
-				63, 240, 0, 0, 0, 0, 0, 0, 63, 240, 0, 0, 0, 0, 0, 0},
+			Data: []byte{
+				def.Fixext16, byte(def.ComplexTypeCode()),
+				63, 240, 0, 0, 0, 0, 0, 0, 63, 240, 0, 0, 0, 0, 0, 0,
+			},
 			Expected: complex(1, 1),
 			MethodAs: method,
 		},
@@ -132,8 +134,10 @@ func Test_asComplex128(t *testing.T) {
 		},
 		{
 			Name: "Fixext16.ok",
-			Data: []byte{def.Fixext16, byte(def.ComplexTypeCode()),
-				63, 240, 0, 0, 0, 0, 0, 0, 63, 240, 0, 0, 0, 0, 0, 0},
+			Data: []byte{
+				def.Fixext16, byte(def.ComplexTypeCode()),
+				63, 240, 0, 0, 0, 0, 0, 0, 63, 240, 0, 0, 0, 0, 0, 0,
+			},
 			Expected: complex(1, 1),
 			MethodAs: method,
 		},

internal/decoding/decoding_test.go

@@ -714,7 +714,7 @@ func Test_decodeWithCode(t *testing.T) {
 				MethodAs: method,
 			},
 		}
-		v := (any)(new(int))
+		v := any(new(int))
 		target = &v
 		testcases.Run(t)
 		vv := v.(*int)