Improvement/linter (#330)

* add format configurations for golangci-lint

* format code as per the formatter

Author: Saurabh2402

.golangci.yml

@@ -0,0 +1,50 @@
+# See for configurations: https://golangci-lint.run/usage/configuration/
+version: 2
+# See: https://golangci-lint.run/usage/formatters/
+formatters:
+  default: none
+  enable:
+    - gofmt # https://pkg.go.dev/cmd/gofmt
+    - gofumpt # https://github.com/mvdan/gofumpt
+
+  settings:
+    gofmt:
+      simplify: true # Simplify code: gofmt with `-s` option.
+
+    gofumpt:
+      # Module path which contains the source code being formatted.
+      # Default: ""
+      module-path: github.com/rosedblabs/rosedb/v2 # Should match with module in go.mod
+      # Choose whether to use the extra rules.
+      # Default: false
+      extra-rules: true
+
+# See: https://golangci-lint.run/usage/linters/
+linters:
+  default: none
+  enable:
+    - staticcheck
+    - govet
+    - gocritic
+    - unconvert
+    - ineffassign
+    - mirror
+    - unused
+    - usestdlibvars
+    - loggercheck
+    - exptostd
+    - godot
+    - copyloopvar
+    - perfsprint
+    - testifylint
+    - thelper
+    - nilerr
+
+  # See: https://golangci-lint.run/usage/false-positives/
+  # exclusion:
+  #   paths:
+  #   rules:
+
+  settings:
+    godot:
+      period: false

batch.go

@@ -64,7 +64,7 @@ func (db *DB) NewBatch(options BatchOptions) *Batch {
 	return batch
 }
 
-func newBatch() interface{} {
+func newBatch() any {
 	node, err := snowflake.NewNode(1)
 	if err != nil {
 		panic(fmt.Sprintf("snowflake.NewNode(1) failed: %v", err))
@@ -75,7 +75,7 @@ func newBatch() interface{} {
 	}
 }
 
-func newRecord() interface{} {
+func newRecord() any {
 	return &LogRecord{}
 }
 
@@ -116,7 +116,7 @@ func (b *Batch) unlock() {
 }
 
 // Put adds a key-value pair to the batch for writing.
-func (b *Batch) Put(key []byte, value []byte) error {
+func (b *Batch) Put(key, value []byte) error {
 	if len(key) == 0 {
 		return ErrKeyIsEmpty
 	}
@@ -129,7 +129,7 @@ func (b *Batch) Put(key []byte, value []byte) error {
 
 	b.mu.Lock()
 	// write to pendingWrites
-	var record = b.lookupPendingWrites(key)
+	record := b.lookupPendingWrites(key)
 	if record == nil {
 		// if the key does not exist in pendingWrites, write a new record
 		// the record will be put back to the pool when the batch is committed or rollbacked
@@ -145,7 +145,7 @@ func (b *Batch) Put(key []byte, value []byte) error {
 }
 
 // PutWithTTL adds a key-value pair with ttl to the batch for writing.
-func (b *Batch) PutWithTTL(key []byte, value []byte, ttl time.Duration) error {
+func (b *Batch) PutWithTTL(key, value []byte, ttl time.Duration) error {
 	if len(key) == 0 {
 		return ErrKeyIsEmpty
 	}
@@ -158,7 +158,7 @@ func (b *Batch) PutWithTTL(key []byte, value []byte, ttl time.Duration) error {
 
 	b.mu.Lock()
 	// write to pendingWrites
-	var record = b.lookupPendingWrites(key)
+	record := b.lookupPendingWrites(key)
 	if record == nil {
 		// if the key does not exist in pendingWrites, write a new record
 		// the record will be put back to the pool when the batch is committed or rollbacked
@@ -185,7 +185,7 @@ func (b *Batch) Get(key []byte) ([]byte, error) {
 	now := time.Now().UnixNano()
 	// get from pendingWrites
 	b.mu.RLock()
-	var record = b.lookupPendingWrites(key)
+	record := b.lookupPendingWrites(key)
 	b.mu.RUnlock()
 
 	// if the record is in pendingWrites, return the value directly
@@ -233,7 +233,7 @@ func (b *Batch) Delete(key []byte) error {
 	b.mu.Lock()
 	// only need key and type when deleting a value.
 	var exist bool
-	var record = b.lookupPendingWrites(key)
+	record := b.lookupPendingWrites(key)
 	if record != nil {
 		record.Type = LogRecordDeleted
 		record.Value = nil
@@ -264,7 +264,7 @@ func (b *Batch) Exist(key []byte) (bool, error) {
 	now := time.Now().UnixNano()
 	// check if the key exists in pendingWrites
 	b.mu.RLock()
-	var record = b.lookupPendingWrites(key)
+	record := b.lookupPendingWrites(key)
 	b.mu.RUnlock()
 
 	if record != nil {
@@ -306,7 +306,7 @@ func (b *Batch) Expire(key []byte, ttl time.Duration) error {
 	b.mu.Lock()
 	defer b.mu.Unlock()
 
-	var record = b.lookupPendingWrites(key)
+	record := b.lookupPendingWrites(key)
 
 	// if the key exists in pendingWrites, update the expiry time directly
 	if record != nil {
@@ -356,7 +356,7 @@ func (b *Batch) TTL(key []byte) (time.Duration, error) {
 	b.mu.Lock()
 	defer b.mu.Unlock()
 
-	var record = b.lookupPendingWrites(key)
+	record := b.lookupPendingWrites(key)
 	if record != nil {
 		if record.Expire == 0 {
 			return -1, nil
@@ -413,7 +413,7 @@ func (b *Batch) Persist(key []byte) error {
 	defer b.mu.Unlock()
 
 	// if the key exists in pendingWrites, update the expiry time directly
-	var record = b.lookupPendingWrites(key)
+	record := b.lookupPendingWrites(key)
 	if record != nil {
 		if record.Type == LogRecordDeleted && record.IsExpired(time.Now().UnixNano()) {
 			return ErrKeyNotFound

batch_test.go

@@ -28,7 +28,7 @@ func TestBatch_Put_IncrSegmentFile(t *testing.T) {
 	options := DefaultOptions
 	options.SegmentSize = 64 * MB
 	db, err := Open(options)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	defer destroyDB(db)
 
 	generateData(t, db, 1, 2000, 32*KB)
@@ -37,31 +37,31 @@ func TestBatch_Put_IncrSegmentFile(t *testing.T) {
 	batch := db.NewBatch(DefaultBatchOptions)
 	for i := 0; i < 1000; i++ {
 		err := batch.Put(utils.GetTestKey(i*100), utils.RandomValue(32*KB))
-		assert.Nil(t, err)
+		assert.NoError(t, err)
 	}
 	err = batch.Commit()
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 }
 
 func TestBatch_Get_Normal(t *testing.T) {
 	options := DefaultOptions
 	db, err := Open(options)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	defer destroyDB(db)
 
 	batch1 := db.NewBatch(DefaultBatchOptions)
 	err = batch1.Put(utils.GetTestKey(12), utils.RandomValue(128))
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	val1, err := batch1.Get(utils.GetTestKey(12))
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.NotNil(t, val1)
 	_ = batch1.Commit()
 
 	generateData(t, db, 400, 500, 4*KB)
 
 	batch2 := db.NewBatch(DefaultBatchOptions)
 	err = batch2.Delete(utils.GetTestKey(450))
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	val, err := batch2.Get(utils.GetTestKey(450))
 	assert.Nil(t, val)
 	assert.Equal(t, ErrKeyNotFound, err)
@@ -70,7 +70,7 @@ func TestBatch_Get_Normal(t *testing.T) {
 	// reopen
 	_ = db.Close()
 	db2, err := Open(options)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	defer func() {
 		_ = db2.Close()
 	}()
@@ -81,34 +81,34 @@ func TestBatch_Get_Normal(t *testing.T) {
 func TestBatch_Delete_Normal(t *testing.T) {
 	options := DefaultOptions
 	db, err := Open(options)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	defer destroyDB(db)
 
 	err = db.Delete([]byte("not exist"))
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 
 	generateData(t, db, 1, 100, 128)
 	err = db.Delete(utils.GetTestKey(99))
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 
 	exist, err := db.Exist(utils.GetTestKey(99))
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.False(t, exist)
 
 	batch := db.NewBatch(DefaultBatchOptions)
 	err = batch.Put(utils.GetTestKey(200), utils.RandomValue(100))
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	err = batch.Delete(utils.GetTestKey(200))
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	exist1, err := batch.Exist(utils.GetTestKey(200))
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.False(t, exist1)
 	_ = batch.Commit()
 
 	// reopen
 	_ = db.Close()
 	db2, err := Open(options)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	defer func() {
 		_ = db2.Close()
 	}()
@@ -118,75 +118,78 @@ func TestBatch_Delete_Normal(t *testing.T) {
 func TestBatch_Exist_Normal(t *testing.T) {
 	options := DefaultOptions
 	db, err := Open(options)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	defer destroyDB(db)
 
 	generateData(t, db, 1, 100, 128)
 	batch := db.NewBatch(DefaultBatchOptions)
 	ok1, err := batch.Exist(utils.GetTestKey(99))
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.True(t, ok1)
 	ok2, err := batch.Exist(utils.GetTestKey(5000))
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.False(t, ok2)
 	_ = batch.Commit()
 
 	_ = db.Close()
 	db2, err := Open(options)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	defer func() {
 		_ = db2.Close()
 	}()
 	assertKeyExistOrNot(t, db2, utils.GetTestKey(99), true)
 }
 
-func generateData(t *testing.T, db *DB, start, end int, valueLen int) {
+func generateData(t *testing.T, db *DB, start, end, valueLen int) {
+	t.Helper()
 	for ; start < end; start++ {
 		err := db.Put(utils.GetTestKey(start), utils.RandomValue(valueLen))
-		assert.Nil(t, err)
+		assert.NoError(t, err)
 	}
 }
 
-func batchPutAndIterate(t *testing.T, segmentSize int64, size int, valueLen int) {
+func batchPutAndIterate(t *testing.T, segmentSize int64, size, valueLen int) {
+	t.Helper()
 	options := DefaultOptions
 	options.SegmentSize = segmentSize
 	db, err := Open(options)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	defer destroyDB(db)
 
 	batch := db.NewBatch(BatchOptions{})
 
 	for i := 0; i < size; i++ {
 		err := batch.Put(utils.GetTestKey(i), utils.RandomValue(valueLen))
-		assert.Nil(t, err)
+		assert.NoError(t, err)
 	}
 	err = batch.Commit()
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 
 	for i := 0; i < size; i++ {
 		value, err := db.Get(utils.GetTestKey(i))
-		assert.Nil(t, err)
-		assert.Equal(t, len(utils.RandomValue(valueLen)), len(value))
+		assert.NoError(t, err)
+		assert.Len(t, value, len(utils.RandomValue(valueLen)))
 	}
 
 	// reopen
 	_ = db.Close()
 	db2, err := Open(options)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	defer func() {
 		_ = db2.Close()
 	}()
 	for i := 0; i < size; i++ {
 		value, err := db2.Get(utils.GetTestKey(i))
-		assert.Nil(t, err)
-		assert.Equal(t, len(utils.RandomValue(valueLen)), len(value))
+		assert.NoError(t, err)
+		assert.Len(t, value, len(utils.RandomValue(valueLen)))
 	}
 }
 
 func assertKeyExistOrNot(t *testing.T, db *DB, key []byte, exist bool) {
+	t.Helper()
 	val, err := db.Get(key)
 	if exist {
-		assert.Nil(t, err)
+		assert.NoError(t, err)
 		assert.NotNil(t, val)
 	} else {
 		assert.Nil(t, val)
@@ -197,18 +200,18 @@ func assertKeyExistOrNot(t *testing.T, db *DB, key []byte, exist bool) {
 func TestBatch_Rollback(t *testing.T) {
 	options := DefaultOptions
 	db, err := Open(options)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	defer destroyDB(db)
 
 	key := []byte("rosedb")
 	value := []byte("val")
 
 	batcher := db.NewBatch(DefaultBatchOptions)
 	err = batcher.Put(key, value)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 
 	err = batcher.Rollback()
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 
 	resp, err := db.Get(key)
 	assert.Equal(t, ErrKeyNotFound, err)
@@ -218,7 +221,7 @@ func TestBatch_Rollback(t *testing.T) {
 func TestBatch_SetTwice(t *testing.T) {
 	options := DefaultOptions
 	db, err := Open(options)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	defer destroyDB(db)
 
 	batch := db.NewBatch(DefaultBatchOptions)
@@ -229,11 +232,11 @@ func TestBatch_SetTwice(t *testing.T) {
 	_ = batch.Put(key, value2)
 
 	res, err := batch.Get(key)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, res, value2)
 
 	_ = batch.Commit()
 	res2, err := db.Get(key)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, res2, value2)
 }