wsl

Author: mgdigital

.golangci.yml

@@ -21,6 +21,7 @@ linters:
     - revive
     - stylecheck
     - testifylint
+    - wsl
 linters-settings:
   revive:
     rules:

internal/app/cli/cli.go

@@ -30,10 +30,13 @@ func New(p Params) (Result, error) {
 	sort.Slice(commands, func(i, j int) bool {
 		return strings.Compare(commands[i].Name, commands[j].Name) < 0
 	})
+
 	name := "bitmagnet"
+
 	if version.GitTag != "" {
 		name += " " + version.GitTag
 	}
+
 	app := &cli.App{
 		Name:     name,
 		Commands: commands,
@@ -47,7 +50,9 @@ func New(p Params) (Result, error) {
 		// disabling the version flag as for some reason the After hook never gets called
 		HideVersion: true,
 	}
+
 	app.Setup()
+
 	p.Lifecycle.Append(fx.Hook{
 		OnStart: func(context.Context) error {
 			go (func() {
@@ -63,6 +68,7 @@ func New(p Params) (Result, error) {
 			return nil
 		},
 	})
+
 	return Result{
 		App: app,
 	}, nil

internal/app/cli/hooks/hooks.go

@@ -21,5 +21,6 @@ func New(p Params) (Result, error) {
 	for _, hook := range p.Hooks {
 		p.Lifecycle.Append(hook)
 	}
+
 	return Result{}, nil
 }

internal/app/cmd/classifiercmd/command.go

@@ -65,6 +65,7 @@ func write(writer io.Writer, src any, format string) error {
 		output    []byte
 		outputErr error
 	)
+
 	switch format {
 	case "json":
 		output, outputErr = json.MarshalIndent(src, "", "  ")
@@ -74,9 +75,12 @@ func write(writer io.Writer, src any, format string) error {
 	default:
 		outputErr = fmt.Errorf("unsupported format: %s", format)
 	}
+
 	if outputErr != nil {
 		return outputErr
 	}
+
 	_, writeErr := writer.Write(output)
+
 	return writeErr
 }

internal/app/cmd/configcmd/command.go

@@ -40,6 +40,7 @@ func New(p Params) (Result, error) {
 			},
 		},
 	}
+
 	return Result{Command: cmd}, nil
 }
 
@@ -48,15 +49,18 @@ func appendRows(tw table.Writer, node config.ResolvedNode) {
 		tw.AppendSeparator()
 		tw.AppendRow(table.Row{node.PathString + ":", node.Type})
 		tw.AppendSeparator()
+
 		for _, child := range node.Children() {
 			appendRows(tw, child)
 		}
+
 		tw.AppendSeparator()
 	} else {
 		from := node.ResolverKey
 		if from == "" {
 			from = "default"
 		}
+
 		tw.AppendRow(table.Row{node.PathString, node.Type, node.ValueLabel, node.DefaultLabel, from})
 	}
 }

internal/app/cmd/workercmd/command.go

@@ -60,5 +60,6 @@ func New(p Params) (Result, error) {
 			},
 		},
 	}
+
 	return Result{Command: cmd}, nil
 }

internal/blocking/factory.go

@@ -29,14 +29,17 @@ func New(params Params) Result {
 		if err != nil {
 			return nil, err
 		}
+
 		params.PgxPoolWait.Add(1)
+
 		return &manager{
 			pool:          pool,
 			buffer:        make(map[protocol.ID]struct{}, 1000),
 			maxBufferSize: 1000,
 			maxFlushWait:  time.Minute * 5,
 		}, nil
 	})
