Strategy Pattern — Hands-on Tasks¶

package main

import (
    "fmt"
    "sort"
    "time"
)

type User struct {
    Name   string
    Age    int
    Joined time.Time
}

type LessFunc func(a, b User) bool

func SortUsers(users []User, less LessFunc) {
    sort.Slice(users, func(i, j int) bool { return less(users[i], users[j]) })
}

func Reverse(less LessFunc) LessFunc {
    return func(a, b User) bool { return less(b, a) }
}

var (
    ByName       LessFunc = func(a, b User) bool { return a.Name < b.Name }
    ByNameDesc            = Reverse(ByName)
    ByAge        LessFunc = func(a, b User) bool { return a.Age < b.Age }
    ByAgeDesc             = Reverse(ByAge)
    ByJoined     LessFunc = func(a, b User) bool { return a.Joined.Before(b.Joined) }
    ByJoinedDesc          = Reverse(ByJoined)
)

func main() {
    users := []User{
        {"Alice", 30, time.Date(2021, 3, 1, 0, 0, 0, 0, time.UTC)},
        {"Bob", 25, time.Date(2022, 1, 1, 0, 0, 0, 0, time.UTC)},
        {"Carol", 28, time.Date(2020, 6, 1, 0, 0, 0, 0, time.UTC)},
    }
    for _, demo := range []struct {
        label string
        less  LessFunc
    }{
        {"ByName", ByName},
        {"ByAgeDesc", ByAgeDesc},
        {"ByJoined", ByJoined},
    } {
        cp := append([]User(nil), users...)
        SortUsers(cp, demo.less)
        fmt.Printf("%s: ", demo.label)
        for _, u := range cp {
            fmt.Printf("%s ", u.Name)
        }
        fmt.Println()
    }
}

package csvparse

import (
    "strings"
    "unicode"
)

type Delimiter func(r rune) bool

func Comma(r rune) bool         { return r == ',' }
func Tab(r rune) bool           { return r == '\t' }
func Semicolon(r rune) bool     { return r == ';' }
func Pipe(r rune) bool          { return r == '|' }
func AnyWhitespace(r rune) bool { return r != '\n' && unicode.IsSpace(r) }

func Parse(text string, isDelim Delimiter) ([][]string, error) {
    var rows [][]string
    var row []string
    var field strings.Builder
    flushField := func() {
        row = append(row, field.String())
        field.Reset()
    }
    flushRow := func() {
        flushField()
        rows = append(rows, row)
        row = nil
    }
    for _, r := range text {
        switch {
        case r == '\n':
            flushRow()
        case isDelim(r):
            flushField()
        default:
            field.WriteRune(r)
        }
    }
    // Last row, only if there is unflushed content.
    if field.Len() > 0 || len(row) > 0 {
        flushRow()
    }
    return rows, nil
}

package logger

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "sort"
    "sync"
    "time"
)

type Record struct {
    Time   time.Time
    Level  string
    Msg    string
    Fields map[string]any
}

type Formatter interface {
    Format(rec Record) []byte
}

type TextFormatter struct{}

func (TextFormatter) Format(r Record) []byte {
    var b bytes.Buffer
    fmt.Fprintf(&b, "%s %s %s", r.Time.Format("2006-01-02 15:04:05"), r.Level, r.Msg)
    keys := make([]string, 0, len(r.Fields))
    for k := range r.Fields {
        keys = append(keys, k)
    }
    sort.Strings(keys)
    for _, k := range keys {
        fmt.Fprintf(&b, " %s=%v", k, r.Fields[k])
    }
    b.WriteByte('\n')
    return b.Bytes()
}

type JSONFormatter struct{}

func (JSONFormatter) Format(r Record) []byte {
    obj := map[string]any{
        "time":  r.Time.UTC().Format(time.RFC3339),
        "level": r.Level,
        "msg":   r.Msg,
    }
    for k, v := range r.Fields {
        obj[k] = v
    }
    out, _ := json.Marshal(obj)
    return append(out, '\n')
}

type ConsoleFormatter struct{}

func (ConsoleFormatter) Format(r Record) []byte {
    color := ""
    switch r.Level {
    case "ERROR":
        color = "\x1b[31m"
    case "WARN":
        color = "\x1b[33m"
    case "INFO":
        color = "\x1b[36m"
    }
    var b bytes.Buffer
    fmt.Fprintf(&b, "%s%s\x1b[0m %s", color, r.Level, r.Msg)
    keys := make([]string, 0, len(r.Fields))
    for k := range r.Fields {
        keys = append(keys, k)
    }
    sort.Strings(keys)
    for _, k := range keys {
        fmt.Fprintf(&b, " \x1b[2m%s\x1b[0m=%v", k, r.Fields[k])
    }
    b.WriteByte('\n')
    return b.Bytes()
}

