Removing need for runner.New (#1)

Removing need for runner.New()

Author: raksly

README.md

@@ -11,44 +11,44 @@ Documentation available on [GoDoc](https://godoc.org/github.com/raksly/runner).
 ## Examples
 ### Minimalistic
 ```golang
-runner := runner.New(context.Background())
+var r runner.Runner
 
-runner.Run(runHTTP)
-runner.Run(runTCP)
+r.Run(runHTTP)
+r.Run(runTCP)
 
-runner.Wait()
+r.Wait()
 ```
-`runHTTP` and `runTCP` are both of type `func()`. `runner.Run` will run both functions in separate goroutines, and `runner.Wait()` waits until both functions exit.
+`runHTTP` and `runTCP` are both of type `func()`. `r.Run` will run both functions in separate goroutines, and `r.Wait()` waits until both functions exit.
 ### Exit notification
 When `runTCP` exits, it might be because the application is supposed to exit alltogether, or there was an irrecoverable error. In that case, you might want HTTP to exit aswell. `Run*` methods return a channel which is closed when its running function returns.
 ```golang
 ctx, cancel := context.WithCancel(context.Background())
-runner := runner.New(ctx)
+r := runner.Runner{Ctx: ctx}
 
 select {
-case <-runner.RunContext(runHTTP):
-case <-runner.RunContext(runTCP):
+case <-r.RunContext(runHTTP):
+case <-r.RunContext(runTCP):
 }
 
 cancel()
-runner.Wait()
+r.Wait()
 ```
 Both `runHTTP` and `runTCP` are now of type `func(context.Context)` and 
-are given the context passed to `runner.New`. If either `runHTTP` or `runTCP` returns, `select` will break, the context will be cancelled, making the other function exit aswell in due time, and `runner.Wait()` waits for that.
+are given the context `Runner.Ctx`. If either `runHTTP` or `runTCP` returns, `select` will break, the context will be cancelled, making the other function exit aswell in due time, and `r.Wait()` waits for that.
 ### Signals
 `Runner` contains a convenience method to work with OS signals
 ```golang
 ctx, cancel := context.WithCancel(context.Background())
-runner := runner.New(ctx)
+r := runner.Runner{Ctx: ctx}
 
 select {
-case <-runner.RunContext(runHTTP):
-case <-runner.RunContext(runTCP):
-case <-runner.RunSigs(syscall.SIGINT, syscall.SIGTERM):
+case <-r.RunContext(runHTTP):
+case <-r.RunContext(runTCP):
+case <-r.RunSigs(syscall.SIGINT, syscall.SIGTERM):
 }
 
 cancel()
-runner.Wait()
+r.Wait()
 ```
 If either `runHTTP` or `runTCP` returns, or `SIGINT`/`SIGTERM` is received,
 the context will be cancelled and we wait for everything to clean up.
@@ -57,16 +57,15 @@ You might want to pass more than just a context to your function. To archive
 this, you may use closures
 ```golang
 ctx, cancel := context.WithCancel(context.Background())
-runner := runner.New(ctx)
+r := runner.Runner{Ctx: ctx}
 
 select {
-// runSomething blocks on <-ctx.Done()
-case <-runner.Run(func() { runSomething(ctx, 1, 2, 3) }):
-case <-runner.RunSigs(syscall.SIGINT, syscall.SIGTERM):
-    cancel()
+case <-r.Run(func() { runSomething(ctx, 1, 2, 3) }):
+case <-r.RunSigs(syscall.SIGINT, syscall.SIGTERM):
 }
 
-runner.Wait()
+cancel()
+r.Wait()
 ```
 ## License
 MIT

examples/exit_notification/main.go

@@ -22,15 +22,15 @@ func runHTTP(ctx context.Context) {
 
 func main() {
 	ctx, cancel := context.WithCancel(context.Background())
-	runner := runner.New(ctx)
+	r := runner.Runner{Ctx: ctx}
 
 	select {
-	case <-runner.RunContext(runHTTP):
+	case <-r.RunContext(runHTTP):
 		fmt.Println("Exited runHTTP")
-	case <-runner.RunContext(runTCP):
+	case <-r.RunContext(runTCP):
 		fmt.Println("Exited runTCP")
 	}
 
 	cancel()
-	runner.Wait()
+	r.Wait()
 }

examples/minimalistic/main.go

@@ -1,7 +1,6 @@
 package main
 
 import (
-	"context"
 	"fmt"
 	"time"
 
@@ -21,10 +20,10 @@ func runHTTP() {
 }
 
 func main() {
-	runner := runner.New(context.Background())
+	var r runner.Runner
 
-	runner.Run(runHTTP)
-	runner.Run(runTCP)
+	r.Run(runHTTP)
+	r.Run(runTCP)
 
-	runner.Wait()
+	r.Wait()
 }

examples/multiple_parameters/main.go

@@ -16,15 +16,15 @@ func runSomething(ctx context.Context, a, b, c int) {
 
 func main() {
 	ctx, cancel := context.WithCancel(context.Background())
-	runner := runner.New(ctx)
+	r := runner.Runner{Ctx: ctx}
 
 	select {
-	case <-runner.Run(func() { runSomething(ctx, 1, 2, 3) }):
+	case <-r.Run(func() { runSomething(ctx, 1, 2, 3) }):
 		fmt.Println("Exited runSomething")
-	case sig := <-runner.RunSigs(syscall.SIGINT, syscall.SIGTERM):
+	case sig := <-r.RunSigs(syscall.SIGINT, syscall.SIGTERM):
 		fmt.Println("Received signal", sig)
-		cancel()
 	}
 
-	runner.Wait()
+	cancel()
+	r.Wait()
 }

examples/signals/main.go

@@ -22,17 +22,17 @@ func runHTTP(ctx context.Context) {
 
 func main() {
 	ctx, cancel := context.WithCancel(context.Background())
-	runner := runner.New(ctx)
+	r := runner.Runner{Ctx: ctx}
 
 	select {
-	case <-runner.RunContext(runHTTP):
+	case <-r.RunContext(runHTTP):
 		fmt.Println("Exited runHTTP")
-	case <-runner.RunContext(runTCP):
+	case <-r.RunContext(runTCP):
 		fmt.Println("Exited runTCP")
-	case sig := <-runner.RunSigs(syscall.SIGINT, syscall.SIGTERM):
+	case sig := <-r.RunSigs(syscall.SIGINT, syscall.SIGTERM):
 		fmt.Println("Received signal", sig)
 	}
 
 	cancel()
-	runner.Wait()
+	r.Wait()
 }

runner.go

@@ -19,25 +19,24 @@ import (
 )
 
 // New creates a new Runner
+// Deprecated: Use runner.Runner{}
 func New(ctx context.Context) Runner {
-	return Runner{
-		ctx: ctx,
-		wg:  &sync.WaitGroup{},
-	}
+	return Runner{Ctx: ctx}
 }
 
 // Runner runs functions in goroutines with `Run`, `RunContext` and/or
 // `RunOtherContext`, returning a channel that is closed when the goroutine
 // exits.
 // You may wait on all goroutines to finish using `Wait`.
 type Runner struct {
-	ctx context.Context
-	wg  *sync.WaitGroup
+	// Ctx will be passed to functions called by `RunContext`
+	Ctx context.Context
+	wg  sync.WaitGroup
 }
 
 // Run runs a function of type func() in a new goroutine.
 // The returned channel is closed when f returns
-func (r Runner) Run(f func()) <-chan struct{} {
+func (r *Runner) Run(f func()) <-chan struct{} {
 	done := make(chan struct{})
 	r.wg.Add(1)
 	go func() {
@@ -51,31 +50,32 @@ func (r Runner) Run(f func()) <-chan struct{} {
 }
 
 // RunContext is like `Run`, but passes the context given to `New`.
-func (r Runner) RunContext(f func(context.Context)) <-chan struct{} {
-	return r.RunOtherContext(r.ctx, f)
+func (r *Runner) RunContext(f func(context.Context)) <-chan struct{} {
+	return r.RunOtherContext(r.Ctx, f)
 }
 
 // RunOtherContext is like `RunContext`, except you may specify which
 // context to be passed to f.
-func (r Runner) RunOtherContext(ctx context.Context, f func(context.Context)) <-chan struct{} {
+func (r *Runner) RunOtherContext(ctx context.Context, f func(context.Context)) <-chan struct{} {
 	return r.Run(func() { f(ctx) })
 }
 
 // RunSigs is a convenience method to work with OS signals.
 // Unlike the other `Run*` functions, the channel returned
 // is not closed, but reads the received signal.
-func (r Runner) RunSigs(sigs ...os.Signal) <-chan os.Signal {
+func (r *Runner) RunSigs(sigs ...os.Signal) <-chan os.Signal {
 	sig := make(chan os.Signal, 1)
 	signal.Notify(sig, sigs...)
 	return sig
 }
 
 // Wait waits for all goroutines started by this runner.
-func (r Runner) Wait() {
+func (r *Runner) Wait() {
 	r.wg.Wait()
 }
 
 // Context returns the context given to `New`.
-func (r Runner) Context() context.Context {
-	return r.ctx
+// Deprecated: Access Runner.Ctx directly.
+func (r *Runner) Context() context.Context {
+	return r.Ctx
 }

runner_test.go

@@ -8,6 +8,7 @@ import (
 	"time"
 
 	"github.com/raksly/runner"
+
 	"github.com/stretchr/testify/assert"
 )
 
@@ -32,6 +33,50 @@ func assertChan(assert *assert.Assertions, c interface{}, expectClosed bool) {
 	}
 }
 
+func Test2(t *testing.T) {
+	assert := assert.New(t)
+
+	ctx, cancel := context.WithCancel(context.Background())
+	r := runner.Runner{Ctx: ctx}
+
+	c1 := r.Run(run)
+	c2 := r.RunContext(runContext)
+	c3 := r.RunOtherContext(ctx, runContext)
+	c4 := r.RunSigs(syscall.SIGINT)
+
+	select {
+	case <-c1:
+	case <-c2:
+		assert.Fail("should not run")
+	case <-c3:
+		assert.Fail("should not run")
+	case <-c4:
+		assert.Fail("should not run")
+	}
+
+	assertChan(assert, c1, true)
+	assertChan(assert, c2, false)
+	assertChan(assert, c3, false)
+	assertChan(assert, c4, false)
+
+	cancel()
+	r.Wait()
+
+	assertChan(assert, c2, true)
+	assertChan(assert, c3, true)
+	assertChan(assert, c4, false)
+
+	var r2 runner.Runner
+
+	r2.Run(func() {})
+	r2.RunContext(func(ctx context.Context) {
+		assert.Nil(ctx)
+	})
+
+	r2.Wait()
+}
+
+// Keeping Test1 to ensure the old api still works
 func Test1(t *testing.T) {
 	assert := assert.New(t)