+
 	return Result{
 		Manager: lazyManager,
 		AppHook: fx.Hook{

internal/blocking/manager.go

@@ -33,44 +33,55 @@ type manager struct {
 func (m *manager) Filter(ctx context.Context, hashes []protocol.ID) ([]protocol.ID, error) {
 	m.mutex.Lock()
 	defer m.mutex.Unlock()
+
 	if m.filter == nil || m.shouldFlush() {
 		if flushErr := m.flush(ctx); flushErr != nil {
 			return nil, flushErr
 		}
 	}
+
 	var filtered []protocol.ID
+
 	for _, hash := range hashes {
 		if _, ok := m.buffer[hash]; ok {
 			continue
 		}
+
 		if m.filter.Test(hash[:]) {
 			continue
 		}
+
 		filtered = append(filtered, hash)
 	}
+
 	return filtered, nil
 }
 
 func (m *manager) Block(ctx context.Context, hashes []protocol.ID, flush bool) error {
 	m.mutex.Lock()
 	defer m.mutex.Unlock()
+
 	for _, hash := range hashes {
 		m.buffer[hash] = struct{}{}
 	}
+
 	if flush || m.shouldFlush() {
 		if flushErr := m.flush(ctx); flushErr != nil {
 			return flushErr
 		}
 	}
+
 	return nil
 }
 
 func (m *manager) Flush(ctx context.Context) error {
 	m.mutex.Lock()
 	defer m.mutex.Unlock()
+
 	if len(m.buffer) == 0 {
 		return nil
 	}
+
 	return m.flush(ctx)
 }
 
@@ -88,6 +99,7 @@ func (m *manager) flush(ctx context.Context) error {
 	if err != nil {
 		return fmt.Errorf("failed to begin transaction: %w", err)
 	}
+
 	defer func() {
 		_ = tx.Rollback(ctx)
 	}()
@@ -106,18 +118,24 @@ func (m *manager) flush(ctx context.Context) error {
 	found := false
 
 	var oid uint32
+
 	var nullOid sql.NullInt32
+
 	err = tx.QueryRow(ctx, "SELECT oid FROM bloom_filters WHERE key = $1", blockedTorrentsBloomFilterKey).Scan(&nullOid)
 	if err == nil {
 		found = true
+
 		if nullOid.Valid {
 			oid = uint32(nullOid.Int32)
+
 			obj, err := lobs.Open(ctx, oid, pgx.LargeObjectModeRead)
 			if err != nil {
 				return fmt.Errorf("failed to open large object for reading: %w", err)
 			}
+
 			_, err = bf.ReadFrom(obj)
 			obj.Close()
+
 			if err != nil {
 				return fmt.Errorf("failed to read current bloom filter: %w", err)
 			}

internal/bloom/bloom.go

@@ -24,9 +24,11 @@ func FromScrape(f dht.ScrapeBloomFilter) Filter {
 
 func convertBytes(b [byteSize]byte) []uint64 {
 	ret := make([]uint64, size)
+
 	for i := range size {
 		startPos := i * 8
 		ret[i] = binary.BigEndian.Uint64(b[startPos : startPos+8])
 	}
+
 	return ret
 }

internal/bloom/bloom_test.go

@@ -10,6 +10,7 @@ import (
 
 func TestScrapeBloomFilter(t *testing.T) {
 	var s dht.ScrapeBloomFilter
+
 	assert.InDelta(t, 0.5, s.EstimateCount(), 0)
 	s.AddIP(net.IPv4(127, 0, 0, 1))
 	c := s.EstimateCount()
@@ -19,6 +20,7 @@ func TestScrapeBloomFilter(t *testing.T) {
 
 func TestConvertBloom(t *testing.T) {
 	var s dht.ScrapeBloomFilter
+
 	s.AddIP(net.IPv4(127, 0, 0, 1))
 	s.AddIP(net.IPv4(127, 0, 0, 2))
 	f := FromScrape(s)

internal/bloom/stable.go

@@ -24,17 +24,21 @@ func (s *StableBloomFilter) Scan(value interface{}) error {
 	if !ok {
 		return errors.New("invalid type for StableBloomFilter")
 	}
+
 	bf := boom.NewStableBloomFilter(0, 0, 0)
 	if err := bf.GobDecode(bytes); err != nil {
 		return err
 	}
+
 	s.StableBloomFilter = *bf
+
 	return nil
 }
 
 func (s StableBloomFilter) Value() (driver.Value, error) {
 	if s.Cells() == 0 {
 		return nil, nil
 	}
+
 	return s.GobEncode()
 }

internal/classifier/action.go

@@ -25,14 +25,18 @@ type actionDefinition interface {
 
 func (c compilerContext) compileAction(ctx compilerContext) (action, error) {
 	var rawActions []any
+
 	isArray := false
+
 	if s, ok := ctx.source.([]any); ok {
 		rawActions = s
 		isArray = true
 	} else {
 		rawActions = []any{ctx.source}
 	}
+
 	var actions []action
+
 	var errs []error
 outer:
 	for i, rawAction := range rawActions {
@@ -52,9 +56,11 @@ outer:
 		}
 		errs = append(errs, fmt.Errorf("no action matched: %v", ctx.source))
 	}
+
 	if len(errs) > 0 {
 		return action{}, errors.Join(errs...)
 	}
+
 	return action{func(ctx executionContext) (classification.Result, error) {
 		for _, a := range actions {
 			result, err := a.run(ctx)

internal/classifier/action_add_tag.go

@@ -42,6 +42,7 @@ func (addTagAction) compileAction(ctx compilerContext) (action, error) {
 	if err != nil {
 		return action{}, ctx.error(err)
 	}
+
 	return action{
 		func(ctx executionContext) (classification.Result, error) {
 			cl := ctx.result

internal/classifier/action_attach_local_content_by_id.go

@@ -22,6 +22,7 @@ func (attachLocalContentByIDAction) compileAction(ctx compilerContext) (action,
 	if _, err := attachLocalContentByIDPayloadSpec.Unmarshal(ctx); err != nil {
 		return action{}, ctx.error(err)
 	}
+
 	return action{
 		run: func(ctx executionContext) (classification.Result, error) {
 			cl := ctx.result

internal/classifier/action_attach_local_content_by_search.go

@@ -21,6 +21,7 @@ func (attachLocalContentBySearchAction) compileAction(ctx compilerContext) (acti
 	if _, err := attachLocalContentBySearchPayloadSpec.Unmarshal(ctx); err != nil {
 		return action{}, ctx.error(err)
 	}
+
 	return action{
 		run: func(ctx executionContext) (classification.Result, error) {
 			cl := ctx.result

internal/classifier/action_attach_tmdb_content_by_id.go

@@ -24,6 +24,7 @@ func (attachTMDBContentByIDAction) compileAction(ctx compilerContext) (action, e
 	if _, err := attachTMDBContentByIDPayloadSpec.Unmarshal(ctx); err != nil {
 		return action{}, ctx.error(err)
 	}
+
 	return action{
 		run: func(ctx executionContext) (classification.Result, error) {
 			cl := ctx.result

internal/classifier/action_attach_tmdb_content_by_search.go

@@ -22,6 +22,7 @@ func (attachTmdbContentBySearchAction) compileAction(ctx compilerContext) (actio
 	if _, err := attachTmdbContentBySearchPayloadSpec.Unmarshal(ctx); err != nil {
 		return action{}, ctx.error(err)
 	}
+
 	return action{
 		run: func(ctx executionContext) (classification.Result, error) {
 			cl := ctx.result

internal/classifier/action_delete.go

@@ -19,7 +19,9 @@ func (deleteAction) compileAction(ctx compilerContext) (action, error) {
 	if _, err := deletePayloadSpec.Unmarshal(ctx); err != nil {
 		return action{}, ctx.error(err)
 	}
+
 	path := ctx.path
+
 	return action{
 		run: func(ctx executionContext) (classification.Result, error) {
 			return ctx.result, classification.RuntimeError{Cause: classification.ErrDeleteTorrent, Path: path}

internal/classifier/action_find_match.go

@@ -29,15 +29,20 @@ func (findMatchAction) compileAction(ctx compilerContext) (action, error) {
 	if err != nil {
 		return action{}, ctx.error(err)
 	}
+
 	actions := make([]action, len(payload))
+
 	for i, actionPayload := range payload {
 		a, err := ctx.compileAction(ctx.child(numericPathPart(i), actionPayload))
 		if err != nil {
 			return action{}, err
 		}
+
 		actions[i] = a
 	}
+
 	path := ctx.path
+
 	return action{
 		func(ctx executionContext) (classification.Result, error) {
 			for _, action := range actions {

internal/classifier/action_if_else.go

@@ -44,25 +44,32 @@ func (ifElseAction) compileAction(ctx compilerContext) (action, error) {
 	if decodeErr != nil {
 		return action{}, ctx.error(decodeErr)
 	}
+
 	cond, cErr := ctx.compileCondition(ctx.child("condition", p.Condition))
 	if cErr != nil {
 		return action{}, ctx.error(cErr)
 	}
+
 	var ifAction, elseAction action
+
 	if p.IfAction != nil {
 		pIfAction, ifErr := ctx.compileAction(ctx.child("if_action", p.IfAction))
 		if ifErr != nil {
 			return action{}, ctx.error(ifErr)
 		}
+
 		ifAction = pIfAction
 	}
+
 	if p.ElseAction != nil {
 		pElseAction, err := ctx.compileAction(ctx.child("else_action", p.ElseAction))
 		if err != nil {
 			return action{}, ctx.error(err)
 		}
+
 		elseAction = pElseAction
 	}
+
 	return action{
 		run: func(ctx executionContext) (classification.Result, error) {
 			if result, err := cond.check(ctx); err != nil {