type Logger struct {
    mu  sync.Mutex
    w   io.Writer
    fmt Formatter
}

func NewLogger(w io.Writer, f Formatter) *Logger { return &Logger{w: w, fmt: f} }

func parseKV(kv []any) map[string]any {
    m := make(map[string]any, len(kv)/2)
    for i := 0; i < len(kv); i += 2 {
        k, ok := kv[i].(string)
        if !ok {
            k = "!BADKEY"
        }
        var v any = "!MISSING"
        if i+1 < len(kv) {
            v = kv[i+1]
        }
        m[k] = v
    }
    return m
}

func (l *Logger) log(level, msg string, kv []any) {
    rec := Record{Time: time.Now(), Level: level, Msg: msg, Fields: parseKV(kv)}
    out := l.fmt.Format(rec)
    l.mu.Lock()
    defer l.mu.Unlock()
    _, _ = l.w.Write(out)
}

func (l *Logger) Info(msg string, kv ...any)  { l.log("INFO", msg, kv) }
func (l *Logger) Warn(msg string, kv ...any)  { l.log("WARN", msg, kv) }
func (l *Logger) Error(msg string, kv ...any) { l.log("ERROR", msg, kv) }

package authclient

import (
    "encoding/base64"
    "encoding/json"
    "fmt"
    "net/http"
    "net/url"
    "strings"
    "sync"
    "time"
)

type Authenticator interface {
    Apply(req *http.Request) error
}

type BasicAuth struct {
    User string
    Pass string
}

func (b BasicAuth) Apply(req *http.Request) error {
    tok := base64.StdEncoding.EncodeToString([]byte(b.User + ":" + b.Pass))
    req.Header.Set("Authorization", "Basic "+tok)
    return nil
}

type BearerAuth struct {
    Token string
}

func (b BearerAuth) Apply(req *http.Request) error {
    req.Header.Set("Authorization", "Bearer "+b.Token)
    return nil
}

type OAuth2 struct {
    endpoint     string
    clientID     string
    clientSecret string

    mu      sync.Mutex
    token   string
    expires time.Time
    hc      *http.Client
}

func NewOAuth2(endpoint, clientID, clientSecret string) *OAuth2 {
    return &OAuth2{endpoint: endpoint, clientID: clientID, clientSecret: clientSecret, hc: &http.Client{Timeout: 10 * time.Second}}
}

func (o *OAuth2) Apply(req *http.Request) error {
    tok, err := o.fetchToken()
    if err != nil {
        return err
    }
    req.Header.Set("Authorization", "Bearer "+tok)
    return nil
}

func (o *OAuth2) fetchToken() (string, error) {
    o.mu.Lock()
    defer o.mu.Unlock()
    if o.token != "" && time.Now().Before(o.expires) {
        return o.token, nil
    }
    form := url.Values{
        "grant_type":    {"client_credentials"},
        "client_id":     {o.clientID},
        "client_secret": {o.clientSecret},
    }
    resp, err := o.hc.Post(o.endpoint, "application/x-www-form-urlencoded", strings.NewReader(form.Encode()))
    if err != nil {
        return "", fmt.Errorf("OAuth2: %w", err)
    }
    defer resp.Body.Close()
    var body struct {
        AccessToken string `json:"access_token"`
        ExpiresIn   int    `json:"expires_in"`
    }
    if err := json.NewDecoder(resp.Body).Decode(&body); err != nil {
        return "", fmt.Errorf("OAuth2: decode: %w", err)
    }
    if body.AccessToken == "" {
        return "", fmt.Errorf("OAuth2: empty token")
    }
    o.token = body.AccessToken
    // Refresh slightly before expiry.
    o.expires = time.Now().Add(time.Duration(body.ExpiresIn-30) * time.Second)
    return o.token, nil
}

type Client struct {
    hc   *http.Client
    auth Authenticator
}

func NewClient(hc *http.Client, auth Authenticator) *Client {
    if hc == nil {
        hc = http.DefaultClient
    }
    return &Client{hc: hc, auth: auth}
}

func (c *Client) Do(req *http.Request) (*http.Response, error) {
    if c.auth != nil {
        if err := c.auth.Apply(req); err != nil {
            return nil, err
        }
    }
    return c.hc.Do(req)
}

package cache

