apply Vojtech suggestions

Author: marino39

cmd/ethwalcat/ethwalcat.go

@@ -148,29 +148,29 @@ func main() {
 			FileRollOnCloseFlag,
 			GoogleCloudBucket,
 		},
-		Action: func(context *cli.Context) error {
-			switch context.String(ModeFlag.Name) {
+		Action: func(c *cli.Context) error {
+			switch c.String(ModeFlag.Name) {
 			case "read":
-				dec, err := decoder(context)
+				dec, err := decoder(c)
 				if err != nil {
 					return err
 				}
 
-				decomp, err := decompressor(context)
+				decomp, err := decompressor(c)
 				if err != nil {
 					return err
 				}
 
 				var fs storage.FS
-				if bucket := context.String(GoogleCloudBucket.Name); bucket != "" {
+				if bucket := c.String(GoogleCloudBucket.Name); bucket != "" {
 					fs = gcloud.NewGCloudFS(bucket, nil)
 				}
 
 				r, err := ethwal.NewReader[any](ethwal.Options{
 					Dataset: ethwal.Dataset{
-						Name:    context.String(DatasetNameFlag.Name),
-						Version: context.String(DatasetVersion.Name),
-						Path:    context.String(DatasetPathFlag.Name),
+						Name:    c.String(DatasetNameFlag.Name),
+						Version: c.String(DatasetVersion.Name),
+						Path:    c.String(DatasetPathFlag.Name),
 					},
 					FileSystem:      fs,
 					NewDecoder:      dec,
@@ -180,22 +180,22 @@ func main() {
 					return err
 				}
 
-				if context.Uint64(FromBlockNumFlag.Name) > 0 {
-					err = r.Seek(context.Context, context.Uint64(FromBlockNumFlag.Name))
+				if c.Uint64(FromBlockNumFlag.Name) > 0 {
+					err = r.Seek(c.Context, c.Uint64(FromBlockNumFlag.Name))
 					if err != nil {
 						return err
 					}
 				}
 
-				var toBlockNumber = context.Uint64(ToBlockNumFlag.Name)
+				var toBlockNumber = c.Uint64(ToBlockNumFlag.Name)
 
-				for b, err := r.Read(context.Context); err == nil; b, err = r.Read(context.Context) {
+				for b, err := r.Read(c.Context); err == nil; b, err = r.Read(c.Context) {
 					if toBlockNumber != 0 && b.Number >= toBlockNumber {
 						break
 					}
 
 					// cbor deserializes into map[interface{}]interface{} which can not be serialized into json
-					if context.String(DecoderFlag.Name) == "cbor" {
+					if c.String(DecoderFlag.Name) == "cbor" {
 						b.Data = normalizeDataFromCBOR(b.Data)
 					}
 
@@ -220,32 +220,32 @@ func main() {
 					return err
 				}
 			case "write":
-				enc, err := encoder(context)
+				enc, err := encoder(c)
 				if err != nil {
 					return err
 				}
 
-				compres, err := compressor(context)
+				compres, err := compressor(c)
 				if err != nil {
 					return err
 				}
 
 				var fs storage.FS
-				if bucket := context.String(GoogleCloudBucket.Name); bucket != "" {
+				if bucket := c.String(GoogleCloudBucket.Name); bucket != "" {
 					fs = gcloud.NewGCloudFS(bucket, nil)
 				}
 
 				w, err := ethwal.NewWriter[any](ethwal.Options{
 					Dataset: ethwal.Dataset{
-						Name:    context.String(DatasetNameFlag.Name),
-						Version: context.String(DatasetVersion.Name),
-						Path:    context.String(DatasetPathFlag.Name),
+						Name:    c.String(DatasetNameFlag.Name),
+						Version: c.String(DatasetVersion.Name),
+						Path:    c.String(DatasetPathFlag.Name),
 					},
 					FileSystem:      fs,
 					NewEncoder:      enc,
 					NewCompressor:   compres,
 					FileRollPolicy:  ethwal.NewFileSizeRollPolicy(uint64(8 << 20)), // 8 MB
-					FileRollOnClose: context.Bool(FileRollOnCloseFlag.Name),
+					FileRollOnClose: c.Bool(FileRollOnCloseFlag.Name),
 				})
 				if err != nil {
 					return err
@@ -260,11 +260,11 @@ func main() {
 					}
 
 					// cbor needs to have hashes represented as byte slices
-					if context.String(EncoderFlag.Name) == "cbor" {
+					if c.String(EncoderFlag.Name) == "cbor" {
 						b.Data = normalizeDataToCBOR(b.Data)
 					}
 
-					err = w.Write(context.Context, b)
+					err = w.Write(c.Context, b)
 					if err != nil {
 						return err
 					}
@@ -274,12 +274,12 @@ func main() {
 					return err
 				}
 
-				err = w.Close(context.Context)
+				err = w.Close(c.Context)
 				if err != nil {
 					return err
 				}
 			default:
-				return fmt.Errorf("unknown mode: %s", context.String(ModeFlag.Name))
+				return fmt.Errorf("unknown mode: %s", c.String(ModeFlag.Name))
 			}
 
 			return nil

common.go

@@ -2,6 +2,7 @@ package ethwal
 
 import (
 	"bytes"
+	"cmp"
 	"context"
 	"crypto/sha256"
 	"encoding/binary"
@@ -18,6 +19,7 @@ import (
 
 	"github.com/0xsequence/ethwal/storage"
 	"github.com/0xsequence/ethwal/storage/local"
+	"github.com/c2h5oh/datasize"
 )
 
 type Dataset struct {
@@ -56,6 +58,7 @@ func buildETHWALPath(name, version, rootPath string) string {
 }
 
 const (
+	defaultFileSize        = 8 * datasize.MB
 	defaultPrefetchTimeout = 30 * time.Second
 )
 
@@ -77,21 +80,15 @@ type Options struct {
 }
 
 func (o Options) WithDefaults() Options {
-	if o.FileSystem == nil {
-		o.FileSystem = local.NewLocalFS("")
-	}
-	if o.FilePrefetchTimeout == 0 {
-		o.FilePrefetchTimeout = defaultPrefetchTimeout
-	}
+	o.FileSystem = cmp.Or(o.FileSystem, local.NewLocalFS(""))
+	o.FilePrefetchTimeout = cmp.Or(o.FilePrefetchTimeout, defaultPrefetchTimeout)
+	o.FileRollPolicy = cmp.Or(o.FileRollPolicy, NewFileSizeRollPolicy(uint64(defaultFileSize)))
 	if o.NewEncoder == nil {
 		o.NewEncoder = NewCBOREncoder
 	}
 	if o.NewDecoder == nil {
 		o.NewDecoder = NewCBORDecoder
 	}
-	if o.FileRollPolicy == nil {
-		o.FileRollPolicy = NewFileSizeRollPolicy(uint64(defaultBufferSize))
-	}
 	return o
 }
 

writer.go

@@ -10,11 +10,8 @@ import (
 
 	"github.com/0xsequence/ethwal/storage"
 	"github.com/0xsequence/ethwal/storage/local"
-	"github.com/c2h5oh/datasize"
 )
 
-const defaultBufferSize = 8 * datasize.MB
-
 type Writer[T any] interface {
 	Write(ctx context.Context, b Block[T]) error
 	BlockNum() uint64