octolab / pkg Goto Github PK

classifier := errors.Classifier{
  "some": []error{x, y, z}
}
class := classifier.Classify(err)
metrics.Count(class).Send()

import "github.com/Masterminds/semver"

var (
	min := fn.MustReturn(semver.NewConstraint(">= 92.0")).(*semver.Constraints)
)

sync.Times(100).Do(func () {
   ...
})

defer safe.Close(io.Discard(resp.Body), ...)

func NewRequest(options ...func(*http.Request)) *http.Request {
	req := new(http.Request)
	for _, configure := range options {
		configure(req)
	}
	return req
}

func WithForm(kv ...string) func(*http.Request) {
	return func(req *http.Request) {
		req.Form = make(url.Values, len(kv))

		for i := 0; i+1 < len(kv); i += 2 {
			req.Form.Set(kv[i], kv[i+1])
		}
	}
}

func WithHeaders(kv ...string) func(*http.Request) {
	return func(req *http.Request) {
		req.Header = make(http.Header, len(kv))

		for i := 0; i+1 < len(kv); i += 2 {
			req.Header.Set(kv[i], kv[i+1])
		}
	}
}

func WithPath(path string) func(*http.Request) {
	return func(req *http.Request) {
		req.URL = new(url.URL)
		req.URL.Path = path
	}
}

global.Classifier.Apply(err, action, errors.Loggable, errors.Critical)

data := helper.Bytes("file:testdata/some.file")

if errors.IsAny(err, Case1, Case2, ...) {}

sequence := new(integer.generator).Since(10).Rhythm(func (int64) int64).Until(10^5)

for range sequence.Source() { ... } // math.MaxInt64 by default

sequence.Next() bool

sequence.Current() int64

sequence.FastForward(int64) bool

uid := new(uuid.generator)

uid.Next() string ?

random := new(rand.generator)

random.Next() ?

classificator.Classify(err, fallback) -> classificator.Classify(err)

RepeatableReadCloser(
    helper.ReadCloser("file:testdata/some.data"),
    bytes.NewBuffer(make([]byte, 0, 5)),
)

job := async.NewDelayedJob(make([]func(), 0, 2))

if cond1 {
  job.Do(...)
}

if cond2 {
  job.Do(...)
}

job.Wait()

	wg :=&sync.WaitGroup{}
	wg.Add(len(data))
	for range data {
		go safe.Background(wg, func() { handler.ServeHTTP(rec, &http.Request{}) }, 1)
	}

file, err := safe.OpenFile()
if err ...
// no call defer file.Close()
// panic in runtime

Open() -> SetFinalizer

Close() -> UnsetFinalizer

local := packageX.Classificator.Merge(packageY.Classificator, packageZ.Classificator)
if !local.Consistent() {
  panic()
}

resp, err := http.Do(req)
if err {...}
defer safe.Close(io.Discard(resp.Body), ...) // now I can't read from body

json.NewDecoder(resp.Body).Decode() // woops

	ctx := context.Background()
	deadline, has := t.Deadline()
	if has {
		var cancel context.CancelFunc
		ctx, cancel = context.WithDeadline(ctx, deadline.Add(50*time.Millisecond))
		defer cancel()
	}