import (
    "container/list"
    "sync"
)

type Policy interface {
    Touch(key string)
    Add(key string)
    Remove(key string)
    Evict() string
}

// LRU

type LRU struct {
    order *list.List
    index map[string]*list.Element
}

func NewLRU() *LRU { return &LRU{order: list.New(), index: map[string]*list.Element{}} }

func (l *LRU) Touch(k string) {
    if el, ok := l.index[k]; ok {
        l.order.MoveToBack(el)
    }
}
func (l *LRU) Add(k string) { l.index[k] = l.order.PushBack(k) }
func (l *LRU) Remove(k string) {
    if el, ok := l.index[k]; ok {
        l.order.Remove(el)
        delete(l.index, k)
    }
}
func (l *LRU) Evict() string {
    front := l.order.Front()
    if front == nil {
        return ""
    }
    k := front.Value.(string)
    l.order.Remove(front)
    delete(l.index, k)
    return k
}

// LFU

type LFU struct {
    freq map[string]int
}

func NewLFU() *LFU { return &LFU{freq: map[string]int{}} }

func (l *LFU) Touch(k string) {
    if _, ok := l.freq[k]; ok {
        l.freq[k]++
    }
}
func (l *LFU) Add(k string)    { l.freq[k] = 1 }
func (l *LFU) Remove(k string) { delete(l.freq, k) }
func (l *LFU) Evict() string {
    var minKey string
    min := -1
    for k, v := range l.freq {
        if min == -1 || v < min {
            min = v
            minKey = k
        }
    }
    delete(l.freq, minKey)
    return minKey
}

// FIFO

type FIFO struct {
    order []string
}

func NewFIFO() *FIFO { return &FIFO{} }

func (f *FIFO) Touch(_ string) {}
func (f *FIFO) Add(k string)   { f.order = append(f.order, k) }
func (f *FIFO) Remove(k string) {
    for i, x := range f.order {
        if x == k {
            f.order = append(f.order[:i], f.order[i+1:]...)
            return
        }
    }
}
func (f *FIFO) Evict() string {
    if len(f.order) == 0 {
        return ""
    }
    k := f.order[0]
    f.order = f.order[1:]
    return k
}

// Cache

type Cache struct {
    mu       sync.Mutex
    data     map[string]any
    policy   Policy
    capacity int
}

func NewCache(cap int, p Policy) *Cache {
    return &Cache{data: map[string]any{}, policy: p, capacity: cap}
}

func (c *Cache) Set(k string, v any) {
    c.mu.Lock()
    defer c.mu.Unlock()
    if _, ok := c.data[k]; ok {
        c.data[k] = v
        c.policy.Touch(k)
        return
    }
    if len(c.data) >= c.capacity {
        evicted := c.policy.Evict()
        if evicted != "" {
            delete(c.data, evicted)
        }
    }
    c.data[k] = v
    c.policy.Add(k)
}

func (c *Cache) Get(k string) (any, bool) {
    c.mu.Lock()
    defer c.mu.Unlock()
    v, ok := c.data[k]
    if ok {
        c.policy.Touch(k)
    }
    return v, ok
}

package payment

import (
    "context"
    "errors"
    "fmt"
    "math/rand"
)

type Order struct {
    ID          string
    AmountCents int
    Currency    string
}

type Charge struct {
    ID      string
    Order   Order
    Gateway string
}

type Charger interface {
    Charge(ctx context.Context, o Order) (Charge, error)
}

type Refunder interface {
    Refund(ctx context.Context, chargeID string, amountCents int) error
}

type Authorizer interface {
    Authorize(ctx context.Context, o Order) (Charge, error)
}

// Gateways

type StripeGateway struct {
    key string
    rng *rand.Rand
}

func NewStripeGateway(key string) *StripeGateway {
    return &StripeGateway{key: key, rng: rand.New(rand.NewSource(1))}
}

func (s *StripeGateway) Charge(ctx context.Context, o Order) (Charge, error) {
    if s.rng.Float64() < 0.05 {
        return Charge{}, errors.New("stripe: transient")
    }
    return Charge{ID: "stripe_" + o.ID, Order: o, Gateway: "stripe"}, nil
}

func (s *StripeGateway) Refund(ctx context.Context, id string, amount int) error {
    return nil
}

func (s *StripeGateway) Authorize(ctx context.Context, o Order) (Charge, error) {
    return Charge{ID: "stripe_auth_" + o.ID, Order: o, Gateway: "stripe"}, nil
}

type PayPalGateway struct{ rng *rand.Rand }

