Collapse

The automatic threshold

kazari.config.yaml sets collapsible.lineThreshold: 18, so any block longer than that collapses to a six line preview with a toggle in the toolbar. This block needs no attributes at all.

1
package pipeline
2
3
import (
4
  "context"
5
  "errors"
6
  "sync"
7
)
8
9
type Stage func(context.Context, []byte) ([]byte, error)
10
11
type Pipeline struct {
12
  stages []Stage
13
  mu     sync.Mutex
14
}
15
16
func New(stages ...Stage) *Pipeline {
17
  return &Pipeline{stages: stages}
18
}
19
20
func (p *Pipeline) Run(ctx context.Context, in []byte) ([]byte, error) {
21
  p.mu.Lock()
22
  defer p.mu.Unlock()
23
  if len(p.stages) == 0 {
24
    return nil, errors.New("pipeline: no stages")
25
  }
26
  out := in
27
  for _, stage := range p.stages {
28
    next, err := stage(ctx, out)
29
    if err != nil {
30
      return nil, err
31
    }
32
    out = next
33
  }
34
  return out, nil
35
}

Opting one block out

nocollapse="true" keeps a long block fully expanded even though it crosses the threshold.

1
package config
2
3
const (
4
  DefaultAddr        = ":8080"
5
  DefaultReadTimeout = 15
6
  DefaultIdleTimeout = 60
7
  DefaultMaxHeader   = 1 << 20
8
  DefaultLogLevel    = "info"
9
  DefaultCacheTTL    = 300
10
  DefaultRetries     = 3
11
  DefaultBackoffMS   = 250
12
  DefaultPoolSize    = 32
13
  DefaultQueueDepth  = 128
14
  DefaultBatchSize   = 64
15
  DefaultFlushEvery  = 5
16
  DefaultShutdownSec = 30
17
  DefaultMetricsPath = "/metrics"
18
  DefaultHealthPath  = "/healthz"
19
  DefaultProfilePath = "/debug/pprof"
20
)

Explicit ranges

collapse takes ranges of its own, which folds boilerplate in the middle of a short block that the threshold would never touch.

1
package main
2
7 collapsed lines
3
import (
4
  "context"
5
  "flag"
6
  "log"
7
  "net/http"
8
  "os"
9
  "os/signal"
10
)
11
12
func main() {
13
  addr := flag.String("addr", ":8080", "listen address")
14
  flag.Parse()
15
  log.Fatal(http.ListenAndServe(*addr, nil))
16
}

Collapse styles

The default style renders each folded region as a summary row. The collapsible-start, collapsible-end, and collapsible-auto styles attach the control to the edge of the region instead.

1
func setup() error {
5 collapsed lines
2
  if err := loadEnv(); err != nil {
3
    return err
4
  }
5
  if err := openDB(); err != nil {
6
    return err
7
  }
8
  return serve()
9
}

1
func teardown() error {
5 collapsed lines
2
  if err := flushQueue(); err != nil {
3
    return err
4
  }
5
  if err := closeDB(); err != nil {
6
    return err
7
  }
8
  return nil
9
}

A per block threshold

collapsethreshold overrides the config wide number for one block. At 8, this ten line block collapses even though the site default of 18 would leave it alone.

1
func routes(mux *http.ServeMux) {
2
  mux.HandleFunc("/", index)
3
  mux.HandleFunc("/about", about)
4
  mux.HandleFunc("/login", login)
5
  mux.HandleFunc("/logout", logout)
6
  mux.HandleFunc("/search", search)
7
  mux.HandleFunc("/healthz", health)
8
  mux.HandleFunc("/metrics", metrics)
9
  mux.HandleFunc("/version", version)
10
}