30fc7775a5
Modernizes several `internal/*` packages under the Go proxy, replaces
third-party forks with standard-library primitives, and brings the
test suite from near-zero to high coverage across the touched packages.
Package changes
- **`internal/errors`** — Rewrites the `pkg/errors` fork as a thin
wrapper
over stdlib `errors`. A single `withStack` struct captures stack
traces via `runtime.Callers`; `fmt.Errorf("%w", ...)` handles all
message wrapping. Restores `errors.Is`/`As`/`Unwrap` chain traversal
(silently broken in the fork) and deletes ~190 lines of stack/frame
formatting. `Is`, `As`, `Unwrap`, and `Join` are re-exported so
callers need a single import.
- **`internal/logger`** — Swaps stdlib `log.Logger` for `log/slog` JSON
handlers with UTC timestamps and custom level labels (`verb`, `debug`,
`warn`, `error`). Hides `withContextID` (no external callers).
- **`internal/sync`** — Converts `Map[K, V]` from a concrete struct to
an interface with a `NewMap` constructor for testability.
- **`internal/signal`** — Adds `signalNotify` / `osExit` indirections so
`InstallSignals` and `InstallForceQuit` can be exercised without real
OS signals or process termination.
- **`internal/utils`** — Drops deprecated `io/ioutil` and the stdlib
`errors` alias (the internal `errors` package re-exports what's
needed).
- **`internal/version`** — No code changes; fully covered by new tests.
---------
Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
59 lines
1.2 KiB
Go
59 lines
1.2 KiB
Go
// Copyright (c) 2026 Winlin
|
|
//
|
|
// SPDX-License-Identifier: MIT
|
|
package sync
|
|
|
|
import "sync"
|
|
|
|
type Map[K comparable, V any] interface {
|
|
Delete(key K)
|
|
Load(key K) (value V, ok bool)
|
|
LoadAndDelete(key K) (value V, loaded bool)
|
|
LoadOrStore(key K, value V) (actual V, loaded bool)
|
|
Range(f func(key K, value V) bool)
|
|
Store(key K, value V)
|
|
}
|
|
|
|
func NewMap[K comparable, V any]() Map[K, V] {
|
|
return &mapImpl[K, V]{}
|
|
}
|
|
|
|
type mapImpl[K comparable, V any] struct {
|
|
m sync.Map
|
|
}
|
|
|
|
func (m *mapImpl[K, V]) Delete(key K) {
|
|
m.m.Delete(key)
|
|
}
|
|
|
|
func (m *mapImpl[K, V]) Load(key K) (value V, ok bool) {
|
|
v, ok := m.m.Load(key)
|
|
if !ok {
|
|
return value, ok
|
|
}
|
|
return v.(V), ok
|
|
}
|
|
|
|
func (m *mapImpl[K, V]) LoadAndDelete(key K) (value V, loaded bool) {
|
|
v, loaded := m.m.LoadAndDelete(key)
|
|
if !loaded {
|
|
return value, loaded
|
|
}
|
|
return v.(V), loaded
|
|
}
|
|
|
|
func (m *mapImpl[K, V]) LoadOrStore(key K, value V) (actual V, loaded bool) {
|
|
a, loaded := m.m.LoadOrStore(key, value)
|
|
return a.(V), loaded
|
|
}
|
|
|
|
func (m *mapImpl[K, V]) Range(f func(key K, value V) bool) {
|
|
m.m.Range(func(key, value any) bool {
|
|
return f(key.(K), value.(V))
|
|
})
|
|
}
|
|
|
|
func (m *mapImpl[K, V]) Store(key K, value V) {
|
|
m.m.Store(key, value)
|
|
}
|