func NewPayPalGateway() *PayPalGateway { return &PayPalGateway{rng: rand.New(rand.NewSource(2))} }
func (p *PayPalGateway) Charge(ctx context.Context, o Order) (Charge, error) {
    if p.rng.Float64() < 0.05 {
        return Charge{}, errors.New("paypal: transient")
    }
    return Charge{ID: "pp_" + o.ID, Order: o, Gateway: "paypal"}, nil
}
func (p *PayPalGateway) Refund(ctx context.Context, id string, amount int) error { return nil }
func (p *PayPalGateway) Authorize(ctx context.Context, o Order) (Charge, error) {
    return Charge{ID: "pp_auth_" + o.ID, Order: o, Gateway: "paypal"}, nil
}

type SquareGateway struct{}

func NewSquareGateway() *SquareGateway { return &SquareGateway{} }
func (s *SquareGateway) Charge(ctx context.Context, o Order) (Charge, error) {
    return Charge{ID: "sq_" + o.ID, Order: o, Gateway: "square"}, nil
}

// Processor

type Processor struct{ charger Charger }

func NewProcessor(c Charger) *Processor { return &Processor{charger: c} }

func (p *Processor) Charge(ctx context.Context, o Order) (Charge, error) {
    if o.AmountCents <= 0 {
        return Charge{}, errors.New("Charge: non-positive amount")
    }
    if o.Currency == "" {
        return Charge{}, errors.New("Charge: empty currency")
    }
    return p.charger.Charge(ctx, o)
}

// RetryingCharger — decorator over Charger

type RetryingCharger struct {
    Inner    Charger
    Attempts int
}

func (r *RetryingCharger) Charge(ctx context.Context, o Order) (Charge, error) {
    var lastErr error
    for i := 0; i < r.Attempts; i++ {
        c, err := r.Inner.Charge(ctx, o)
        if err == nil {
            return c, nil
        }
        lastErr = err
    }
    return Charge{}, fmt.Errorf("after %d attempts: %w", r.Attempts, lastErr)
}

package codec

import (
    "bytes"
    "compress/gzip"
    "encoding/base64"
    "errors"
    "fmt"
    "io"
    "sort"
    "sync"
)

type Codec interface {
    Encode([]byte) []byte
    Decode([]byte) ([]byte, error)
    Name() string
}

var (
    mu       sync.RWMutex
    registry = map[string]Codec{}
)

func Register(name string, c Codec) {
    mu.Lock()
    defer mu.Unlock()
    if _, dup := registry[name]; dup {
        panic("codec: duplicate registration for " + name)
    }
    registry[name] = c
}

func Get(name string) (Codec, error) {
    mu.RLock()
    defer mu.RUnlock()
    c, ok := registry[name]
    if !ok {
        return nil, fmt.Errorf("codec: unknown %q", name)
    }
    return c, nil
}

func List() []string {
    mu.RLock()
    defer mu.RUnlock()
    out := make([]string, 0, len(registry))
    for k := range registry {
        out = append(out, k)
    }
    sort.Strings(out)
    return out
}

type GzipCodec struct{}

func (GzipCodec) Name() string { return "gzip" }
func (GzipCodec) Encode(in []byte) []byte {
    var buf bytes.Buffer
    w := gzip.NewWriter(&buf)
    _, _ = w.Write(in)
    _ = w.Close()
    return buf.Bytes()
}
func (GzipCodec) Decode(in []byte) ([]byte, error) {
    r, err := gzip.NewReader(bytes.NewReader(in))
    if err != nil {
        return nil, err
    }
    defer r.Close()
    return io.ReadAll(r)
}

type SnappyCodec struct{}

func (SnappyCodec) Name() string             { return "snappy" }
func (SnappyCodec) Encode(in []byte) []byte  { return []byte(base64.StdEncoding.EncodeToString(in)) }
func (SnappyCodec) Decode(in []byte) ([]byte, error) {
    out, err := base64.StdEncoding.DecodeString(string(in))
    if err != nil {
        return nil, errors.New("snappy: bad data")
    }
    return out, nil
}

type ZstdCodec struct{}

func (ZstdCodec) Name() string             { return "zstd" }
func (ZstdCodec) Encode(in []byte) []byte  { return []byte(base64.URLEncoding.EncodeToString(in)) }
func (ZstdCodec) Decode(in []byte) ([]byte, error) {
    return base64.URLEncoding.DecodeString(string(in))
}

func init() {
    Register("gzip", GzipCodec{})
    Register("snappy", SnappyCodec{})
    Register("zstd", ZstdCodec{})
}