aybabtme

package main

import (
	"bytes"
	"flag"
	"github.com/Shopify/go-lua"
	"github.com/kortschak/zalgo"
	"io"
	"log"
	"os"

aybabtme

Keybase proof

I hereby claim:

• I am aybabtme on github.
• I am antoineg (https://keybase.io/antoineg) on keybase.
• I have a public key whose fingerprint is 6F35 158F 2F17 763B 44F1 4396 C6DD 7E23 7AEA 9856

To claim this, I am signing this object:

aybabtme

//go:generate pipeliner map(func(string) (string, error) concurrently as concErrMap into conc_err_map.go
func concErrMap(concurrency int, fn func(string) (string, error), in <-chan string) (<-chan string, <-chan error) {
	out := make(chan string)
	errc := make(chan error, concurrency)
	done := make(chan struct{})
	go func() {
		defer close(out)
		defer close(errc)
		wg := sync.WaitGroup{}
		wg.Add(concurrency)

aybabtme

"snippets": [
  {
    "text": "sortby",
    "title": "type bySomeOrder []type",
    "value": "type $1 []$2\n\nfunc(b $1) Len() int { return len(b) }\nfunc(b $1) Swap(i, j int) { b[i],b[j] = b[j],b[i] }\nfunc(b $1) Less(i, j int) bool { return b[i].$3 < b[j].$3 }"
  },
],

aybabtme

// LogHook builds a func that can be fired by a doge/log through
// log.AddHook. If the entry it fires on contains an error, it will
// include a stacktrace of the logger's callsite.
//
//      import "doge/log"
//
//		log.AddHook(
//			sentry.LogHook("my.pkg/name"),
//			log.Lerror, log.Lpanic, log.Lfatal,

aybabtme

package log

import (
	"fmt"
	"log/syslog"
	"os"

	"github.com/Sirupsen/logrus"
)

aybabtme

switch {
case olderr != nil && newerr != nil:
	return diff, fmt.Errorf("reading both source, %v", olderr)
case olderr != nil:
	return diff, fmt.Errorf("reading old source, %v", olderr)
case newerr != nil:
	return diff, fmt.Errorf("reading new source, %v", newerr)
default:
	return diff, nil
}

aybabtme

// io.Writer implementer
type writer func(p []byte) (int, error)

func (w writer) Write(p []byte) (int, error) { return w(p) }

// magic, a testing.T writer!
func testwriter(t *testing.T) io.Writer {
	return writer(func(p []byte) (int, error) {
		t.Log(string(p))
		return 0, nil

aybabtme

// Example usage:
// Triggers an io.ErrUnexpectedEOF on the last read
func TestCanDiffWhenOldlistIsCorrupted(t *testing.T) {
	log.SetOutput(testwriter(t)) // log to testing.Log

	oldKeys := []s3.Key{{ETag: "1"}, {ETag: "3"}}
	newKeys := []s3.Key{{ETag: "1"}, {ETag: "2"}, {ETag: "3"}}
	want := []s3.Key{{ETag: "2"}}

	oldList := encodeKeys(oldKeys)

aybabtme

// accumulates non-nil errors

type errors []error

func (e *errors) Ack(err error) {
	if err != nil {
		*e = append(*e, err)
	}
}