fix: make linter happy

Author: pashagolub

.golangci.yml

@@ -0,0 +1,39 @@
+version: "2"
+linters:
+  enable:
+    - misspell
+    - revive
+  disable:
+    - gocyclo
+  settings:
+    gocyclo:
+      min-complexity: 20
+  exclusions:
+    generated: lax
+    presets:
+      - comments
+      - common-false-positives
+      - legacy
+      - std-error-handling
+    rules:
+      - path: (.+)\.go$
+        text: SA1019    # CPUTimesStat.Total is deprecated
+      - path: (.+)\.go$
+        text: SA5008    # duplicate struct tag "choice" (staticcheck)
+      - path: (.+)\.go$
+        text: QF1001    # could apply De Morgan's law
+      - path: pkg/
+        text: "var-naming: avoid meaningless package names"
+        linters:
+          - revive
+    paths:
+      - third_party$
+      - builtin$
+      - examples$
+formatters:
+  exclusions:
+    generated: lax
+    paths:
+      - third_party$
+      - builtin$
+      - examples$

cmd/pgcov/main.go

@@ -123,5 +123,5 @@ func reportCommand(ctx context.Context, cmd *urfavecli.Command) error {
 	output := cmd.String("output")
 	coverageFile := cmd.String("coverage-file")
 
-	return cli.Report(coverageFile, format, output)
+	return cli.Report(ctx, coverageFile, format, output)
 }

internal/cli/report.go

