fix: follow golangci-lint

Signed-off-by: Zxilly <[email protected]>

internal/diff/diff.go

@@ -24,23 +24,23 @@ const (
 	changeTypeChange changeType = "change"
 )
 
-type DiffBase struct {
+type Base struct {
 	Name       string     `json:"name"`
 	From       int64      `json:"from"`
 	To         int64      `json:"to"`
 	ChangeType changeType `json:"change_type"`
 }
 
-func diffBaseCmp(a, b DiffBase) int {
+func diffBaseCmp(a, b Base) int {
 	return -cmp.Compare(a.To-a.From, b.To-b.From)
 }
 
 type diffPackage struct {
-	DiffBase
+	Base
 }
 
 type diffSection struct {
-	DiffBase
+	Base
 	OldFileSize  int64 `json:"old_file_size"`
 	OldKnownSize int64 `json:"old_known_size"`
 	NewFileSize  int64 `json:"new_file_size"`
@@ -59,19 +59,19 @@ func processPackages(newPackages, oldPackages map[string]commonPackage) (ret []d
 			fromSize = oldV.Size
 		}
 		ret = append(ret, diffPackage{
-			DiffBase: DiffBase{Name: k, From: fromSize, To: v.Size, ChangeType: typ},
+			Base: Base{Name: k, From: fromSize, To: v.Size, ChangeType: typ},
 		})
 	}
 
 	for k, v := range oldPackages {
 		if _, ok := newPackages[k]; !ok {
 			ret = append(ret, diffPackage{
-				DiffBase: DiffBase{Name: k, From: v.Size, To: 0, ChangeType: changeTypeRemove},
+				Base: Base{Name: k, From: v.Size, To: 0, ChangeType: changeTypeRemove},
 			})
 		}
 	}
 
-	return
+	return ret
 }
 
 func processSections(newSections, oldSections []commonSection) (ret []diffSection) {
@@ -100,7 +100,7 @@ func processSections(newSections, oldSections []commonSection) (ret []diffSectio
 		}
 
 		ret = append(ret, diffSection{
-			DiffBase:     DiffBase{Name: k, From: fromSize, To: v.UnknownSize(), ChangeType: typ},
+			Base:         Base{Name: k, From: fromSize, To: v.UnknownSize(), ChangeType: typ},
 			OldFileSize:  fromFileSize,
 			OldKnownSize: fromKnownSize,
 			NewFileSize:  v.FileSize,
@@ -111,14 +111,14 @@ func processSections(newSections, oldSections []commonSection) (ret []diffSectio
 	for k, v := range oldSectionsMap {
 		if _, ok := newSectionsMap[k]; !ok {
 			ret = append(ret, diffSection{
-				DiffBase:     DiffBase{Name: k, From: v.UnknownSize(), To: 0, ChangeType: changeTypeRemove},
+				Base:         Base{Name: k, From: v.UnknownSize(), To: 0, ChangeType: changeTypeRemove},
 				OldFileSize:  v.FileSize,
 				OldKnownSize: v.KnownSize,
 			})
 		}
 	}
 
-	return
+	return ret
 }
 
 func newDiffResult(newResult, oldResult *commonResult) diffResult {
@@ -133,10 +133,10 @@ func newDiffResult(newResult, oldResult *commonResult) diffResult {
 	}
 
 	slices.SortFunc(ret.Packages, func(a, b diffPackage) int {
-		return diffBaseCmp(a.DiffBase, b.DiffBase)
+		return diffBaseCmp(a.Base, b.Base)
 	})
 	slices.SortFunc(ret.Sections, func(a, b diffSection) int {
-		return diffBaseCmp(a.DiffBase, b.DiffBase)
+		return diffBaseCmp(a.Base, b.Base)
 	})
 
 	return ret

internal/diff/diff_test.go

@@ -17,9 +17,9 @@ func TestProcessPackages(t *testing.T) {
 	}
 
 	expected := []diffPackage{
-		{DiffBase{Name: "pkg1", From: 100, To: 150, ChangeType: changeTypeChange}},
-		{DiffBase{Name: "pkg3", From: 0, To: 300, ChangeType: changeTypeAdd}},
-		{DiffBase{Name: "pkg2", From: 200, To: 0, ChangeType: changeTypeRemove}},
+		{Base{Name: "pkg1", From: 100, To: 150, ChangeType: changeTypeChange}},
+		{Base{Name: "pkg3", From: 0, To: 300, ChangeType: changeTypeAdd}},
+		{Base{Name: "pkg2", From: 200, To: 0, ChangeType: changeTypeRemove}},
 	}
 
 	result := processPackages(newPackages, oldPackages)
@@ -37,9 +37,9 @@ func TestProcessSections(t *testing.T) {
 	}
 
 	expected := []diffSection{
-		{DiffBase: DiffBase{Name: "sec1", From: 50, To: 75, ChangeType: changeTypeChange}, OldFileSize: 100, OldKnownSize: 50, NewFileSize: 150, NewKnownSize: 75},
-		{DiffBase: DiffBase{Name: "sec3", From: 0, To: 150, ChangeType: changeTypeAdd}, OldFileSize: 0, OldKnownSize: 0, NewFileSize: 300, NewKnownSize: 150},
-		{DiffBase: DiffBase{Name: "sec2", From: 100, To: 0, ChangeType: changeTypeRemove}, OldFileSize: 200, OldKnownSize: 100, NewFileSize: 0, NewKnownSize: 0},
+		{Base: Base{Name: "sec1", From: 50, To: 75, ChangeType: changeTypeChange}, OldFileSize: 100, OldKnownSize: 50, NewFileSize: 150, NewKnownSize: 75},
+		{Base: Base{Name: "sec3", From: 0, To: 150, ChangeType: changeTypeAdd}, OldFileSize: 0, OldKnownSize: 0, NewFileSize: 300, NewKnownSize: 150},
+		{Base: Base{Name: "sec2", From: 100, To: 0, ChangeType: changeTypeRemove}, OldFileSize: 200, OldKnownSize: 100, NewFileSize: 0, NewKnownSize: 0},
 	}
 
 	result := processSections(newSections, oldSections)
@@ -70,14 +70,14 @@ func TestNewDiffResult(t *testing.T) {
 
 	expected := diffResult{
 		Packages: []diffPackage{
-			{DiffBase{Name: "pkg3", From: 0, To: 300, ChangeType: changeTypeAdd}},
-			{DiffBase{Name: "pkg1", From: 100, To: 150, ChangeType: changeTypeChange}},
-			{DiffBase{Name: "pkg2", From: 200, To: 0, ChangeType: changeTypeRemove}},
+			{Base{Name: "pkg3", From: 0, To: 300, ChangeType: changeTypeAdd}},
+			{Base{Name: "pkg1", From: 100, To: 150, ChangeType: changeTypeChange}},
+			{Base{Name: "pkg2", From: 200, To: 0, ChangeType: changeTypeRemove}},
 		},
 		Sections: []diffSection{
-			{DiffBase: DiffBase{Name: "sec3", From: 0, To: 150, ChangeType: changeTypeAdd}, OldFileSize: 0, OldKnownSize: 0, NewFileSize: 300, NewKnownSize: 150},
-			{DiffBase: DiffBase{Name: "sec1", From: 50, To: 75, ChangeType: changeTypeChange}, OldFileSize: 100, OldKnownSize: 50, NewFileSize: 150, NewKnownSize: 75},
-			{DiffBase: DiffBase{Name: "sec2", From: 100, To: 0, ChangeType: changeTypeRemove}, OldFileSize: 200, OldKnownSize: 100, NewFileSize: 0, NewKnownSize: 0},
+			{Base: Base{Name: "sec3", From: 0, To: 150, ChangeType: changeTypeAdd}, OldFileSize: 0, OldKnownSize: 0, NewFileSize: 300, NewKnownSize: 150},
+			{Base: Base{Name: "sec1", From: 50, To: 75, ChangeType: changeTypeChange}, OldFileSize: 100, OldKnownSize: 50, NewFileSize: 150, NewKnownSize: 75},
+			{Base: Base{Name: "sec2", From: 100, To: 0, ChangeType: changeTypeRemove}, OldFileSize: 200, OldKnownSize: 100, NewFileSize: 0, NewKnownSize: 0},
 		},
 	}
 

internal/diff/load_test.go

@@ -36,7 +36,6 @@ func TestDiffJSONAndBinary(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-
 			require.NoError(t, Diff(io.Discard, DOptions{
 				OldTarget: tt.old,
 				NewTarget: tt.new,

internal/diff/printer.go

@@ -11,7 +11,7 @@ import (
 	"github.com/Zxilly/go-size-analyzer/internal/utils"
 )
 
-func diffString(b DiffBase) string {
+func diffString(b Base) string {
 	switch b.ChangeType {
 	case changeTypeChange:
 		sign := "+"
@@ -61,7 +61,7 @@ func text(r *diffResult, writer io.Writer) error {
 		}
 
 		t.AppendRow(table.Row{
-			diffString(pkg.DiffBase),
+			diffString(pkg.Base),
 			name,
 			bytesWithIgnore(pkg.From),
 			bytesWithIgnore(pkg.To),
@@ -73,7 +73,7 @@ func text(r *diffResult, writer io.Writer) error {
 
 	for _, section := range r.Sections {
 		t.AppendRow(table.Row{
-			diffString(section.DiffBase),
+			diffString(section.Base),
 			section.Name,
 			bytesWithIgnore(section.From),
 			bytesWithIgnore(section.To),
@@ -82,7 +82,7 @@ func text(r *diffResult, writer io.Writer) error {
 	}
 
 	t.AppendFooter(table.Row{
-		diffString(DiffBase{
+		diffString(Base{
 			From:       r.OldSize,
 			To:         r.NewSize,
 			ChangeType: changeTypeChange,

internal/diff/printer_test.go

@@ -5,22 +5,23 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestDiffStringChangeTypeChangeReturnsPercentage(t *testing.T) {
-	b := DiffBase{From: 100, To: 150, ChangeType: changeTypeChange}
+	b := Base{From: 100, To: 150, ChangeType: changeTypeChange}
 	assert.Equal(t, "+50.00%", diffString(b))
-	b = DiffBase{From: 150, To: 100, ChangeType: changeTypeChange}
+	b = Base{From: 150, To: 100, ChangeType: changeTypeChange}
 	assert.Equal(t, "-33.33%", diffString(b))
 }
 
 func TestDiffStringChangeTypeAddReturnsAdd(t *testing.T) {
-	b := DiffBase{ChangeType: changeTypeAdd}
+	b := Base{ChangeType: changeTypeAdd}
 	assert.Equal(t, "add", diffString(b))
 }
 
 func TestDiffStringChangeTypeRemoveReturnsRemove(t *testing.T) {
-	b := DiffBase{ChangeType: changeTypeRemove}
+	b := Base{ChangeType: changeTypeRemove}
 	assert.Equal(t, "remove", diffString(b))
 }
 
@@ -40,14 +41,14 @@ func TestTextRendersTableCorrectly(t *testing.T) {
 		OldSize: 100,
 		NewSize: 150,
 		Sections: []diffSection{
-			{DiffBase: DiffBase{Name: "sec1", From: 100, To: 150, ChangeType: changeTypeChange}},
+			{Base: Base{Name: "sec1", From: 100, To: 150, ChangeType: changeTypeChange}},
 		},
 		Packages: []diffPackage{
-			{DiffBase: DiffBase{Name: "pkg1", From: 100, To: 150, ChangeType: changeTypeChange}},
+			{Base: Base{Name: "pkg1", From: 100, To: 150, ChangeType: changeTypeChange}},
 		},
 	}
 	err := text(r, &buf)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Contains(t, buf.String(), "Diff between old and new")
 	assert.Contains(t, buf.String(), "sec1")
 	assert.Contains(t, buf.String(), "pkg1")
@@ -57,6 +58,6 @@ func TestTextHandlesEmptyResultWithoutError(t *testing.T) {
 	var buf bytes.Buffer
 	r := &diffResult{}
 	err := text(r, &buf)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Contains(t, buf.String(), "Diff between  and ")
 }

internal/diff/result_test.go

@@ -25,11 +25,11 @@ func TestCommonResultFromFullResult(t *testing.T) {
 	})
 	require.NoError(t, err)
 
-	crFromJson := new(commonResult)
-	err = json.UnmarshalRead(jsonData, crFromJson)
+	crFromJSON := new(commonResult)
+	err = json.UnmarshalRead(jsonData, crFromJSON)
 	require.NoError(t, err)
 
-	assert.Equal(t, cr, crFromJson)
+	assert.Equal(t, cr, crFromJSON)
 }
 
 func TestCommonResultFromFullAndCompactJSON(t *testing.T) {

internal/utils/reader.go

@@ -20,5 +20,5 @@ func (r *ReaderAtAdapter) Read(p []byte) (n int, err error) {
 	if errors.Is(err, io.EOF) && n > 0 {
 		return n, nil
 	}
-	return
+	return n, err
 }

internal/utils/reader_test.go

@@ -24,6 +24,6 @@ func TestReaderAtAdapter_Read(t *testing.T) {
 	// Test reading beyond the data
 	readData = make([]byte, 10)
 	n, err = reader.Read(readData)
-	assert.ErrorIs(t, err, io.EOF)
+	require.ErrorIs(t, err, io.EOF)
 	assert.Zero(t, n)
 }

internal/webui/net_test.go

@@ -40,26 +40,26 @@ type CacheSuite struct {
 }
 
 func (s *CacheSuite) TestGetTemplate() {
-	s.T().Run("cache exist", func(t *testing.T) {
+	s.Run("cache exist", func() {
 		cacheFile, err := getCacheFilePath()
-		require.NoError(t, err)
+		s.Require().NoError(err)
 
 		_, err = updateCache(cacheFile)
-		require.NoError(t, err)
+		s.Require().NoError(err)
 
 		got := GetTemplate()
-		assert.Contains(t, got, constant.ReplacedStr)
+		s.Contains(got, constant.ReplacedStr)
 	})
 
-	s.T().Run("cache not exist", func(t *testing.T) {
+	s.Run("cache not exist", func() {
 		cacheFile, err := getCacheFilePath()
-		require.NoError(t, err)
+		s.Require().NoError(err)
 
 		err = os.Remove(cacheFile)
-		require.NoError(t, err)
+		s.Require().NoError(err)
 
 		got := GetTemplate()
-		assert.Contains(t, got, constant.ReplacedStr)
+		s.Contains(got, constant.ReplacedStr)
 	})
 }