@@ -1,6 +1,7 @@
 package cli
 
 import (
+	"context"
 	"fmt"
 	"os"
 
@@ -9,7 +10,7 @@ import (
 )
 
 // Report generates a coverage report from saved coverage data
-func Report(coverageFile string, format string, outputPath string) error {
+func Report(_ context.Context, coverageFile string, format string, outputPath string) error {
 	// Step 1: Load coverage data
 	store := coverage.NewStore(coverageFile)
 	if !store.Exists() {

internal/cli/run.go

@@ -57,7 +57,7 @@ func Run(ctx context.Context, config *Config, searchPath string) (int, error) {
 	}
 
 	// Step 4: Instrument source files
-	instrumentedSources, err := instrument.InstrumentBatch(parsedSources)
+	instrumentedSources, err := instrument.GenerateCoverageInstruments(parsedSources)
 	if err != nil {
 		return 1, fmt.Errorf("failed to instrument sources: %w", err)
 	}

internal/coverage/model.go

@@ -60,8 +60,10 @@ func (c *Coverage) AddLine(file string, line int, hitCount int) {
 }
 
 // AddBranch adds or updates branch coverage data (placeholder for future)
-func (c *Coverage) AddBranch(file string, branchID string, hitCount int) {
+func (c *Coverage) AddBranch(_ string, branchID string, hitCount int) {
 	// TODO: Implement branch coverage tracking
+	_ = branchID
+	_ = hitCount
 }
 
 // LineCoveragePercent calculates the line coverage percentage for a file

internal/database/pool.go

@@ -5,13 +5,37 @@ import (
 	"fmt"
 	"strconv"
 
-	"github.com/cybertec-postgresql/pgcov/internal/errors"
 	"github.com/cybertec-postgresql/pgcov/pkg/types"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 
 const applicationName = "pgcov"
 
+// ConnectionError represents PostgreSQL connection failure
+type ConnectionError struct {
+	Host       string
+	Port       int
+	Message    string
+	Suggestion string
+}
+
+func (e *ConnectionError) Error() string {
+	msg := fmt.Sprintf("failed to connect to %s:%d: %s", e.Host, e.Port, e.Message)
+	if e.Suggestion != "" {
+		msg += fmt.Sprintf("\nSuggestion: %s", e.Suggestion)
+	}
+	return msg
+}
+
+// NewConnectionError creates a new ConnectionError
+func NewConnectionError(host string, port int, message string) *ConnectionError {
+	return &ConnectionError{
+		Host:    host,
+		Port:    port,
+		Message: message,
+	}
+}
+
 // Pool wraps pgxpool.Pool with additional functionality
 type Pool struct {
 	*pgxpool.Pool
@@ -26,7 +50,7 @@ func NewPool(ctx context.Context, config *types.Config) (*Pool, error) {
 	// Configure pool
 	poolConfig, err := pgxpool.ParseConfig(connString)
 	if err != nil {
-		return nil, &errors.ConnectionError{
+		return nil, &ConnectionError{
 			Message:    fmt.Sprintf("invalid connection configuration: %v", err),
 			Suggestion: "Check your PostgreSQL connection string format. Use URI format (postgresql://user:pass@host:port/db) or key=value format (host=localhost port=5432 ...)",
 		}
@@ -45,7 +69,7 @@ func NewPool(ctx context.Context, config *types.Config) (*Pool, error) {
 	// Create pool
 	pool, err := pgxpool.NewWithConfig(ctx, poolConfig)
 	if err != nil {
-		return nil, &errors.ConnectionError{
+		return nil, &ConnectionError{
 			Message:    fmt.Sprintf("failed to create connection pool: %v", err),
 			Suggestion: "Verify PostgreSQL is running and accessible with the provided connection string",
 		}
@@ -56,23 +80,23 @@ func NewPool(ctx context.Context, config *types.Config) (*Pool, error) {
 	err = pool.QueryRow(ctx, "SHOW server_version_num").Scan(&versionStr)
 	if err != nil {
 		pool.Close()
-		return nil, &errors.ConnectionError{
+		return nil, &ConnectionError{
 			Message: fmt.Sprintf("failed to query PostgreSQL version: %v", err),
 		}
 	}
 
 	version, err := strconv.Atoi(versionStr)
 	if err != nil {
 		pool.Close()
-		return nil, &errors.ConnectionError{
+		return nil, &ConnectionError{
 			Message: fmt.Sprintf("failed to parse PostgreSQL version '%s': %v", versionStr, err),
 		}
 	}
 
 	// PostgreSQL 13+ required (version 130000+)
 	if version < 130000 {
 		pool.Close()
-		return nil, &errors.ConnectionError{
+		return nil, &ConnectionError{
 			Message:    fmt.Sprintf("PostgreSQL version %d is not supported (need 13+)", version/10000),
 			Suggestion: "Upgrade to PostgreSQL 13 or later",
 		}

internal/database/tempdb.go

@@ -75,16 +75,11 @@ func DestroyTempDatabase(ctx context.Context, pool *Pool, tempDB *types.TempData
 	defer conn.Release()
 
 	// Terminate all connections to the database first (PostgreSQL 13+)
-	terminateSQL := fmt.Sprintf(`
-		SELECT pg_terminate_backend(pid)
+	terminateSQL := `SELECT pg_terminate_backend(pid)
 		FROM pg_stat_activity
-		WHERE datname = '%s' AND pid <> pg_backend_pid()
-	`, tempDB.Name)
+		WHERE datname = $1 AND pid <> pg_backend_pid()`
 
-	_, err = conn.Exec(ctx, terminateSQL)
-	if err != nil {
-		// Non-fatal - database might not have any connections
-	}
+	_, _ = conn.Exec(ctx, terminateSQL, tempDB.Name)
 
 	// Drop database with FORCE option (PostgreSQL 13+)
 	dropSQL := fmt.Sprintf("DROP DATABASE IF EXISTS %s WITH (FORCE)", tempDB.Name)
@@ -127,7 +122,7 @@ func verifyDatabaseDropped(ctx context.Context, conn *pgxpool.Conn, dbName strin
 // CleanupStaleTempDatabases removes old pgcov temporary databases
 // This is useful for cleanup after crashes or interrupted test runs
 // Returns list of cleaned databases and any errors encountered
-func CleanupStaleTempDatabases(ctx context.Context, pool *Pool, olderThan time.Duration) ([]string, error) {
+func CleanupStaleTempDatabases(ctx context.Context, pool *Pool, _ time.Duration) ([]string, error) {
 	conn, err := pool.Acquire(ctx)
 	if err != nil {
 		return nil, fmt.Errorf("failed to acquire connection: %w", err)

internal/errors/errors.go

@@ -7,18 +7,12 @@ import (
 	"github.com/cybertec-postgresql/pgcov/internal/parser"
 )
 
-// Instrument takes parsed SQL and injects coverage tracking calls
-func Instrument(parsed *parser.ParsedSQL) (*InstrumentedSQL, error) {
-	// Use full instrumentation with NOTIFY injection
-	return InstrumentWithNotify(parsed)
-}
-
-// InstrumentBatch instruments multiple parsed SQL files
-func InstrumentBatch(parsedFiles []*parser.ParsedSQL) ([]*InstrumentedSQL, error) {
+// GenerateCoverageInstruments instruments multiple parsed SQL files
+func GenerateCoverageInstruments(parsedFiles []*parser.ParsedSQL) ([]*InstrumentedSQL, error) {
 	var instrumented []*InstrumentedSQL
 
 	for _, parsed := range parsedFiles {
-		inst, err := Instrument(parsed)
+		inst, err := GenerateCoverageInstrument(parsed)
 		if err != nil {
 			return nil, fmt.Errorf("failed to instrument %s: %w", parsed.File.Path, err)
 		}
@@ -39,7 +33,7 @@ func GetCoveragePointBySignal(instrumented *InstrumentedSQL, signalID string) *C
 }
 
 // InstrumentWithNotify instruments SQL by injecting NOTIFY calls for coverage tracking
-func InstrumentWithNotify(parsed *parser.ParsedSQL) (*InstrumentedSQL, error) {
+func GenerateCoverageInstrument(parsed *parser.ParsedSQL) (*InstrumentedSQL, error) {
 	if parsed == nil || parsed.File == nil {
 		return nil, fmt.Errorf("parsed SQL or file is nil")
 	}
@@ -263,29 +257,3 @@ func markStatementLinesAsCovered(stmt *parser.Statement, filePath string) []Cove
 
 	return locations
 }
-
-func readOriginalSQL(parsed *parser.ParsedSQL) string {
-	if len(parsed.Statements) == 0 {
-		return ""
-	}
-	var parts []string
-	for _, stmt := range parsed.Statements {
-		parts = append(parts, stmt.RawSQL)
-	}
-	return strings.Join(parts, "\n")
-}
-
-func findStatementPosition(sql string, lineNum int) int {
-	if lineNum <= 1 {
-		return 0
-	}
-	pos := 0
-	currentLine := 1
-	for i := 0; i < len(sql) && currentLine < lineNum; i++ {
-		if sql[i] == '\n' {
-			currentLine++
-			pos = i + 1
-		}
-	}
-	return pos
-}