Use tickers instead of for loops with sleep, replace interface{} with any

.gitignore

@@ -1,2 +1,2 @@
-i3status-go
+/i3status-go
-i3status-go.json
+/battery-test

Makefile

@@ -1,22 +1,23 @@
 #!/usr/bin/env gmake -f
 
 BUILDOPTS=-ldflags="-s -w" -a -gcflags=all=-l -trimpath
-FILELIST=batteries.go clock.go collection.go config.go cputemp.go cron.go i3.go ifmon.go la.go main.go memory.go \
-         pulseaudio.go signal.go spawn.go stdin.go vpn.go
 
 BINARY=i3status-go
+TEST1=battery-test
 
 ## Use calssic targets where first one is deafult target
 all: clean build
 
 ## This target compiles binary
 build:
-	go build ${BUILDOPTS} -o ${BINARY} ${FILELIST}
+	go build ${BUILDOPTS} -o ${BINARY} ./cmd/${BINARY}
 
+battery-test:
+	go build ${BUILDOPTS} -o ${TEST1} ./cmd/${TEST1}
 
 ## Remove binary with golang compiler' means
 clean:
-	go clean
+	rm -rf ${BINARY} ${TEST1}
 
 
 ## Misc target, for development purposes. Updates vendored libs, brutal way.

cmd/battery-test/main.go

@@ -0,0 +1,23 @@
+package main
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/davecgh/go-spew/spew"
+	"github.com/distatus/battery"
+)
+
+// Program entry point.
+func main() {
+	for {
+		batteries, err := battery.GetAll()
+
+		if err != nil {
+			fmt.Printf("Unable to get battery info: %w", err)
+		}
+
+		spew.Dump(batteries)
+		time.Sleep(1 * time.Second)
+	}
+}

cmd/i3status-go/main.go

@@ -2,58 +2,48 @@ package main
 
 import (
 	"bytes"
-	"embed"
+	_ "embed"
 	"encoding/json"
 	"fmt"
 	"log"
+	"os"
 	"os/signal"
 	"strings"
 	"syscall"
+
+	"i3status-go/internal/lib"
 )
 
-// I3BarOutBlock is structure element for I3BarOut, it represents i3bar output json block format.
+//go:embed default-config.json
-type I3BarOutBlock struct {
-	FullText string `json:"full_text"`
-	// ShortText will be shown if not enough room for FullText, threshold width defined in MinWidth
-	ShortText    string `json:"short_text,omitempty"`
-	Color        string `json:"color,omitempty"`
-	Background   string `json:"background,omitempty"`
-	Border       string `json:"border,omitempty"`
-	BorderTop    int    `json:"border_top"`
-	BorderRight  int    `json:"border_right"`
-	BorderBottom int    `json:"border_bottom"`
-	BorderLeft   int    `json:"border_left"`
-	// measured either in pixels or in characters, so either int or string, let's make it string :)
-	MinWidth            string `json:"min_width,omitempty"`
-	Align               string `json:"align,omitempty"`
-	Name                string `json:"name,omitempty"`
-	Instance            string `json:"instance,omitempty"`
-	Urgent              bool   `json:"urgent,omitempty"`
-	Separator           bool   `json:"separator"`
-	SeparatorBlockWidth int    `json:"separator_block_width"`
-	Markup              string `json:"markup,omitempty"`
-}
-
-// UpdateReady channel that "refreshes" i3bar (generates stdout json line).
-var UpdateReady = make(chan bool)
-var MsgChan = make(chan []I3BarOutBlock, 64)
-
-//go:embed i3status-go-example.json
-var EmbeddedDefaultConfig embed.FS
 var DefaultConfig []byte
 
-func init() {
-	DefaultConfig, _ = EmbeddedDefaultConfig.ReadFile("i3status-go-example.json")
-}
-
 // Program entry point.
 func main() {
-	var err error
+	Conf, err := lib.ReadConf(DefaultConfig)
 
-	Conf, err = readConf()
+	if err != nil {
+		log.Panicf("Unable to read config: %s", err)
+	}
+
+	Conf.Channels.UpdateReady = make(chan bool)
+	Conf.Channels.SVPAHandlerChan = make(chan lib.ClickEvent, 256)
+	Conf.Channels.MsgChan = make(chan []lib.I3BarOutBlock, 64)
+	Conf.Channels.SigChan = make(chan os.Signal, 1)
+	Conf.Channels.RunChan = make(chan []string, 128)
+	Conf.Values.PrintOutput = true
+	Conf.Values.BatteryString = "<big>⚡</big> ??% •"
+	Conf.Values.ClockTime = "Thu, 1 Jan 1970   1:00"
+	Conf.Values.IfStatus = ""
+	Conf.Values.VPNStatus = ""
+	Conf.Values.Memory.Shared = 0
+	Conf.Values.Memory.Usedpct = 0
+	Conf.Values.Memory.Swap = 0
+	Conf.Values.La = "-1"
+	// Conf.Values.PA
+	Conf.Values.SoundVolume = "🔊:0%"
 
 	// TODO: Проставить дефолтные значения для глобальных переменных модулей.
-	Batt = fmt.Sprintf(
+	Conf.Values.BatteryString = fmt.Sprintf(
 		"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
 		Conf.Battery.Color,
 		Conf.Battery.Background,
@@ -62,7 +52,7 @@ func main() {
 		Conf.Battery.Symbol,
 	)
 
-	Batt += fmt.Sprintf(
+	Conf.Values.BatteryString += fmt.Sprintf(
 		"<span color='%s' background='%s' font='%s' size='%s'> ??%% •</span>",
 		Conf.Battery.Color,
 		Conf.Battery.Background,
@@ -70,7 +60,7 @@ func main() {
 		Conf.Battery.FontSize,
 	)
 
-	SoundVolume = fmt.Sprintf(
+	Conf.Values.SoundVolume = fmt.Sprintf(
 		"<span color='%s' background='%s' font='%s' size='%s'>🔊</span>",
 		Conf.SimpleVolumePa.Color,
 		Conf.SimpleVolumePa.Background,
@@ -78,7 +68,7 @@ func main() {
 		Conf.SimpleVolumePa.SymbolFontSize,
 	)
 
-	SoundVolume += fmt.Sprintf(
+	Conf.Values.SoundVolume += fmt.Sprintf(
 		"<span color='%s' background='%s' font='%s' size='%s'>:0%%</span>",
 		Conf.SimpleVolumePa.Color,
 		Conf.SimpleVolumePa.Background,
@@ -86,7 +76,7 @@ func main() {
 		Conf.SimpleVolumePa.FontSize,
 	)
 
-	Clock = fmt.Sprintf(
+	Conf.Values.ClockTime = fmt.Sprintf(
 		"<span color='%s' background='%s' font='%s' size='%s'>Thu, 1 Jan 1970   1:00</span>",
 		Conf.Clock.Color,
 		Conf.Clock.Background,
@@ -94,23 +84,19 @@ func main() {
 		Conf.Clock.FontSize,
 	)
 
-	if err != nil {
+	go Conf.Spawner()
-		log.Panicln(err)
+	go Conf.ParseStdin()
-	}
+	go Conf.CleanZombies()
-
+	go Conf.SVPAHandler()
-	go Spawner()
+	go PrintToI3bar(Conf)
-	go ParseStdin()
-	go CleanZombies()
-	go SVPAHandler()
-	go PrintToI3bar()
 
 	if Conf.AppButtons.Enabled {
-		go UpdateI3WinList()
+		go Conf.UpdateI3WinList()
 	}
 
 	// Kick signal handler
-	go sigHandler()
+	go Conf.SigHandler()
-	signal.Notify(sigChan,
+	signal.Notify(Conf.Channels.SigChan,
 		syscall.SIGUSR1,
 		syscall.SIGUSR2,
 		syscall.SIGQUIT,
@@ -119,42 +105,42 @@ func main() {
 
 	// Populate memory stats
 	if Conf.Mem.Enabled {
-		go UpdateMemStats()
+		go Conf.UpdateMemStats()
 	}
 
 	// Populate LA stats
 	if Conf.LA.Enabled {
-		go UpdateLaStats()
+		go Conf.UpdateLaStats()
 	}
 
 	// Populate CPUTemperature
 	if Conf.CPUTemp.Enabled {
-		go UpdateCPUTemperature()
+		go Conf.UpdateCPUTemperature()
 	}
 
 	// Populate Clock
 	if Conf.Clock.Enabled {
-		go UpdateClock()
+		go Conf.UpdateClock()
 	}
 
 	if Conf.Battery.Enabled {
-		go UpdateBatteryInfo()
+		go Conf.UpdateBatteryInfo()
 	}
 
 	if Conf.SimpleVolumePa.Enabled {
-		go UpdateVolumeInfo()
+		go Conf.UpdateVolumeInfo()
 	}
 
 	if Conf.NetIf.Enabled {
-		go UpdateIfStatus()
+		go Conf.UpdateIfStatus()
 	}
 
 	if Conf.Cron.Enabled {
-		go RunCron()
+		go Conf.RunCron()
 	}
 
 	if Conf.Vpn.Enabled {
-		go UpdateVPNStatus()
+		go Conf.UpdateVPNStatus()
 	}
 
 	/*
@@ -175,14 +161,14 @@ func main() {
 	fmt.Println("[ [],")
 
 	for {
-		if <-UpdateReady {
+		if <-Conf.Channels.UpdateReady {
 			// Actually build json struct, marshal it and print result
-			var j []I3BarOutBlock
+			var j []lib.I3BarOutBlock
 
 			// TODO: впилить для первого и последнего батона separator
 			if Conf.AppButtons.Enabled {
 				for num, app := range Conf.Apps {
-					var b I3BarOutBlock
+					var b lib.I3BarOutBlock
 
 					if num == 0 {
 						b.FullText = fmt.Sprintf(
@@ -216,7 +202,7 @@ func main() {
 					b.SeparatorBlockWidth = app.SeparatorBlockWidth
 					b.Name = app.Name
 
-					if HasWindows(app.Class, app.Instance) {
+					if lib.HasWindows(app.Class, app.Instance) {
 						b.Border = app.BorderActive
 					} else {
 						b.Border = app.Border
@@ -232,7 +218,7 @@ func main() {
 			}
 
 			if Conf.CPUTemp.Enabled {
-				var b I3BarOutBlock
+				var b lib.I3BarOutBlock
 
 				b.Color = Conf.CPUTemp.Color
 				b.Background = Conf.CPUTemp.Background
@@ -254,7 +240,7 @@ func main() {
 					Conf.CPUTemp.Background,
 					Conf.CPUTemp.Font,
 					Conf.CPUTemp.FontSize,
-					CPUTemperature,
+					Conf.Values.CPUTemperature,
 				)
 
 				if Conf.CPUTemp.Separator.Right.Enabled {
@@ -275,7 +261,7 @@ func main() {
 			}
 
 			if Conf.Mem.Enabled {
-				var b I3BarOutBlock
+				var b lib.I3BarOutBlock
 
 				b.Color = Conf.Mem.Color
 				b.Background = Conf.Mem.Background
@@ -298,9 +284,9 @@ func main() {
 						Conf.Mem.Background,
 						Conf.Mem.Font,
 						Conf.Mem.FontSize,
-						Memory.Usedpct,
+						Conf.Values.Memory.Usedpct,
-						Memory.Shared,
+						Conf.Values.Memory.Shared,
-						Memory.Swap,
+						Conf.Values.Memory.Swap,
 					)
 				} else {
 					b.FullText += fmt.Sprintf(
@@ -309,8 +295,8 @@ func main() {
 						Conf.Mem.Background,
 						Conf.Mem.Font,
 						Conf.Mem.FontSize,
-						Memory.Usedpct,
+						Conf.Values.Memory.Usedpct,
-						Memory.Shared,
+						Conf.Values.Memory.Shared,
 					)
 				}
 
@@ -332,7 +318,7 @@ func main() {
 			}
 
 			if Conf.LA.Enabled {
-				var b I3BarOutBlock
+				var b lib.I3BarOutBlock
 
 				b.Color = Conf.LA.Color
 				b.Background = Conf.LA.Background
@@ -354,7 +340,7 @@ func main() {
 					Conf.LA.Background,
 					Conf.LA.Font,
 					Conf.LA.FontSize,
-					La,
+					Conf.Values.La,
 				)
 
 				if Conf.LA.Separator.Right.Enabled {
@@ -375,7 +361,7 @@ func main() {
 			}
 
 			if Conf.NetIf.Enabled {
-				var b I3BarOutBlock
+				var b lib.I3BarOutBlock
 
 				b.Color = Conf.NetIf.Color
 				b.Background = Conf.NetIf.Background
@@ -397,7 +383,7 @@ func main() {
 					Conf.NetIf.Background,
 					Conf.NetIf.Font,
 					Conf.NetIf.FontSize,
-					IfStatus,
+					Conf.Values.IfStatus,
 				)
 
 				if Conf.NetIf.Separator.Right.Enabled {
@@ -418,7 +404,7 @@ func main() {
 			}
 
 			if Conf.Vpn.Enabled {
-				var b I3BarOutBlock
+				var b lib.I3BarOutBlock
 
 				b.Color = Conf.Vpn.Color
 				b.Background = Conf.Vpn.Background
@@ -440,7 +426,7 @@ func main() {
 					Conf.Vpn.Background,
 					Conf.Vpn.Font,
 					Conf.Vpn.FontSize,
-					VPNStatus,
+					Conf.Values.VPNStatus,
 				)
 
 				if Conf.Vpn.Separator.Right.Enabled {
@@ -461,7 +447,7 @@ func main() {
 			}
 
 			if Conf.Battery.Enabled {
-				var b I3BarOutBlock
+				var b lib.I3BarOutBlock
 
 				b.Color = Conf.Battery.Color
 				b.Background = Conf.Battery.Background
@@ -477,7 +463,7 @@ func main() {
 					)
 				}
 
-				b.FullText += Batt
+				b.FullText += Conf.Values.BatteryString
 
 				if Conf.Battery.Separator.Right.Enabled {
 					b.FullText += fmt.Sprintf(
@@ -497,7 +483,7 @@ func main() {
 			}
 
 			if Conf.SimpleVolumePa.Enabled {
-				var b I3BarOutBlock
+				var b lib.I3BarOutBlock
 
 				b.Name = "simple-volume-pa"
 				b.Color = Conf.SimpleVolumePa.Color
@@ -515,7 +501,7 @@ func main() {
 				}
 
 				// Pango format is already applied in plugin src.
-				b.FullText += SoundVolume
+				b.FullText += Conf.Values.SoundVolume
 
 				if Conf.SimpleVolumePa.Separator.Right.Enabled {
 					b.FullText += fmt.Sprintf(
@@ -535,7 +521,7 @@ func main() {
 			}
 
 			if Conf.Clock.Enabled {
-				var b I3BarOutBlock
+				var b lib.I3BarOutBlock
 
 				b.Name = `wallclock`
 				b.Color = Conf.Clock.Color
@@ -558,7 +544,7 @@ func main() {
 					Conf.Clock.Background,
 					Conf.Clock.Font,
 					Conf.Clock.FontSize,
-					Clock,
+					Conf.Values.ClockTime,
 				)
 
 				if Conf.Clock.Separator.Right.Enabled {
@@ -578,16 +564,16 @@ func main() {
 				j = append(j, b)
 			}
 
-			if PrintOutput && len(j) > 0 {
+			if Conf.Values.PrintOutput && len(j) > 0 {
-				MsgChan <- j
+				Conf.Channels.MsgChan <- j
 			}
 		}
 	}
 }
 
 // PrintToI3bar prints info to stdout according to ipc docs (https://i3wm.org/docs/i3bar-protocol.html)
-func PrintToI3bar() {
+func PrintToI3bar(c *lib.MyConfig) {
-	for message := range MsgChan {
+	for message := range c.Channels.MsgChan {
 		// we do not need to html-encode output, json.Marshal does this forcefully, so invent our own Marshal
 		buf := new(bytes.Buffer)
 		encoder := json.NewEncoder(buf)

configs/i3status-go-example.json

@@ -0,0 +1 @@
+/home/eleksir/git/i3status-go/cmd/i3status-go/default-config.json

go.mod

@@ -1,11 +1,12 @@
-module github.com/eleksir/i3status-go
+module i3status-go
 
-go 1.21
+go 1.22.6
 
 require (
 	github.com/adrg/xdg v0.5.0
+	github.com/davecgh/go-spew v1.1.1
 	github.com/distatus/battery v0.11.0
-	github.com/go-co-op/gocron/v2 v2.11.0
+	github.com/go-co-op/gocron/v2 v2.12.1
 	github.com/hjson/hjson-go v3.3.0+incompatible
 	github.com/mafik/pulseaudio v0.0.0-20240327130323-384e01075e6e
 	github.com/shirou/gopsutil v3.21.11+incompatible

go.sum

@@ -10,8 +10,8 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/distatus/battery v0.11.0 h1:KJk89gz90Iq/wJtbjjM9yUzBXV+ASV/EG2WOOL7N8lc=
 github.com/distatus/battery v0.11.0/go.mod h1:KmVkE8A8hpIX4T78QRdMktYpEp35QfOL8A8dwZBxq2k=
-github.com/go-co-op/gocron/v2 v2.11.0 h1:IOowNA6SzwdRFnD4/Ol3Kj6G2xKfsoiiGq2Jhhm9bvE=
+github.com/go-co-op/gocron/v2 v2.12.1 h1:dCIIBFbzhWKdgXeEifBjHPzgQ1hoWhjS4289Hjjy1uw=
-github.com/go-co-op/gocron/v2 v2.11.0/go.mod h1:xY7bJxGazKam1cz04EebrlP4S9q4iWdiAylMGP3jY9w=
+github.com/go-co-op/gocron/v2 v2.12.1/go.mod h1:xY7bJxGazKam1cz04EebrlP4S9q4iWdiAylMGP3jY9w=
 github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0=
 github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE=
 github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78=

internal/lib/batteries.go

@@ -1,4 +1,4 @@
-package main
+package lib
 
 import (
 	"fmt"
@@ -8,28 +8,27 @@ import (
 	"github.com/distatus/battery"
 )
 
-// Batt shows battery charge on i3bar.
-var Batt = "<big>⚡</big> ??% •"
-
 // UpdateBatteryInfo updates info about battery charge.
-func UpdateBatteryInfo() {
+func (c *MyConfig) UpdateBatteryInfo() {
 	var (
 		ch     int
 		status string
 		Batts  string
 	)
 
-	for {
+	ticker := time.NewTicker(time.Second * 5)
+
+	for range ticker.C {
 		batteries, err := battery.GetAll()
 
 		if err != nil {
 			Batts = fmt.Sprintf(
 				"<span font='%s' size='%s'>%s</span><span font='%s' size='%s'> no batt</span>",
-				Conf.Battery.SymbolFont,
+				c.Battery.SymbolFont,
-				Conf.Battery.SymbolFontSize,
+				c.Battery.SymbolFontSize,
-				Conf.Battery.Symbol,
+				c.Battery.Symbol,
-				Conf.Battery.Font,
+				c.Battery.Font,
-				Conf.Battery.FontSize,
+				c.Battery.FontSize,
 			)
 		} else {
 			var (
@@ -51,89 +50,89 @@ func UpdateBatteryInfo() {
 
 				// N.B. there can be case when battery is overcharged and shows >100%. It also can indicate that
 				//      calibration data is out of date and battery should be re-calibrated.
-				ch = int(math.Round((b.Full - b.Current) * (100 / b.Full)))
+				ch = int(math.Round((b.Full - (b.Full - b.Current)) * (100 / b.Full)))
 
 				switch {
 				case ch > 85:
-					if Conf.Battery.ChargeColor.Full == "" {
+					if c.Battery.ChargeColor.Full == "" {
 						chStr = fmt.Sprintf(
 							"<span color='%s' background='%s' font='%s' size='%s'>% 3d%%</span>",
-							Conf.Battery.Color,
+							c.Battery.Color,
-							Conf.Battery.Background,
+							c.Battery.Background,
-							Conf.Battery.Font,
+							c.Battery.Font,
-							Conf.Battery.FontSize,
+							c.Battery.FontSize,
 							ch,
 						)
 					} else {
 						chStr = fmt.Sprintf(
 							`<span color='%s' background='%s' font='%s' size='%s'>% 3d%%</span>`,
-							Conf.Battery.ChargeColor.Full,
+							c.Battery.ChargeColor.Full,
-							Conf.Battery.Background,
+							c.Battery.Background,
-							Conf.Battery.Font,
+							c.Battery.Font,
-							Conf.Battery.FontSize,
+							c.Battery.FontSize,
 							ch,
 						)
 					}
 
 				case ch < 85 && ch > 40:
-					if Conf.Battery.ChargeColor.AlmostFull == "" {
+					if c.Battery.ChargeColor.AlmostFull == "" {
 						chStr = fmt.Sprintf(
 							"<span color='%s' background='%s' font='%s' size='%s'>% 3d%%</span>",
-							Conf.Battery.Color,
+							c.Battery.Color,
-							Conf.Battery.Background,
+							c.Battery.Background,
-							Conf.Battery.Font,
+							c.Battery.Font,
-							Conf.Battery.FontSize,
+							c.Battery.FontSize,
 							ch,
 						)
 					} else {
 						chStr = fmt.Sprintf(
 							`<span color='%s' background='%s' font='%s' size='%s'>% 3d%%</span>`,
-							Conf.Battery.ChargeColor.AlmostFull,
+							c.Battery.ChargeColor.AlmostFull,
-							Conf.Battery.Background,
+							c.Battery.Background,
-							Conf.Battery.Font,
+							c.Battery.Font,
-							Conf.Battery.FontSize,
+							c.Battery.FontSize,
 							ch,
 						)
 					}
 
 				case ch <= 40 && ch >= 10:
-					if Conf.Battery.ChargeColor.AlmostEmpty == "" {
+					if c.Battery.ChargeColor.AlmostEmpty == "" {
 						chStr = fmt.Sprintf(
 							"<span color='%s' background='%s' font='%s' size='%s'>% 3d%%</span>",
-							Conf.Battery.Color,
+							c.Battery.Color,
-							Conf.Battery.Background,
+							c.Battery.Background,
-							Conf.Battery.Font,
+							c.Battery.Font,
-							Conf.Battery.FontSize,
+							c.Battery.FontSize,
 							ch,
 						)
 					} else {
 						chStr = fmt.Sprintf(
 							`<span color='%s' background='%s' font='%s' size='%s'>% 3d%%</span>`,
-							Conf.Battery.ChargeColor.AlmostEmpty,
+							c.Battery.ChargeColor.AlmostEmpty,
-							Conf.Battery.Background,
+							c.Battery.Background,
-							Conf.Battery.Font,
+							c.Battery.Font,
-							Conf.Battery.FontSize,
+							c.Battery.FontSize,
 							ch,
 						)
 					}
 
 				case ch < 10:
-					if Conf.Battery.ChargeColor.Empty == "" {
+					if c.Battery.ChargeColor.Empty == "" {
 						chStr = fmt.Sprintf(
 							"<span color='%s' background='%s' font='%s' size='%s'>% 3d%%</span>",
-							Conf.Battery.Color,
+							c.Battery.Color,
-							Conf.Battery.Background,
+							c.Battery.Background,
-							Conf.Battery.Font,
+							c.Battery.Font,
-							Conf.Battery.FontSize,
+							c.Battery.FontSize,
 							ch,
 						)
 					} else {
 						chStr = fmt.Sprintf(
 							`<span color='%s' background='%s' font='%s' size='%s'>% 3d%%</span>`,
-							Conf.Battery.ChargeColor.Empty,
+							c.Battery.ChargeColor.Empty,
-							Conf.Battery.Background,
+							c.Battery.Background,
-							Conf.Battery.Font,
+							c.Battery.Font,
-							Conf.Battery.FontSize,
+							c.Battery.FontSize,
 							ch,
 						)
 					}
@@ -141,21 +140,21 @@ func UpdateBatteryInfo() {
 
 				battsInfo += fmt.Sprintf(
 					"<span color='%s' background='%s' font='%s' size='%s'>%s</span><span color='%s' background='%s' font='%s' size='%s'>B%d </span>%s<span color='%s' background='%s' font='%s' size='%s'> %s</span>",
-					Conf.Battery.Color,
+					c.Battery.Color,
-					Conf.Battery.Background,
+					c.Battery.Background,
-					Conf.Battery.SymbolFont,
+					c.Battery.SymbolFont,
-					Conf.Battery.SymbolFontSize,
+					c.Battery.SymbolFontSize,
-					Conf.Battery.Symbol,
+					c.Battery.Symbol,
-					Conf.Battery.Color,
+					c.Battery.Color,
-					Conf.Battery.Background,
+					c.Battery.Background,
-					Conf.Battery.Font,
+					c.Battery.Font,
-					Conf.Battery.FontSize,
+					c.Battery.FontSize,
 					i,
 					chStr,
-					Conf.Battery.Color,
+					c.Battery.Color,
-					Conf.Battery.Background,
+					c.Battery.Background,
-					Conf.Battery.Font,
+					c.Battery.Font,
-					Conf.Battery.FontSize,
+					c.Battery.FontSize,
 					status,
 				)
 			}
@@ -165,11 +164,9 @@ func UpdateBatteryInfo() {
 			}
 		}
 
-		if Batt == Batts {
+		if c.Values.BatteryString != Batts {
-			Batt = Batts
+			c.Values.BatteryString = Batts
-			UpdateReady <- true
+			c.Channels.UpdateReady <- true
-		}
+		}
-
-		time.Sleep(5 * time.Second)
 	}
 }

internal/lib/clock.go

@@ -1,16 +1,15 @@
-package main
+package lib
 
 import (
 	"fmt"
 	"time"
 )
 
-// Clock shows current date and time on i3bar.
-var Clock = "Thu, 1 Jan 1970   1:00"
-
 // UpdateClock get and updates (on i3bar) info about system clock.
-func UpdateClock() {
+func (c *MyConfig) UpdateClock() {
-	for {
+	ticker := time.NewTicker(time.Second * 1)
+
+	for range ticker.C {
 		currentTime := time.Now()
 		hours, minutes, _ := currentTime.Clock()
 		year, month, day := currentTime.Date()
@@ -20,11 +19,9 @@ func UpdateClock() {
 
 		myclock := fmt.Sprintf("     %s, %d %s %d  % 2d:%02d  ", rdow[dow], day, rmonth[month-1], year, hours, minutes)
 
-		if myclock != Clock {
+		if myclock != c.Values.ClockTime {
-			Clock = myclock
+			c.Values.ClockTime = myclock
-			UpdateReady <- true
+			c.Channels.UpdateReady <- true
-		}
+		}
-
-		time.Sleep(1 * time.Second)
 	}
 }

internal/lib/collection.go

@@ -1,4 +1,4 @@
-package main
+package lib
 
 import (
 	"sync"
@@ -12,7 +12,7 @@ type Collection struct {
 
 // Item just interface for stoing any data.
 type item struct {
-	data interface{}
+	data any
 }
 
 // NewCollection creates new instance of "collection".
@@ -25,7 +25,7 @@ func NewCollection() *Collection {
 }
 
 // Get returns value by given key. Or empty value.
-func (collection *Collection) Get(key interface{}) (interface{}, bool) {
+func (collection *Collection) Get(key any) (any, bool) {
 	obj, exists := collection.items.Load(key)
 
 	if !exists {
@@ -38,15 +38,15 @@ func (collection *Collection) Get(key interface{}) (interface{}, bool) {
 }
 
 // Set saves value to given "collection".
-func (collection *Collection) Set(key interface{}, value interface{}) {
+func (collection *Collection) Set(key any, value any) {
 	collection.items.Store(key, item{
 		data: value,
 	})
 }
 
 // Range apply function f to all keys/values in collection. Retuns immediatly on first error.
-func (collection *Collection) Range(f func(key, value interface{}) bool) {
+func (collection *Collection) Range(f func(key, value any) bool) {
-	fn := func(key, value interface{}) bool {
+	fn := func(key, value any) bool {
 		item := value.(item)
 
 		return f(key, item.data)
@@ -56,7 +56,7 @@ func (collection *Collection) Range(f func(key, value interface{}) bool) {
 }
 
 // Delete deletes key and corresponding value from collection.
-func (collection *Collection) Delete(key interface{}) {
+func (collection *Collection) Delete(key any) {
 	collection.items.Delete(key)
 }
 

internal/lib/config.go

@@ -1,4 +1,4 @@
-package main
+package lib
 
 import (
 	"encoding/json"
@@ -11,8 +11,32 @@ import (
 
 	"github.com/adrg/xdg"
 	"github.com/hjson/hjson-go"
+	p "github.com/mafik/pulseaudio"
 )
 
+// I3BarOutBlock is structure element for I3BarOut, it represents i3bar output json block format.
+type I3BarOutBlock struct {
+	FullText string `json:"full_text"`
+	// ShortText will be shown if not enough room for FullText, threshold width defined in MinWidth
+	ShortText    string `json:"short_text,omitempty"`
+	Color        string `json:"color,omitempty"`
+	Background   string `json:"background,omitempty"`
+	Border       string `json:"border,omitempty"`
+	BorderTop    int    `json:"border_top"`
+	BorderRight  int    `json:"border_right"`
+	BorderBottom int    `json:"border_bottom"`
+	BorderLeft   int    `json:"border_left"`
+	// measured either in pixels or in characters, so either int or string, let's make it string :)
+	MinWidth            string `json:"min_width,omitempty"`
+	Align               string `json:"align,omitempty"`
+	Name                string `json:"name,omitempty"`
+	Instance            string `json:"instance,omitempty"`
+	Urgent              bool   `json:"urgent,omitempty"`
+	Separator           bool   `json:"separator"`
+	SeparatorBlockWidth int    `json:"separator_block_width"`
+	Markup              string `json:"markup,omitempty"`
+}
+
 type Separator struct {
 	Left struct {
 		Enabled    bool   `json:"enabled,omitempty"`
@@ -34,6 +58,26 @@ type Separator struct {
 }
 
 type MyConfig struct {
+	Values struct {
+		PrintOutput    bool
+		CPUTemperature int64
+		BatteryString  string
+		ClockTime      string
+		IfStatus       string
+		VPNStatus      string
+		Memory         Mem
+		La             string
+		PA             *p.Client
+		SoundVolume    string
+	}
+
+	Channels struct {
+		UpdateReady     chan bool
+		MsgChan         chan []I3BarOutBlock
+		SigChan         chan os.Signal
+		SVPAHandlerChan chan ClickEvent
+		RunChan         chan []string
+	}
 
 	// Default text color
 	Color string `json:"color,omitempty"`
@@ -206,15 +250,12 @@ type MyConfig struct {
 	} `json:"apps,omitempty"`
 }
 
-// Conf global variable with application config.
-var Conf MyConfig
-
 // readConf reads and validates config if config does not exist, it puts default config to the same dir where i3 config
 // is located.
-func readConf() (MyConfig, error) {
+func ReadConf(DefaultConfig []byte) (*MyConfig, error) {
 	var (
 		path   string
-		config MyConfig
+		config *MyConfig
 		err    error
 		buf    []byte
 	)
@@ -260,7 +301,7 @@ func readConf() (MyConfig, error) {
 	// We interested in struct as output product: so we parse config to intermediate map then marshal it to json and
 	// then produced json unmarshal to struct. Not very effective way, but in app lifetime it happens only once.
 	var (
-		sampleConfig MyConfig
+		sampleConfig *MyConfig
 		tmp          map[string]interface{}
 	)
 
@@ -320,6 +361,10 @@ func readConf() (MyConfig, error) {
 		sampleConfig.Separator.Left.Font = sampleConfig.Font
 	}
 
+	if sampleConfig.Separator.Left.FontSize == "" {
+		sampleConfig.Separator.Left.FontSize = sampleConfig.FontSize
+	}
+
 	matched, err := regexp.MatchString(
 		`^(xx-small|x-small|small|medium|large|x-large|xx-large|smaller|larger)$`,
 		sampleConfig.Separator.Left.FontSize,
@@ -362,6 +407,10 @@ func readConf() (MyConfig, error) {
 		sampleConfig.Separator.Right.Font = sampleConfig.Font
 	}
 
+	if sampleConfig.Separator.Right.FontSize == "" {
+		sampleConfig.Separator.Right.FontSize = sampleConfig.FontSize
+	}
+
 	matched, err = regexp.MatchString(
 		`^(xx-small|x-small|small|medium|large|x-large|xx-large|smaller|larger)$`,
 		sampleConfig.Separator.Right.FontSize,
@@ -1493,19 +1542,19 @@ func readConf() (MyConfig, error) {
 			}
 
 			if app.Color == "" {
-				app.Color = Conf.Color
+				app.Color = sampleConfig.Color
 			}
 
 			if app.Background == "" {
-				app.Background = Conf.Background
+				app.Background = sampleConfig.Background
 			}
 
 			if app.Border == "" {
-				app.Border = Conf.Color
+				app.Border = sampleConfig.Color
 			}
 
 			if app.BorderActive == "" {
-				app.BorderActive = Conf.Color
+				app.BorderActive = sampleConfig.Color
 			}
 
 			if app.FullText == "" {

internal/lib/cputemp.go

@@ -1,4 +1,4 @@
-package main
+package lib
 
 import (
 	"bufio"
@@ -8,21 +8,20 @@ import (
 	"time"
 )
 
-// CPUTemperature stores average temperature among all cores.
-var CPUTemperature int64
-
 // UpdateCPUTemperature gets and updates average CPU cores temperature.
-func UpdateCPUTemperature() {
+func (c *MyConfig) UpdateCPUTemperature() {
-	n := len(Conf.CPUTemp.File)
+	n := len(c.CPUTemp.File)
 
-	for {
+	ticker := time.NewTicker(time.Second * 3)
+
+	for range ticker.C {
 		var (
 			temperature = make([]int64, n)
 			tSum        int64
 			tAvg        int64
 		)
 
-		for i, filename := range Conf.CPUTemp.File {
+		for i, filename := range c.CPUTemp.File {
 			file, err := os.Open(filename)
 
 			if err != nil {
@@ -70,11 +69,9 @@ func UpdateCPUTemperature() {
 			tAvg = tSum / int64(len(temperature))
 		}
 
-		if CPUTemperature != tAvg {
+		if c.Values.CPUTemperature != tAvg {
-			CPUTemperature = tAvg
+			c.Values.CPUTemperature = tAvg
-			UpdateReady <- true
+			c.Channels.UpdateReady <- true
-		}
+		}
-
-		time.Sleep(3 * time.Second)
 	}
 }

internal/lib/cron.go

@@ -1,4 +1,4 @@
-package main
+package lib
 
 import (
 	"log"
@@ -10,7 +10,7 @@ import (
 var myCron gocron.Scheduler
 
 // RunCron parses config part, related to cron tasks and kicks cron to run.
-func RunCron() {
+func (c MyConfig) RunCron() {
 	var err error
 
 	myCron, err = gocron.NewScheduler()
@@ -21,14 +21,14 @@ func RunCron() {
 		return
 	}
 
-	for _, job := range Conf.Cron.Tasks {
+	for _, job := range c.Cron.Tasks {
 		_, err := myCron.NewJob(
 			gocron.CronJob(job.Time, false),
 			gocron.NewTask(
 				// Сука, просто заспавнить бинарь, ну почему это надо делать через жопу-то?
 				any(
 					func() bool {
-						RunChan <- job.Cmd
+						c.Channels.RunChan <- job.Cmd
 
 						return true
 					},

internal/lib/i3.go

@@ -1,4 +1,4 @@
-package main
+package lib
 
 import (
 	"log"
@@ -18,7 +18,7 @@ type WinList struct {
 var WL WinList
 
 // UpdateI3WinList subsribes to all window-related events and send them to I3EventParser() for more detailed parsing.
-func UpdateI3WinList() {
+func (c *MyConfig) UpdateI3WinList() {
 	// TODO: Здесь получить начальный список окон, управляемых i3wm (через GetTree()) и сложить их атрибутику в переменную WL
 	Tree, err := i3.GetTree()
 
@@ -26,20 +26,20 @@ func UpdateI3WinList() {
 		log.Printf("Unable to get list of windows: %s", err)
 	}
 
-	ExtractProps(Tree.Root)
+	c.ExtractProps(Tree.Root)
 
 	i3wm := i3.Subscribe(i3.WindowEventType)
 
 	for i3wm.Next() {
 		e := i3wm.Event().(*i3.WindowEvent)
-		go I3EventParser(e)
+		go c.I3EventParser(e)
 	}
 
 	log.Fatal(i3wm.Close())
 }
 
 // I3EventParser parses i3wm events and updates WL (aka Windows List).
-func I3EventParser(e *i3.WindowEvent) {
+func (c *MyConfig) I3EventParser(e *i3.WindowEvent) {
 	switch e.Change {
 	case "new":
 		var (
@@ -68,7 +68,7 @@ func I3EventParser(e *i3.WindowEvent) {
 		count++
 		WL.Instance.Set(e.Container.WindowProperties.Instance, count)
 
-		UpdateReady <- true
+		c.Channels.UpdateReady <- true
 
 	case "close":
 		countI, exist := WL.Class.Get(e.Container.WindowProperties.Class)
@@ -99,15 +99,15 @@ func I3EventParser(e *i3.WindowEvent) {
 			}
 		}
 
-		UpdateReady <- true
+		c.Channels.UpdateReady <- true
 	}
 }
 
 // interfaceToUint превращает данный интерфейс в Uint64.
 // Если может, конечно :) .
-func interfaceToUint64(iface interface{}) uint64 {
+func interfaceToUint64(iface any) uint64 {
-	// А теперь мы начинаем дурдом, нам надо превратить ёбанный interface{} в []string
+	// А теперь мы начинаем дурдом, нам надо превратить ёбанный any в []string
-	// Поскольку interface{} может быть чем угодно, перестрахуемся
+	// Поскольку any может быть чем угодно, перестрахуемся
 	if reflect.TypeOf(iface).Kind() == reflect.Uint64 {
 		return reflect.ValueOf(iface).Uint()
 	}
@@ -152,7 +152,7 @@ func HasWindows(className string, instanceName string) bool {
 func FindWindowInstance(regexpStr string) bool {
 	var found = false
 
-	f := func(key interface{}, value interface{}) bool {
+	f := func(key any, value any) bool {
 		keyStr := reflect.ValueOf(key).String()
 
 		re, err := regexp.Compile(regexpStr) //nolint:nolintlint, gocritic, we do not want shit our pants and panic on
@@ -210,18 +210,18 @@ func FindWindowClass(regexpStr string) bool {
 }
 
 // ExtractProps fills WL stricture collections with instance name and class name of given node (x11, that is).
-func ExtractProps(n *i3.Node) {
+func (c *MyConfig) ExtractProps(n *i3.Node) {
 	var e i3.WindowEvent
 	e.Change = "new"
 	e.Container = *n
 
-	I3EventParser(&e)
+	c.I3EventParser(&e)
 
 	for _, node := range n.Nodes {
-		ExtractProps(node)
+		c.ExtractProps(node)
 	}
 
 	for _, node := range n.FloatingNodes {
-		ExtractProps(node)
+		c.ExtractProps(node)
 	}
 }

internal/lib/ifmon.go

@@ -1,4 +1,4 @@
-package main
+package lib
 
 import (
 	"fmt"
@@ -9,15 +9,14 @@ import (
 	"time"
 )
 
-// IfStatus global var conaining cumulative status of all monitored net intefaces.
-var IfStatus string
-
 // UpdateIfStatus updates network interfaces status for i3bar.
-func UpdateIfStatus() {
+func (c *MyConfig) UpdateIfStatus() {
-	for {
+	ticker := time.NewTicker(time.Second * 3)
+
+	for range ticker.C {
 		var statusSum string
 
-		for _, item := range Conf.NetIf.If {
+		for _, item := range c.NetIf.If {
 			var (
 				name = item.Name
 			)
@@ -35,10 +34,10 @@ func UpdateIfStatus() {
 			} else {
 				switch strings.TrimSpace(string(operstate)) {
 				case "up":
-					StatusStr := fmt.Sprintf("<span foreground=\"%s\">⍋</span>", Conf.NetIf.UpColor)
+					StatusStr := fmt.Sprintf("<span foreground=\"%s\">⍋</span>", c.NetIf.UpColor)
 					operstate = []byte(StatusStr)
 				case "down":
-					statusStr := fmt.Sprintf("<span foreground=\"%s\">⍒</span>", Conf.NetIf.DownColor)
+					statusStr := fmt.Sprintf("<span foreground=\"%s\">⍒</span>", c.NetIf.DownColor)
 					operstate = []byte(statusStr)
 				default:
 					operstate = []byte(`?`)
@@ -52,11 +51,9 @@ func UpdateIfStatus() {
 			statusSum += fmt.Sprintf("%s:%s", name, operstate)
 		}
 
-		if IfStatus != statusSum {
+		if c.Values.IfStatus != statusSum {
-			IfStatus = statusSum
+			c.Values.IfStatus = statusSum
-			UpdateReady <- true
+			c.Channels.UpdateReady <- true
-		}
+		}
-
-		time.Sleep(3 * time.Second)
 	}
 }

internal/lib/la.go

@@ -0,0 +1,24 @@
+package lib
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/shirou/gopsutil/load"
+)
+
+// UpdateLaStats вытаскивает показание LA за последнюю минуту.
+func (c *MyConfig) UpdateLaStats() {
+	ticker := time.NewTicker(time.Second * 3)
+
+	for range ticker.C {
+		l, _ := load.Avg()
+
+		lav := fmt.Sprintf("%.2f", l.Load1)
+
+		if c.Values.La != lav {
+			c.Values.La = lav
+			c.Channels.UpdateReady <- true
+		}
+	}
+}

internal/lib/memory.go

@@ -0,0 +1,53 @@
+package lib
+
+import (
+	"log"
+	"time"
+
+	"github.com/shirou/gopsutil/mem"
+)
+
+// Mem struct with mem stats.
+type Mem struct {
+	Usedpct uint64
+	Shared  uint64
+	Swap    uint64
+}
+
+// UpdateMemStats parses mem info stats.
+func (c *MyConfig) UpdateMemStats() {
+	ticker := time.NewTicker(time.Second * 3)
+
+	for range ticker.C {
+		v, err := mem.VirtualMemory()
+
+		if err != nil {
+			log.Printf("Unable to get memory statistics: %s", err)
+
+			continue
+		}
+
+		sw, err := mem.SwapMemory()
+
+		if err != nil {
+			log.Printf("Unable to get swap statistics: %s", err)
+
+			continue
+		}
+
+		if c.Mem.ShowSwap {
+			if c.Values.Memory.Usedpct != uint64(v.UsedPercent) || c.Values.Memory.Shared != v.Shared/1024/1024 || c.Values.Memory.Swap != v.SwapTotal-v.SwapFree {
+				c.Values.Memory.Usedpct = uint64(v.UsedPercent)
+				c.Values.Memory.Shared = v.Shared / 1024 / 1024
+				c.Values.Memory.Swap = sw.Used
+				c.Channels.UpdateReady <- true
+			}
+		} else {
+			if c.Values.Memory.Usedpct != uint64(v.UsedPercent) || c.Values.Memory.Shared != v.Shared/1024/1024 {
+				c.Values.Memory.Usedpct = uint64(v.UsedPercent)
+				c.Values.Memory.Shared = v.Shared / 1024 / 1024
+				c.Channels.UpdateReady <- true
+			}
+		}
+	}
+}

internal/lib/pulseaudio.go

@@ -1,4 +1,4 @@
-package main
+package lib
 
 import (
 	"errors"
@@ -10,30 +10,25 @@ import (
 	p "github.com/mafik/pulseaudio"
 )
 
-var SoundVolume = "🔊:0%"
-var pa *p.Client
-
-var SVPAHandlerChan = make(chan ClickEvent, 256)
-
 // TODO: https://twin.sh/articles/44/add-a-timeout-to-any-function-in-go timeout pulseaudio calls
 
 // UpdateVolumeInfo updates info about current Sound Volume.
-func UpdateVolumeInfo() {
+func (c *MyConfig) UpdateVolumeInfo() {
 	var err error
 
-	pa, err = p.NewClient()
+	c.Values.PA, err = p.NewClient()
 
 	// It can happen if no pulseaudio server running for current user.
 	// If no server running we have to run one.
 	if err != nil {
-		if err := PaReinit(); err != nil {
+		if err := c.PaReinit(); err != nil {
 			log.Print(err)
 
 			return
 		}
 	}
 
-	vol, err := pa.Volume()
+	vol, err := c.Values.PA.Volume()
 
 	if err != nil {
 		log.Printf("Unable get volume from pulseaudio server: %s", err)
@@ -41,29 +36,29 @@ func UpdateVolumeInfo() {
 		return
 	}
 
-	SoundVolume = fmt.Sprintf(
+	c.Values.SoundVolume = fmt.Sprintf(
 		"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-		Conf.SimpleVolumePa.Color,
+		c.SimpleVolumePa.Color,
-		Conf.SimpleVolumePa.Background,
+		c.SimpleVolumePa.Background,
-		Conf.SimpleVolumePa.SymbolFont,
+		c.SimpleVolumePa.SymbolFont,
-		Conf.SimpleVolumePa.SymbolFontSize,
+		c.SimpleVolumePa.SymbolFontSize,
-		Conf.SimpleVolumePa.Symbol,
+		c.SimpleVolumePa.Symbol,
 	)
 
-	SoundVolume += fmt.Sprintf(
+	c.Values.SoundVolume += fmt.Sprintf(
 		"<span color='%s' background='%s' font='%s' size='%s'>:%d%%</span>",
-		Conf.SimpleVolumePa.Color,
+		c.SimpleVolumePa.Color,
-		Conf.SimpleVolumePa.Background,
+		c.SimpleVolumePa.Background,
-		Conf.SimpleVolumePa.Font,
+		c.SimpleVolumePa.Font,
-		Conf.SimpleVolumePa.FontSize,
+		c.SimpleVolumePa.FontSize,
 		int64(vol*100),
 	)
 
-	UpdateReady <- true
+	c.Channels.UpdateReady <- true
 
 	for {
 		// Subscribe to update notification channel, to get info that volume changed.
-		pulseUpdate, err := pa.Updates()
+		pulseUpdate, err := c.Values.PA.Updates()
 
 		if err != nil {
 			log.Printf("Unable to subscribe to pulseaudio updates: %s", err)
@@ -73,7 +68,7 @@ func UpdateVolumeInfo() {
 
 		// Rake update events.
 		for range pulseUpdate {
-			vol, err = pa.Volume()
+			vol, err = c.Values.PA.Volume()
 
 			if err != nil {
 				log.Printf("Unable get volume from pulseaudio server: %s", err)
@@ -81,28 +76,28 @@ func UpdateVolumeInfo() {
 				return
 			}
 
-			SoundVolume = fmt.Sprintf(
+			c.Values.SoundVolume = fmt.Sprintf(
 				"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-				Conf.SimpleVolumePa.Color,
+				c.SimpleVolumePa.Color,
-				Conf.SimpleVolumePa.Background,
+				c.SimpleVolumePa.Background,
-				Conf.SimpleVolumePa.SymbolFont,
+				c.SimpleVolumePa.SymbolFont,
-				Conf.SimpleVolumePa.SymbolFontSize,
+				c.SimpleVolumePa.SymbolFontSize,
-				Conf.SimpleVolumePa.Symbol,
+				c.SimpleVolumePa.Symbol,
 			)
 
-			SoundVolume += fmt.Sprintf(
+			c.Values.SoundVolume += fmt.Sprintf(
 				"<span color='%s' background='%s' font='%s' size='%s'>:%d%%</span>",
-				Conf.SimpleVolumePa.Color,
+				c.SimpleVolumePa.Color,
-				Conf.SimpleVolumePa.Background,
+				c.SimpleVolumePa.Background,
-				Conf.SimpleVolumePa.Font,
+				c.SimpleVolumePa.Font,
-				Conf.SimpleVolumePa.FontSize,
+				c.SimpleVolumePa.FontSize,
 				int64(vol*100),
 			)
 
-			UpdateReady <- true
+			c.Channels.UpdateReady <- true
 		}
 
-		if err := PaReinit(); err != nil {
+		if err := c.PaReinit(); err != nil {
 			log.Print(err)
 
 			return
@@ -110,11 +105,11 @@ func UpdateVolumeInfo() {
 	}
 
 	// This code is unreachable :(
-	pa.Close() //nolint:govet
+	c.Values.PA.Close() //nolint:govet
 }
 
 // PaReinit re-inits pulseaudio and connection to it.
-func PaReinit() error {
+func (c *MyConfig) PaReinit() error {
 	var err error
 
 	// If we out of updates, seems someone killed pulseaudio server. Restart it.
@@ -157,7 +152,7 @@ func PaReinit() error {
 	// This setting defines if pulseaudio will be run in manner that allows it to exit is other login detected (how
 	// they guess it - I do not know). In general case we do not want to allow pa to exit and leave our session without
 	// audio.
-	if Conf.SimpleVolumePa.DontExitOnLogin {
+	if c.SimpleVolumePa.DontExitOnLogin {
 		// Do not exit on any kind of login/logout events.
 		cmd = exec.Command("pulseaudio", "--exit-idle-time=-1", "--start")
 	} else {
@@ -169,7 +164,7 @@ func PaReinit() error {
 		return fmt.Errorf("unable to initialize pulseaudio server instance: %w", err)
 	}
 
-	pa, err = p.NewClient()
+	c.Values.PA, err = p.NewClient()
 
 	if err != nil {
 		return fmt.Errorf("unable to make client connection to pulseaudio: %w", err)
@@ -178,21 +173,21 @@ func PaReinit() error {
 	return err
 }
 
-func SVPAHandler() {
+func (c *MyConfig) SVPAHandler() {
-	for e := range SVPAHandlerChan {
+	for e := range c.Channels.SVPAHandlerChan {
 		if e.Button == 3 {
-			RunChan <- Conf.SimpleVolumePa.RightClickCmd
+			c.Channels.RunChan <- c.SimpleVolumePa.RightClickCmd
 
 			continue
 		}
 
-		vol, err := pa.Volume()
+		vol, err := c.Values.PA.Volume()
 
 		if err != nil {
-			if err := PaReinit(); err != nil {
+			if err := c.PaReinit(); err != nil {
 				log.Printf("Unable to get pulseaudio volume: %s", err)
 			} else {
-				vol, err = pa.Volume()
+				vol, err = c.Values.PA.Volume()
 
 				if err != nil {
 					log.Printf("Unable to get volume pulseaudio server behaves weirdly: %s", err)
@@ -201,25 +196,25 @@ func SVPAHandler() {
 		}
 
 		switch e.Button {
-		case Conf.SimpleVolumePa.WheelUp:
+		case c.SimpleVolumePa.WheelUp:
-			vol += float32(Conf.SimpleVolumePa.Step) / 100
+			vol += float32(c.SimpleVolumePa.Step) / 100
 
-			if vol > (float32(Conf.SimpleVolumePa.MaxVolumeLimit) / 100) {
+			if vol > (float32(c.SimpleVolumePa.MaxVolumeLimit) / 100) {
-				vol = float32(Conf.SimpleVolumePa.MaxVolumeLimit) / 100
+				vol = float32(c.SimpleVolumePa.MaxVolumeLimit) / 100
 			}
 
-			if err := pa.SetVolume(vol); err != nil {
+			if err := c.Values.PA.SetVolume(vol); err != nil {
 				log.Printf("Unable to set pulseaudio volume: %s", err)
 			}
 
-		case Conf.SimpleVolumePa.WheelDown:
+		case c.SimpleVolumePa.WheelDown:
-			vol -= float32(Conf.SimpleVolumePa.Step) / 100
+			vol -= float32(c.SimpleVolumePa.Step) / 100
 
 			if vol < 0 {
 				vol = 0
 			}
 
-			if err := pa.SetVolume(vol); err != nil {
+			if err := c.Values.PA.SetVolume(vol); err != nil {
 				log.Printf("Unable to set pulseaudio volume: %s", err)
 			}
 		}

internal/lib/signal.go

@@ -1,4 +1,4 @@
-package main
+package lib
 
 import (
 	"log"
@@ -7,23 +7,22 @@ import (
 )
 
 var PrintOutput = true
-var sigChan = make(chan os.Signal, 1)
 
-// sigHandler OS signal handler.
+// SigHandler OS signal handler.
-func sigHandler() {
+func (c *MyConfig) SigHandler() {
-	for s := range sigChan {
+	for s := range c.Channels.SigChan {
 		switch s {
 		case syscall.SIGUSR1:
 			log.Print("Got SIGUSR1, stopping output")
 
-			PrintOutput = false
+			c.Values.PrintOutput = false
 
 		case syscall.SIGUSR2:
 			log.Print("Got SIGUSR2, resuming output")
 
-			PrintOutput = true
+			c.Values.PrintOutput = true
 
-			UpdateReady <- true
+			c.Channels.UpdateReady <- true
 
 		case syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGINT:
 			os.Exit(0)

internal/lib/spawn.go

@@ -1,4 +1,4 @@
-package main
+package lib
 
 import (
 	"log"
@@ -8,12 +8,9 @@ import (
 	"time"
 )
 
-// RunChan to this channel we send command and its argv to execute as separate process.
-var RunChan = make(chan []string, 128)
-
 // Spawner forks and execs given program, and also detaches form its control tty.
-func Spawner() {
+func (c *MyConfig) Spawner() {
-	for prg := range RunChan {
+	for prg := range c.Channels.RunChan {
 		devnullR, _ := os.Open(os.DevNull)
 		devnullW, _ := os.OpenFile(os.DevNull, os.O_WRONLY|os.O_APPEND, 0644)
 
@@ -48,7 +45,7 @@ func Spawner() {
 }
 
 // CleanZombies reaps processes spawned by Spawner() and already exited.
-func CleanZombies() {
+func (c *MyConfig) CleanZombies() {
 	r := syscall.Rusage{}
 
 	for {

internal/lib/stdin.go

@@ -1,4 +1,4 @@
-package main
+package lib
 
 import (
 	"bufio"
@@ -26,7 +26,7 @@ type ClickEvent struct {
 
 // ParseStdin tries to parse text that i3bar prints to our stdin. Currently - it is mouse click events on different
 // area names of i3bar.
-func ParseStdin() {
+func (c *MyConfig) ParseStdin() {
 	reader := bufio.NewReader(os.Stdin)
 
 	// De-facto it is jsonl, except first line is garbage. Also, first symbol in each strint garbage too.
@@ -84,35 +84,35 @@ func ParseStdin() {
 
 		// Clock clicks parse.
 		if e.Name == "wallclock" {
-			if Conf.Clock.LeftClick.Enabled && e.Button == 1 {
+			if c.Clock.LeftClick.Enabled && e.Button == 1 {
-				RunChan <- Conf.Clock.LeftClick.Cmd
+				c.Channels.RunChan <- c.Clock.LeftClick.Cmd
-			} else if Conf.Clock.RightClick.Enabled && e.Button == 3 {
+			} else if c.Clock.RightClick.Enabled && e.Button == 3 {
-				RunChan <- Conf.Clock.RightClick.Cmd
+				c.Channels.RunChan <- c.Clock.RightClick.Cmd
 			}
 
 			continue
 		}
 
 		if e.Name == "simple-volume-pa" {
-			if Conf.SimpleVolumePa.Enabled {
+			if c.SimpleVolumePa.Enabled {
-				SVPAHandlerChan <- e
+				c.Channels.SVPAHandlerChan <- e
 			}
 
 			continue
 		}
 
-		if !Conf.AppButtons.Enabled {
+		if !c.AppButtons.Enabled {
 			continue
 		}
 
-		for _, app := range Conf.Apps {
+		for _, app := range c.Apps {
 			switch {
 			case app.Name != "" && app.Instance != "":
 				if app.Name == e.Name && app.Instance == e.Instance {
 					prg := append([]string{}, app.Cmd)
 					prg = append(prg, app.Args...)
 
-					RunChan <- prg
+					c.Channels.RunChan <- prg
 
 					break
 				}
@@ -120,13 +120,13 @@ func ParseStdin() {
 				prg := append([]string{}, app.Cmd)
 				prg = append(prg, app.Args...)
 
-				RunChan <- prg
+				c.Channels.RunChan <- prg
 
 			case app.Instance != "" && e.Instance == app.Instance:
 				prg := append([]string{}, app.Cmd)
 				prg = append(prg, app.Args...)
 
-				RunChan <- prg
+				c.Channels.RunChan <- prg
 			}
 		}
 	}

internal/lib/vpn.go

@@ -1,4 +1,4 @@
-package main
+package lib
 
 import (
 	"fmt"
@@ -7,44 +7,43 @@ import (
 	"time"
 )
 
-// VPNStatus status string for i3bar, related to vpn.
-var VPNStatus string
-
 // UpdateVPNStatus periodically update status of openvpn daemon.
-func UpdateVPNStatus() {
+func (c *MyConfig) UpdateVPNStatus() {
 	var (
 		vpnCStatus string
 		tcpCheck   string
 		vpnCheck   string
 	)
 
-	for {
+	ticker := time.NewTicker(time.Second * 3)
-		if VPNFileCheck() {
+
-			if Conf.Vpn.UpColor == "" {
+	for range ticker.C {
+		if c.VPNFileCheck() {
+			if c.Vpn.UpColor == "" {
 				vpnCheck = `⍋`
 			} else {
-				vpnCheck = fmt.Sprintf(`<span foreground="%s">⍋</span>`, Conf.Vpn.UpColor)
+				vpnCheck = fmt.Sprintf(`<span foreground="%s">⍋</span>`, c.Vpn.UpColor)
 			}
 		} else {
-			if Conf.Vpn.DownColor == "" {
+			if c.Vpn.DownColor == "" {
 				vpnCheck = `⍒`
 			} else {
-				vpnCheck = fmt.Sprintf(`<span foreground="%s">⍒</span>`, Conf.Vpn.DownColor)
+				vpnCheck = fmt.Sprintf(`<span foreground="%s">⍒</span>`, c.Vpn.DownColor)
 			}
 		}
 
-		if Conf.Vpn.TCPCheck.Enabled {
+		if c.Vpn.TCPCheck.Enabled {
-			if VPNTCPCheck() {
+			if c.VPNTCPCheck() {
-				if Conf.Vpn.UpColor == "" {
+				if c.Vpn.UpColor == "" {
 					tcpCheck = `✔`
 				} else {
-					tcpCheck = fmt.Sprintf(`<span foreground="%s">✔</span>`, Conf.Vpn.UpColor)
+					tcpCheck = fmt.Sprintf(`<span foreground="%s">✔</span>`, c.Vpn.UpColor)
 				}
 			} else {
-				if Conf.Vpn.DownColor == "" {
+				if c.Vpn.DownColor == "" {
 					tcpCheck = `✘`
 				} else {
-					tcpCheck = fmt.Sprintf(`<span foreground="%s">✘</span>`, Conf.Vpn.DownColor)
+					tcpCheck = fmt.Sprintf(`<span foreground="%s">✘</span>`, c.Vpn.DownColor)
 				}
 			}
 
@@ -53,21 +52,19 @@ func UpdateVPNStatus() {
 			vpnCStatus = fmt.Sprintf("VPN:%s", vpnCheck)
 		}
 
-		if VPNStatus != vpnCStatus {
+		if c.Values.VPNStatus != vpnCStatus {
-			VPNStatus = vpnCStatus
+			c.Values.VPNStatus = vpnCStatus
-			UpdateReady <- true
+			c.Channels.UpdateReady <- true
 		}
-
-		time.Sleep(3 * time.Second)
 	}
 }
 
 // VPNTCPCheck intended to check arbitrary service inside vpn segment, to indicate that openvpn sevice not stoned.
-func VPNTCPCheck() bool {
+func (c *MyConfig) VPNTCPCheck() bool {
 	conn, err := net.DialTimeout(
 		"tcp",
-		fmt.Sprintf("%s:%d", Conf.Vpn.TCPCheck.Host, Conf.Vpn.TCPCheck.Port),
+		fmt.Sprintf("%s:%d", c.Vpn.TCPCheck.Host, c.Vpn.TCPCheck.Port),
-		time.Second*time.Duration(Conf.Vpn.TCPCheck.Timeout),
+		time.Second*time.Duration(c.Vpn.TCPCheck.Timeout),
 	)
 
 	if err == nil {
@@ -79,17 +76,17 @@ func VPNTCPCheck() bool {
 }
 
 // VPNFileCheck checks modification time of openvpn-status file.
-func VPNFileCheck() bool {
+func (c *MyConfig) VPNFileCheck() bool {
 	var (
 		fi  os.FileInfo
 		err error
 	)
 
-	if fi, err = os.Stat(Conf.Vpn.StatusFile); err != nil {
+	if fi, err = os.Stat(c.Vpn.StatusFile); err != nil {
 		return false
 	}
 
-	if time.Since(fi.ModTime()).Seconds() > float64(Conf.Vpn.MtimeThreshold) {
+	if time.Since(fi.ModTime()).Seconds() > float64(c.Vpn.MtimeThreshold) {
 		return false
 	}
 

la.go

@@ -1,27 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"time"
-
-	"github.com/shirou/gopsutil/load"
-)
-
-// La переменная, хранящая значение LA за последнюю минуту.
-var La = "-1"
-
-// UpdateLaStats вытаскивает показание LA за последнюю минуту.
-func UpdateLaStats() {
-	for {
-		l, _ := load.Avg()
-
-		lav := fmt.Sprintf("%.2f", l.Load1)
-
-		if La != lav {
-			La = lav
-			UpdateReady <- true
-		}
-
-		time.Sleep(3 * time.Second)
-	}
-}

memory.go

@@ -1,59 +0,0 @@
-package main
-
-import (
-	"log"
-	"time"
-
-	"github.com/shirou/gopsutil/mem"
-)
-
-// Mem struct with mem stats.
-type Mem struct {
-	Usedpct uint64
-	Shared  uint64
-	Swap    uint64
-}
-
-// Memory stores string with mem stats for i3bar.
-var Memory Mem
-
-// UpdateMemStats parses mem info stats.
-func UpdateMemStats() {
-	for {
-		v, err := mem.VirtualMemory()
-
-		if err != nil {
-			log.Printf("Unable to get memory statistics: %s", err)
-			time.Sleep(1 * time.Second)
-
-			continue
-		}
-
-		sw, err := mem.SwapMemory()
-
-		if err != nil {
-			log.Printf("Unable to get swap statistics: %s", err)
-			time.Sleep(1 * time.Second)
-
-			continue
-		}
-
-		if Conf.Mem.ShowSwap {
-			if Memory.Usedpct != uint64(v.UsedPercent) || Memory.Shared != v.Shared/1024/1024 ||
-				Memory.Swap != v.SwapTotal-v.SwapFree {
-				Memory.Usedpct = uint64(v.UsedPercent)
-				Memory.Shared = v.Shared / 1024 / 1024
-				Memory.Swap = sw.Used
-				UpdateReady <- true
-			}
-		} else {
-			if Memory.Usedpct != uint64(v.UsedPercent) || Memory.Shared != v.Shared/1024/1024 {
-				Memory.Usedpct = uint64(v.UsedPercent)
-				Memory.Shared = v.Shared / 1024 / 1024
-				UpdateReady <- true
-			}
-		}
-
-		time.Sleep(3 * time.Second)
-	}
-}

vendor/github.com/davecgh/go-spew/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2012-2016 Dave Collins <dave@davec.name>
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

vendor/github.com/davecgh/go-spew/spew/bypass.go

@@ -0,0 +1,145 @@
+// Copyright (c) 2015-2016 Dave Collins <dave@davec.name>
+//
+// Permission to use, copy, modify, and distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+// NOTE: Due to the following build constraints, this file will only be compiled
+// when the code is not running on Google App Engine, compiled by GopherJS, and
+// "-tags safe" is not added to the go build command line.  The "disableunsafe"
+// tag is deprecated and thus should not be used.
+// Go versions prior to 1.4 are disabled because they use a different layout
+// for interfaces which make the implementation of unsafeReflectValue more complex.
+// +build !js,!appengine,!safe,!disableunsafe,go1.4
+
+package spew
+
+import (
+	"reflect"
+	"unsafe"
+)
+
+const (
+	// UnsafeDisabled is a build-time constant which specifies whether or
+	// not access to the unsafe package is available.
+	UnsafeDisabled = false
+
+	// ptrSize is the size of a pointer on the current arch.
+	ptrSize = unsafe.Sizeof((*byte)(nil))
+)
+
+type flag uintptr
+
+var (
+	// flagRO indicates whether the value field of a reflect.Value
+	// is read-only.
+	flagRO flag
+
+	// flagAddr indicates whether the address of the reflect.Value's
+	// value may be taken.
+	flagAddr flag
+)
+
+// flagKindMask holds the bits that make up the kind
+// part of the flags field. In all the supported versions,
+// it is in the lower 5 bits.
+const flagKindMask = flag(0x1f)
+
+// Different versions of Go have used different
+// bit layouts for the flags type. This table
+// records the known combinations.
+var okFlags = []struct {
+	ro, addr flag
+}{{
+	// From Go 1.4 to 1.5
+	ro:   1 << 5,
+	addr: 1 << 7,
+}, {
+	// Up to Go tip.
+	ro:   1<<5 | 1<<6,
+	addr: 1 << 8,
+}}
+
+var flagValOffset = func() uintptr {
+	field, ok := reflect.TypeOf(reflect.Value{}).FieldByName("flag")
+	if !ok {
+		panic("reflect.Value has no flag field")
+	}
+	return field.Offset
+}()
+
+// flagField returns a pointer to the flag field of a reflect.Value.
+func flagField(v *reflect.Value) *flag {
+	return (*flag)(unsafe.Pointer(uintptr(unsafe.Pointer(v)) + flagValOffset))
+}
+
+// unsafeReflectValue converts the passed reflect.Value into a one that bypasses
+// the typical safety restrictions preventing access to unaddressable and
+// unexported data.  It works by digging the raw pointer to the underlying
+// value out of the protected value and generating a new unprotected (unsafe)
+// reflect.Value to it.
+//
+// This allows us to check for implementations of the Stringer and error
+// interfaces to be used for pretty printing ordinarily unaddressable and
+// inaccessible values such as unexported struct fields.
+func unsafeReflectValue(v reflect.Value) reflect.Value {
+	if !v.IsValid() || (v.CanInterface() && v.CanAddr()) {
+		return v
+	}
+	flagFieldPtr := flagField(&v)
+	*flagFieldPtr &^= flagRO
+	*flagFieldPtr |= flagAddr
+	return v
+}
+
+// Sanity checks against future reflect package changes
+// to the type or semantics of the Value.flag field.
+func init() {
+	field, ok := reflect.TypeOf(reflect.Value{}).FieldByName("flag")
+	if !ok {
+		panic("reflect.Value has no flag field")
+	}
+	if field.Type.Kind() != reflect.TypeOf(flag(0)).Kind() {
+		panic("reflect.Value flag field has changed kind")
+	}
+	type t0 int
+	var t struct {
+		A t0
+		// t0 will have flagEmbedRO set.
+		t0
+		// a will have flagStickyRO set
+		a t0
+	}
+	vA := reflect.ValueOf(t).FieldByName("A")
+	va := reflect.ValueOf(t).FieldByName("a")
+	vt0 := reflect.ValueOf(t).FieldByName("t0")
+
+	// Infer flagRO from the difference between the flags
+	// for the (otherwise identical) fields in t.
+	flagPublic := *flagField(&vA)
+	flagWithRO := *flagField(&va) | *flagField(&vt0)
+	flagRO = flagPublic ^ flagWithRO
+
+	// Infer flagAddr from the difference between a value
+	// taken from a pointer and not.
+	vPtrA := reflect.ValueOf(&t).Elem().FieldByName("A")
+	flagNoPtr := *flagField(&vA)
+	flagPtr := *flagField(&vPtrA)
+	flagAddr = flagNoPtr ^ flagPtr
+
+	// Check that the inferred flags tally with one of the known versions.
+	for _, f := range okFlags {
+		if flagRO == f.ro && flagAddr == f.addr {
+			return
+		}
+	}
+	panic("reflect.Value read-only flag has changed semantics")
+}

vendor/github.com/davecgh/go-spew/spew/bypasssafe.go

@@ -0,0 +1,38 @@
+// Copyright (c) 2015-2016 Dave Collins <dave@davec.name>
+//
+// Permission to use, copy, modify, and distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+// NOTE: Due to the following build constraints, this file will only be compiled
+// when the code is running on Google App Engine, compiled by GopherJS, or
+// "-tags safe" is added to the go build command line.  The "disableunsafe"
+// tag is deprecated and thus should not be used.
+// +build js appengine safe disableunsafe !go1.4
+
+package spew
+
+import "reflect"
+
+const (
+	// UnsafeDisabled is a build-time constant which specifies whether or
+	// not access to the unsafe package is available.
+	UnsafeDisabled = true
+)
+
+// unsafeReflectValue typically converts the passed reflect.Value into a one
+// that bypasses the typical safety restrictions preventing access to
+// unaddressable and unexported data.  However, doing this relies on access to
+// the unsafe package.  This is a stub version which simply returns the passed
+// reflect.Value when the unsafe package is not available.
+func unsafeReflectValue(v reflect.Value) reflect.Value {
+	return v
+}

vendor/github.com/davecgh/go-spew/spew/common.go

@@ -0,0 +1,341 @@
+/*
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+package spew
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"reflect"
+	"sort"
+	"strconv"
+)
+
+// Some constants in the form of bytes to avoid string overhead.  This mirrors
+// the technique used in the fmt package.
+var (
+	panicBytes            = []byte("(PANIC=")
+	plusBytes             = []byte("+")
+	iBytes                = []byte("i")
+	trueBytes             = []byte("true")
+	falseBytes            = []byte("false")
+	interfaceBytes        = []byte("(interface {})")
+	commaNewlineBytes     = []byte(",\n")
+	newlineBytes          = []byte("\n")
+	openBraceBytes        = []byte("{")
+	openBraceNewlineBytes = []byte("{\n")
+	closeBraceBytes       = []byte("}")
+	asteriskBytes         = []byte("*")
+	colonBytes            = []byte(":")
+	colonSpaceBytes       = []byte(": ")
+	openParenBytes        = []byte("(")
+	closeParenBytes       = []byte(")")
+	spaceBytes            = []byte(" ")
+	pointerChainBytes     = []byte("->")
+	nilAngleBytes         = []byte("<nil>")
+	maxNewlineBytes       = []byte("<max depth reached>\n")
+	maxShortBytes         = []byte("<max>")
+	circularBytes         = []byte("<already shown>")
+	circularShortBytes    = []byte("<shown>")
+	invalidAngleBytes     = []byte("<invalid>")
+	openBracketBytes      = []byte("[")
+	closeBracketBytes     = []byte("]")
+	percentBytes          = []byte("%")
+	precisionBytes        = []byte(".")
+	openAngleBytes        = []byte("<")
+	closeAngleBytes       = []byte(">")
+	openMapBytes          = []byte("map[")
+	closeMapBytes         = []byte("]")
+	lenEqualsBytes        = []byte("len=")
+	capEqualsBytes        = []byte("cap=")
+)
+
+// hexDigits is used to map a decimal value to a hex digit.
+var hexDigits = "0123456789abcdef"
+
+// catchPanic handles any panics that might occur during the handleMethods
+// calls.
+func catchPanic(w io.Writer, v reflect.Value) {
+	if err := recover(); err != nil {
+		w.Write(panicBytes)
+		fmt.Fprintf(w, "%v", err)
+		w.Write(closeParenBytes)
+	}
+}
+
+// handleMethods attempts to call the Error and String methods on the underlying
+// type the passed reflect.Value represents and outputes the result to Writer w.
+//
+// It handles panics in any called methods by catching and displaying the error
+// as the formatted value.
+func handleMethods(cs *ConfigState, w io.Writer, v reflect.Value) (handled bool) {
+	// We need an interface to check if the type implements the error or
+	// Stringer interface.  However, the reflect package won't give us an
+	// interface on certain things like unexported struct fields in order
+	// to enforce visibility rules.  We use unsafe, when it's available,
+	// to bypass these restrictions since this package does not mutate the
+	// values.
+	if !v.CanInterface() {
+		if UnsafeDisabled {
+			return false
+		}
+
+		v = unsafeReflectValue(v)
+	}
+
+	// Choose whether or not to do error and Stringer interface lookups against
+	// the base type or a pointer to the base type depending on settings.
+	// Technically calling one of these methods with a pointer receiver can
+	// mutate the value, however, types which choose to satisify an error or
+	// Stringer interface with a pointer receiver should not be mutating their
+	// state inside these interface methods.
+	if !cs.DisablePointerMethods && !UnsafeDisabled && !v.CanAddr() {
+		v = unsafeReflectValue(v)
+	}
+	if v.CanAddr() {
+		v = v.Addr()
+	}
+
+	// Is it an error or Stringer?
+	switch iface := v.Interface().(type) {
+	case error:
+		defer catchPanic(w, v)
+		if cs.ContinueOnMethod {
+			w.Write(openParenBytes)
+			w.Write([]byte(iface.Error()))
+			w.Write(closeParenBytes)
+			w.Write(spaceBytes)
+			return false
+		}
+
+		w.Write([]byte(iface.Error()))
+		return true
+
+	case fmt.Stringer:
+		defer catchPanic(w, v)
+		if cs.ContinueOnMethod {
+			w.Write(openParenBytes)
+			w.Write([]byte(iface.String()))
+			w.Write(closeParenBytes)
+			w.Write(spaceBytes)
+			return false
+		}
+		w.Write([]byte(iface.String()))
+		return true
+	}
+	return false
+}
+
+// printBool outputs a boolean value as true or false to Writer w.
+func printBool(w io.Writer, val bool) {
+	if val {
+		w.Write(trueBytes)
+	} else {
+		w.Write(falseBytes)
+	}
+}
+
+// printInt outputs a signed integer value to Writer w.
+func printInt(w io.Writer, val int64, base int) {
+	w.Write([]byte(strconv.FormatInt(val, base)))
+}
+
+// printUint outputs an unsigned integer value to Writer w.
+func printUint(w io.Writer, val uint64, base int) {
+	w.Write([]byte(strconv.FormatUint(val, base)))
+}
+
+// printFloat outputs a floating point value using the specified precision,
+// which is expected to be 32 or 64bit, to Writer w.
+func printFloat(w io.Writer, val float64, precision int) {
+	w.Write([]byte(strconv.FormatFloat(val, 'g', -1, precision)))
+}
+
+// printComplex outputs a complex value using the specified float precision
+// for the real and imaginary parts to Writer w.
+func printComplex(w io.Writer, c complex128, floatPrecision int) {
+	r := real(c)
+	w.Write(openParenBytes)
+	w.Write([]byte(strconv.FormatFloat(r, 'g', -1, floatPrecision)))
+	i := imag(c)
+	if i >= 0 {
+		w.Write(plusBytes)
+	}
+	w.Write([]byte(strconv.FormatFloat(i, 'g', -1, floatPrecision)))
+	w.Write(iBytes)
+	w.Write(closeParenBytes)
+}
+
+// printHexPtr outputs a uintptr formatted as hexadecimal with a leading '0x'
+// prefix to Writer w.
+func printHexPtr(w io.Writer, p uintptr) {
+	// Null pointer.
+	num := uint64(p)
+	if num == 0 {
+		w.Write(nilAngleBytes)
+		return
+	}
+
+	// Max uint64 is 16 bytes in hex + 2 bytes for '0x' prefix
+	buf := make([]byte, 18)
+
+	// It's simpler to construct the hex string right to left.
+	base := uint64(16)
+	i := len(buf) - 1
+	for num >= base {
+		buf[i] = hexDigits[num%base]
+		num /= base
+		i--
+	}
+	buf[i] = hexDigits[num]
+
+	// Add '0x' prefix.
+	i--
+	buf[i] = 'x'
+	i--
+	buf[i] = '0'
+
+	// Strip unused leading bytes.
+	buf = buf[i:]
+	w.Write(buf)
+}
+
+// valuesSorter implements sort.Interface to allow a slice of reflect.Value
+// elements to be sorted.
+type valuesSorter struct {
+	values  []reflect.Value
+	strings []string // either nil or same len and values
+	cs      *ConfigState
+}
+
+// newValuesSorter initializes a valuesSorter instance, which holds a set of
+// surrogate keys on which the data should be sorted.  It uses flags in
+// ConfigState to decide if and how to populate those surrogate keys.
+func newValuesSorter(values []reflect.Value, cs *ConfigState) sort.Interface {
+	vs := &valuesSorter{values: values, cs: cs}
+	if canSortSimply(vs.values[0].Kind()) {
+		return vs
+	}
+	if !cs.DisableMethods {
+		vs.strings = make([]string, len(values))
+		for i := range vs.values {
+			b := bytes.Buffer{}
+			if !handleMethods(cs, &b, vs.values[i]) {
+				vs.strings = nil
+				break
+			}
+			vs.strings[i] = b.String()
+		}
+	}
+	if vs.strings == nil && cs.SpewKeys {
+		vs.strings = make([]string, len(values))
+		for i := range vs.values {
+			vs.strings[i] = Sprintf("%#v", vs.values[i].Interface())
+		}
+	}
+	return vs
+}
+
+// canSortSimply tests whether a reflect.Kind is a primitive that can be sorted
+// directly, or whether it should be considered for sorting by surrogate keys
+// (if the ConfigState allows it).
+func canSortSimply(kind reflect.Kind) bool {
+	// This switch parallels valueSortLess, except for the default case.
+	switch kind {
+	case reflect.Bool:
+		return true
+	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
+		return true
+	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
+		return true
+	case reflect.Float32, reflect.Float64:
+		return true
+	case reflect.String:
+		return true
+	case reflect.Uintptr:
+		return true
+	case reflect.Array:
+		return true
+	}
+	return false
+}
+
+// Len returns the number of values in the slice.  It is part of the
+// sort.Interface implementation.
+func (s *valuesSorter) Len() int {
+	return len(s.values)
+}
+
+// Swap swaps the values at the passed indices.  It is part of the
+// sort.Interface implementation.
+func (s *valuesSorter) Swap(i, j int) {
+	s.values[i], s.values[j] = s.values[j], s.values[i]
+	if s.strings != nil {
+		s.strings[i], s.strings[j] = s.strings[j], s.strings[i]
+	}
+}
+
+// valueSortLess returns whether the first value should sort before the second
+// value.  It is used by valueSorter.Less as part of the sort.Interface
+// implementation.
+func valueSortLess(a, b reflect.Value) bool {
+	switch a.Kind() {
+	case reflect.Bool:
+		return !a.Bool() && b.Bool()
+	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
+		return a.Int() < b.Int()
+	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
+		return a.Uint() < b.Uint()
+	case reflect.Float32, reflect.Float64:
+		return a.Float() < b.Float()
+	case reflect.String:
+		return a.String() < b.String()
+	case reflect.Uintptr:
+		return a.Uint() < b.Uint()
+	case reflect.Array:
+		// Compare the contents of both arrays.
+		l := a.Len()
+		for i := 0; i < l; i++ {
+			av := a.Index(i)
+			bv := b.Index(i)
+			if av.Interface() == bv.Interface() {
+				continue
+			}
+			return valueSortLess(av, bv)
+		}
+	}
+	return a.String() < b.String()
+}
+
+// Less returns whether the value at index i should sort before the
+// value at index j.  It is part of the sort.Interface implementation.
+func (s *valuesSorter) Less(i, j int) bool {
+	if s.strings == nil {
+		return valueSortLess(s.values[i], s.values[j])
+	}
+	return s.strings[i] < s.strings[j]
+}
+
+// sortValues is a sort function that handles both native types and any type that
+// can be converted to error or Stringer.  Other inputs are sorted according to
+// their Value.String() value to ensure display stability.
+func sortValues(values []reflect.Value, cs *ConfigState) {
+	if len(values) == 0 {
+		return
+	}
+	sort.Sort(newValuesSorter(values, cs))
+}

vendor/github.com/davecgh/go-spew/spew/config.go

@@ -0,0 +1,306 @@
+/*
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+package spew
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"os"
+)
+
+// ConfigState houses the configuration options used by spew to format and
+// display values.  There is a global instance, Config, that is used to control
+// all top-level Formatter and Dump functionality.  Each ConfigState instance
+// provides methods equivalent to the top-level functions.
+//
+// The zero value for ConfigState provides no indentation.  You would typically
+// want to set it to a space or a tab.
+//
+// Alternatively, you can use NewDefaultConfig to get a ConfigState instance
+// with default settings.  See the documentation of NewDefaultConfig for default
+// values.
+type ConfigState struct {
+	// Indent specifies the string to use for each indentation level.  The
+	// global config instance that all top-level functions use set this to a
+	// single space by default.  If you would like more indentation, you might
+	// set this to a tab with "\t" or perhaps two spaces with "  ".
+	Indent string
+
+	// MaxDepth controls the maximum number of levels to descend into nested
+	// data structures.  The default, 0, means there is no limit.
+	//
+	// NOTE: Circular data structures are properly detected, so it is not
+	// necessary to set this value unless you specifically want to limit deeply
+	// nested data structures.
+	MaxDepth int
+
+	// DisableMethods specifies whether or not error and Stringer interfaces are
+	// invoked for types that implement them.
+	DisableMethods bool
+
+	// DisablePointerMethods specifies whether or not to check for and invoke
+	// error and Stringer interfaces on types which only accept a pointer
+	// receiver when the current type is not a pointer.
+	//
+	// NOTE: This might be an unsafe action since calling one of these methods
+	// with a pointer receiver could technically mutate the value, however,
+	// in practice, types which choose to satisify an error or Stringer
+	// interface with a pointer receiver should not be mutating their state
+	// inside these interface methods.  As a result, this option relies on
+	// access to the unsafe package, so it will not have any effect when
+	// running in environments without access to the unsafe package such as
+	// Google App Engine or with the "safe" build tag specified.
+	DisablePointerMethods bool
+
+	// DisablePointerAddresses specifies whether to disable the printing of
+	// pointer addresses. This is useful when diffing data structures in tests.
+	DisablePointerAddresses bool
+
+	// DisableCapacities specifies whether to disable the printing of capacities
+	// for arrays, slices, maps and channels. This is useful when diffing
+	// data structures in tests.
+	DisableCapacities bool
+
+	// ContinueOnMethod specifies whether or not recursion should continue once
+	// a custom error or Stringer interface is invoked.  The default, false,
+	// means it will print the results of invoking the custom error or Stringer
+	// interface and return immediately instead of continuing to recurse into
+	// the internals of the data type.
+	//
+	// NOTE: This flag does not have any effect if method invocation is disabled
+	// via the DisableMethods or DisablePointerMethods options.
+	ContinueOnMethod bool
+
+	// SortKeys specifies map keys should be sorted before being printed. Use
+	// this to have a more deterministic, diffable output.  Note that only
+	// native types (bool, int, uint, floats, uintptr and string) and types
+	// that support the error or Stringer interfaces (if methods are
+	// enabled) are supported, with other types sorted according to the
+	// reflect.Value.String() output which guarantees display stability.
+	SortKeys bool
+
+	// SpewKeys specifies that, as a last resort attempt, map keys should
+	// be spewed to strings and sorted by those strings.  This is only
+	// considered if SortKeys is true.
+	SpewKeys bool
+}
+
+// Config is the active configuration of the top-level functions.
+// The configuration can be changed by modifying the contents of spew.Config.
+var Config = ConfigState{Indent: " "}
+
+// Errorf is a wrapper for fmt.Errorf that treats each argument as if it were
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
+// the formatted string as a value that satisfies error.  See NewFormatter
+// for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Errorf(format, c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Errorf(format string, a ...interface{}) (err error) {
+	return fmt.Errorf(format, c.convertArgs(a)...)
+}
+
+// Fprint is a wrapper for fmt.Fprint that treats each argument as if it were
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
+// the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Fprint(w, c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Fprint(w io.Writer, a ...interface{}) (n int, err error) {
+	return fmt.Fprint(w, c.convertArgs(a)...)
+}
+
+// Fprintf is a wrapper for fmt.Fprintf that treats each argument as if it were
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
+// the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Fprintf(w, format, c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
+	return fmt.Fprintf(w, format, c.convertArgs(a)...)
+}
+
+// Fprintln is a wrapper for fmt.Fprintln that treats each argument as if it
+// passed with a Formatter interface returned by c.NewFormatter.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Fprintln(w, c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Fprintln(w io.Writer, a ...interface{}) (n int, err error) {
+	return fmt.Fprintln(w, c.convertArgs(a)...)
+}
+
+// Print is a wrapper for fmt.Print that treats each argument as if it were
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
+// the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Print(c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Print(a ...interface{}) (n int, err error) {
+	return fmt.Print(c.convertArgs(a)...)
+}
+
+// Printf is a wrapper for fmt.Printf that treats each argument as if it were
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
+// the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Printf(format, c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Printf(format string, a ...interface{}) (n int, err error) {
+	return fmt.Printf(format, c.convertArgs(a)...)
+}
+
+// Println is a wrapper for fmt.Println that treats each argument as if it were
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
+// the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Println(c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Println(a ...interface{}) (n int, err error) {
+	return fmt.Println(c.convertArgs(a)...)
+}
+
+// Sprint is a wrapper for fmt.Sprint that treats each argument as if it were
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
+// the resulting string.  See NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Sprint(c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Sprint(a ...interface{}) string {
+	return fmt.Sprint(c.convertArgs(a)...)
+}
+
+// Sprintf is a wrapper for fmt.Sprintf that treats each argument as if it were
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
+// the resulting string.  See NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Sprintf(format, c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Sprintf(format string, a ...interface{}) string {
+	return fmt.Sprintf(format, c.convertArgs(a)...)
+}
+
+// Sprintln is a wrapper for fmt.Sprintln that treats each argument as if it
+// were passed with a Formatter interface returned by c.NewFormatter.  It
+// returns the resulting string.  See NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Sprintln(c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Sprintln(a ...interface{}) string {
+	return fmt.Sprintln(c.convertArgs(a)...)
+}
+
+/*
+NewFormatter returns a custom formatter that satisfies the fmt.Formatter
+interface.  As a result, it integrates cleanly with standard fmt package
+printing functions.  The formatter is useful for inline printing of smaller data
+types similar to the standard %v format specifier.
+
+The custom formatter only responds to the %v (most compact), %+v (adds pointer
+addresses), %#v (adds types), and %#+v (adds types and pointer addresses) verb
+combinations.  Any other verbs such as %x and %q will be sent to the the
+standard fmt package for formatting.  In addition, the custom formatter ignores
+the width and precision arguments (however they will still work on the format
+specifiers not handled by the custom formatter).
+
+Typically this function shouldn't be called directly.  It is much easier to make
+use of the custom formatter by calling one of the convenience functions such as
+c.Printf, c.Println, or c.Printf.
+*/
+func (c *ConfigState) NewFormatter(v interface{}) fmt.Formatter {
+	return newFormatter(c, v)
+}
+
+// Fdump formats and displays the passed arguments to io.Writer w.  It formats
+// exactly the same as Dump.
+func (c *ConfigState) Fdump(w io.Writer, a ...interface{}) {
+	fdump(c, w, a...)
+}
+
+/*
+Dump displays the passed parameters to standard out with newlines, customizable
+indentation, and additional debug information such as complete types and all
+pointer addresses used to indirect to the final value.  It provides the
+following features over the built-in printing facilities provided by the fmt
+package:
+
+	* Pointers are dereferenced and followed
+	* Circular data structures are detected and handled properly
+	* Custom Stringer/error interfaces are optionally invoked, including
+	  on unexported types
+	* Custom types which only implement the Stringer/error interfaces via
+	  a pointer receiver are optionally invoked when passing non-pointer
+	  variables
+	* Byte arrays and slices are dumped like the hexdump -C command which
+	  includes offsets, byte values in hex, and ASCII output
+
+The configuration options are controlled by modifying the public members
+of c.  See ConfigState for options documentation.
+
+See Fdump if you would prefer dumping to an arbitrary io.Writer or Sdump to
+get the formatted result as a string.
+*/
+func (c *ConfigState) Dump(a ...interface{}) {
+	fdump(c, os.Stdout, a...)
+}
+
+// Sdump returns a string with the passed arguments formatted exactly the same
+// as Dump.
+func (c *ConfigState) Sdump(a ...interface{}) string {
+	var buf bytes.Buffer
+	fdump(c, &buf, a...)
+	return buf.String()
+}
+
+// convertArgs accepts a slice of arguments and returns a slice of the same
+// length with each argument converted to a spew Formatter interface using
+// the ConfigState associated with s.
+func (c *ConfigState) convertArgs(args []interface{}) (formatters []interface{}) {
+	formatters = make([]interface{}, len(args))
+	for index, arg := range args {
+		formatters[index] = newFormatter(c, arg)
+	}
+	return formatters
+}
+
+// NewDefaultConfig returns a ConfigState with the following default settings.
+//
+// 	Indent: " "
+// 	MaxDepth: 0
+// 	DisableMethods: false
+// 	DisablePointerMethods: false
+// 	ContinueOnMethod: false
+// 	SortKeys: false
+func NewDefaultConfig() *ConfigState {
+	return &ConfigState{Indent: " "}
+}

vendor/github.com/davecgh/go-spew/spew/doc.go

@@ -0,0 +1,211 @@
+/*
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/*
+Package spew implements a deep pretty printer for Go data structures to aid in
+debugging.
+
+A quick overview of the additional features spew provides over the built-in
+printing facilities for Go data types are as follows:
+
+	* Pointers are dereferenced and followed
+	* Circular data structures are detected and handled properly
+	* Custom Stringer/error interfaces are optionally invoked, including
+	  on unexported types
+	* Custom types which only implement the Stringer/error interfaces via
+	  a pointer receiver are optionally invoked when passing non-pointer
+	  variables
+	* Byte arrays and slices are dumped like the hexdump -C command which
+	  includes offsets, byte values in hex, and ASCII output (only when using
+	  Dump style)
+
+There are two different approaches spew allows for dumping Go data structures:
+
+	* Dump style which prints with newlines, customizable indentation,
+	  and additional debug information such as types and all pointer addresses
+	  used to indirect to the final value
+	* A custom Formatter interface that integrates cleanly with the standard fmt
+	  package and replaces %v, %+v, %#v, and %#+v to provide inline printing
+	  similar to the default %v while providing the additional functionality
+	  outlined above and passing unsupported format verbs such as %x and %q
+	  along to fmt
+
+Quick Start
+
+This section demonstrates how to quickly get started with spew.  See the
+sections below for further details on formatting and configuration options.
+
+To dump a variable with full newlines, indentation, type, and pointer
+information use Dump, Fdump, or Sdump:
+	spew.Dump(myVar1, myVar2, ...)
+	spew.Fdump(someWriter, myVar1, myVar2, ...)
+	str := spew.Sdump(myVar1, myVar2, ...)
+
+Alternatively, if you would prefer to use format strings with a compacted inline
+printing style, use the convenience wrappers Printf, Fprintf, etc with
+%v (most compact), %+v (adds pointer addresses), %#v (adds types), or
+%#+v (adds types and pointer addresses):
+	spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2)
+	spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
+	spew.Fprintf(someWriter, "myVar1: %v -- myVar2: %+v", myVar1, myVar2)
+	spew.Fprintf(someWriter, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
+
+Configuration Options
+
+Configuration of spew is handled by fields in the ConfigState type.  For
+convenience, all of the top-level functions use a global state available
+via the spew.Config global.
+
+It is also possible to create a ConfigState instance that provides methods
+equivalent to the top-level functions.  This allows concurrent configuration
+options.  See the ConfigState documentation for more details.
+
+The following configuration options are available:
+	* Indent
+		String to use for each indentation level for Dump functions.
+		It is a single space by default.  A popular alternative is "\t".
+
+	* MaxDepth
+		Maximum number of levels to descend into nested data structures.
+		There is no limit by default.
+
+	* DisableMethods
+		Disables invocation of error and Stringer interface methods.
+		Method invocation is enabled by default.
+
+	* DisablePointerMethods
+		Disables invocation of error and Stringer interface methods on types
+		which only accept pointer receivers from non-pointer variables.
+		Pointer method invocation is enabled by default.
+
+	* DisablePointerAddresses
+		DisablePointerAddresses specifies whether to disable the printing of
+		pointer addresses. This is useful when diffing data structures in tests.
+
+	* DisableCapacities
+		DisableCapacities specifies whether to disable the printing of
+		capacities for arrays, slices, maps and channels. This is useful when
+		diffing data structures in tests.
+
+	* ContinueOnMethod
+		Enables recursion into types after invoking error and Stringer interface
+		methods. Recursion after method invocation is disabled by default.
+
+	* SortKeys
+		Specifies map keys should be sorted before being printed. Use
+		this to have a more deterministic, diffable output.  Note that
+		only native types (bool, int, uint, floats, uintptr and string)
+		and types which implement error or Stringer interfaces are
+		supported with other types sorted according to the
+		reflect.Value.String() output which guarantees display
+		stability.  Natural map order is used by default.
+
+	* SpewKeys
+		Specifies that, as a last resort attempt, map keys should be
+		spewed to strings and sorted by those strings.  This is only
+		considered if SortKeys is true.
+
+Dump Usage
+
+Simply call spew.Dump with a list of variables you want to dump:
+
+	spew.Dump(myVar1, myVar2, ...)
+
+You may also call spew.Fdump if you would prefer to output to an arbitrary
+io.Writer.  For example, to dump to standard error:
+
+	spew.Fdump(os.Stderr, myVar1, myVar2, ...)
+
+A third option is to call spew.Sdump to get the formatted output as a string:
+
+	str := spew.Sdump(myVar1, myVar2, ...)
+
+Sample Dump Output
+
+See the Dump example for details on the setup of the types and variables being
+shown here.
+
+	(main.Foo) {
+	 unexportedField: (*main.Bar)(0xf84002e210)({
+	  flag: (main.Flag) flagTwo,
+	  data: (uintptr) <nil>
+	 }),
+	 ExportedField: (map[interface {}]interface {}) (len=1) {
+	  (string) (len=3) "one": (bool) true
+	 }
+	}
+
+Byte (and uint8) arrays and slices are displayed uniquely like the hexdump -C
+command as shown.
+	([]uint8) (len=32 cap=32) {
+	 00000000  11 12 13 14 15 16 17 18  19 1a 1b 1c 1d 1e 1f 20  |............... |
+	 00000010  21 22 23 24 25 26 27 28  29 2a 2b 2c 2d 2e 2f 30  |!"#$%&'()*+,-./0|
+	 00000020  31 32                                             |12|
+	}
+
+Custom Formatter
+
+Spew provides a custom formatter that implements the fmt.Formatter interface
+so that it integrates cleanly with standard fmt package printing functions. The
+formatter is useful for inline printing of smaller data types similar to the
+standard %v format specifier.
+
+The custom formatter only responds to the %v (most compact), %+v (adds pointer
+addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb
+combinations.  Any other verbs such as %x and %q will be sent to the the
+standard fmt package for formatting.  In addition, the custom formatter ignores
+the width and precision arguments (however they will still work on the format
+specifiers not handled by the custom formatter).
+
+Custom Formatter Usage
+
+The simplest way to make use of the spew custom formatter is to call one of the
+convenience functions such as spew.Printf, spew.Println, or spew.Printf.  The
+functions have syntax you are most likely already familiar with:
+
+	spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2)
+	spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
+	spew.Println(myVar, myVar2)
+	spew.Fprintf(os.Stderr, "myVar1: %v -- myVar2: %+v", myVar1, myVar2)
+	spew.Fprintf(os.Stderr, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
+
+See the Index for the full list convenience functions.
+
+Sample Formatter Output
+
+Double pointer to a uint8:
+	  %v: <**>5
+	 %+v: <**>(0xf8400420d0->0xf8400420c8)5
+	 %#v: (**uint8)5
+	%#+v: (**uint8)(0xf8400420d0->0xf8400420c8)5
+
+Pointer to circular struct with a uint8 field and a pointer to itself:
+	  %v: <*>{1 <*><shown>}
+	 %+v: <*>(0xf84003e260){ui8:1 c:<*>(0xf84003e260)<shown>}
+	 %#v: (*main.circular){ui8:(uint8)1 c:(*main.circular)<shown>}
+	%#+v: (*main.circular)(0xf84003e260){ui8:(uint8)1 c:(*main.circular)(0xf84003e260)<shown>}
+
+See the Printf example for details on the setup of variables being shown
+here.
+
+Errors
+
+Since it is possible for custom Stringer/error interfaces to panic, spew
+detects them and handles them internally by printing the panic information
+inline with the output.  Since spew is intended to provide deep pretty printing
+capabilities on structures, it intentionally does not return any errors.
+*/
+package spew

vendor/github.com/davecgh/go-spew/spew/dump.go

@@ -0,0 +1,509 @@
+/*
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+package spew
+
+import (
+	"bytes"
+	"encoding/hex"
+	"fmt"
+	"io"
+	"os"
+	"reflect"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+var (
+	// uint8Type is a reflect.Type representing a uint8.  It is used to
+	// convert cgo types to uint8 slices for hexdumping.
+	uint8Type = reflect.TypeOf(uint8(0))
+
+	// cCharRE is a regular expression that matches a cgo char.
+	// It is used to detect character arrays to hexdump them.
+	cCharRE = regexp.MustCompile(`^.*\._Ctype_char$`)
+
+	// cUnsignedCharRE is a regular expression that matches a cgo unsigned
+	// char.  It is used to detect unsigned character arrays to hexdump
+	// them.
+	cUnsignedCharRE = regexp.MustCompile(`^.*\._Ctype_unsignedchar$`)
+
+	// cUint8tCharRE is a regular expression that matches a cgo uint8_t.
+	// It is used to detect uint8_t arrays to hexdump them.
+	cUint8tCharRE = regexp.MustCompile(`^.*\._Ctype_uint8_t$`)
+)
+
+// dumpState contains information about the state of a dump operation.
+type dumpState struct {
+	w                io.Writer
+	depth            int
+	pointers         map[uintptr]int
+	ignoreNextType   bool
+	ignoreNextIndent bool
+	cs               *ConfigState
+}
+
+// indent performs indentation according to the depth level and cs.Indent
+// option.
+func (d *dumpState) indent() {
+	if d.ignoreNextIndent {
+		d.ignoreNextIndent = false
+		return
+	}
+	d.w.Write(bytes.Repeat([]byte(d.cs.Indent), d.depth))
+}
+
+// unpackValue returns values inside of non-nil interfaces when possible.
+// This is useful for data types like structs, arrays, slices, and maps which
+// can contain varying types packed inside an interface.
+func (d *dumpState) unpackValue(v reflect.Value) reflect.Value {
+	if v.Kind() == reflect.Interface && !v.IsNil() {
+		v = v.Elem()
+	}
+	return v
+}
+
+// dumpPtr handles formatting of pointers by indirecting them as necessary.
+func (d *dumpState) dumpPtr(v reflect.Value) {
+	// Remove pointers at or below the current depth from map used to detect
+	// circular refs.
+	for k, depth := range d.pointers {
+		if depth >= d.depth {
+			delete(d.pointers, k)
+		}
+	}
+
+	// Keep list of all dereferenced pointers to show later.
+	pointerChain := make([]uintptr, 0)
+
+	// Figure out how many levels of indirection there are by dereferencing
+	// pointers and unpacking interfaces down the chain while detecting circular
+	// references.
+	nilFound := false
+	cycleFound := false
+	indirects := 0
+	ve := v
+	for ve.Kind() == reflect.Ptr {
+		if ve.IsNil() {
+			nilFound = true
+			break
+		}
+		indirects++
+		addr := ve.Pointer()
+		pointerChain = append(pointerChain, addr)
+		if pd, ok := d.pointers[addr]; ok && pd < d.depth {
+			cycleFound = true
+			indirects--
+			break
+		}
+		d.pointers[addr] = d.depth
+
+		ve = ve.Elem()
+		if ve.Kind() == reflect.Interface {
+			if ve.IsNil() {
+				nilFound = true
+				break
+			}
+			ve = ve.Elem()
+		}
+	}
+
+	// Display type information.
+	d.w.Write(openParenBytes)
+	d.w.Write(bytes.Repeat(asteriskBytes, indirects))
+	d.w.Write([]byte(ve.Type().String()))
+	d.w.Write(closeParenBytes)
+
+	// Display pointer information.
+	if !d.cs.DisablePointerAddresses && len(pointerChain) > 0 {
+		d.w.Write(openParenBytes)
+		for i, addr := range pointerChain {
+			if i > 0 {
+				d.w.Write(pointerChainBytes)
+			}
+			printHexPtr(d.w, addr)
+		}
+		d.w.Write(closeParenBytes)
+	}
+
+	// Display dereferenced value.
+	d.w.Write(openParenBytes)
+	switch {
+	case nilFound:
+		d.w.Write(nilAngleBytes)
+
+	case cycleFound:
+		d.w.Write(circularBytes)
+
+	default:
+		d.ignoreNextType = true
+		d.dump(ve)
+	}
+	d.w.Write(closeParenBytes)
+}
+
+// dumpSlice handles formatting of arrays and slices.  Byte (uint8 under
+// reflection) arrays and slices are dumped in hexdump -C fashion.
+func (d *dumpState) dumpSlice(v reflect.Value) {
+	// Determine whether this type should be hex dumped or not.  Also,
+	// for types which should be hexdumped, try to use the underlying data
+	// first, then fall back to trying to convert them to a uint8 slice.
+	var buf []uint8
+	doConvert := false
+	doHexDump := false
+	numEntries := v.Len()
+	if numEntries > 0 {
+		vt := v.Index(0).Type()
+		vts := vt.String()
+		switch {
+		// C types that need to be converted.
+		case cCharRE.MatchString(vts):
+			fallthrough
+		case cUnsignedCharRE.MatchString(vts):
+			fallthrough
+		case cUint8tCharRE.MatchString(vts):
+			doConvert = true
+
+		// Try to use existing uint8 slices and fall back to converting
+		// and copying if that fails.
+		case vt.Kind() == reflect.Uint8:
+			// We need an addressable interface to convert the type
+			// to a byte slice.  However, the reflect package won't
+			// give us an interface on certain things like
+			// unexported struct fields in order to enforce
+			// visibility rules.  We use unsafe, when available, to
+			// bypass these restrictions since this package does not
+			// mutate the values.
+			vs := v
+			if !vs.CanInterface() || !vs.CanAddr() {
+				vs = unsafeReflectValue(vs)
+			}
+			if !UnsafeDisabled {
+				vs = vs.Slice(0, numEntries)
+
+				// Use the existing uint8 slice if it can be
+				// type asserted.
+				iface := vs.Interface()
+				if slice, ok := iface.([]uint8); ok {
+					buf = slice
+					doHexDump = true
+					break
+				}
+			}
+
+			// The underlying data needs to be converted if it can't
+			// be type asserted to a uint8 slice.
+			doConvert = true
+		}
+
+		// Copy and convert the underlying type if needed.
+		if doConvert && vt.ConvertibleTo(uint8Type) {
+			// Convert and copy each element into a uint8 byte
+			// slice.
+			buf = make([]uint8, numEntries)
+			for i := 0; i < numEntries; i++ {
+				vv := v.Index(i)
+				buf[i] = uint8(vv.Convert(uint8Type).Uint())
+			}
+			doHexDump = true
+		}
+	}
+
+	// Hexdump the entire slice as needed.
+	if doHexDump {
+		indent := strings.Repeat(d.cs.Indent, d.depth)
+		str := indent + hex.Dump(buf)
+		str = strings.Replace(str, "\n", "\n"+indent, -1)
+		str = strings.TrimRight(str, d.cs.Indent)
+		d.w.Write([]byte(str))
+		return
+	}
+
+	// Recursively call dump for each item.
+	for i := 0; i < numEntries; i++ {
+		d.dump(d.unpackValue(v.Index(i)))
+		if i < (numEntries - 1) {
+			d.w.Write(commaNewlineBytes)
+		} else {
+			d.w.Write(newlineBytes)
+		}
+	}
+}
+
+// dump is the main workhorse for dumping a value.  It uses the passed reflect
+// value to figure out what kind of object we are dealing with and formats it
+// appropriately.  It is a recursive function, however circular data structures
+// are detected and handled properly.
+func (d *dumpState) dump(v reflect.Value) {
+	// Handle invalid reflect values immediately.
+	kind := v.Kind()
+	if kind == reflect.Invalid {
+		d.w.Write(invalidAngleBytes)
+		return
+	}
+
+	// Handle pointers specially.
+	if kind == reflect.Ptr {
+		d.indent()
+		d.dumpPtr(v)
+		return
+	}
+
+	// Print type information unless already handled elsewhere.
+	if !d.ignoreNextType {
+		d.indent()
+		d.w.Write(openParenBytes)
+		d.w.Write([]byte(v.Type().String()))
+		d.w.Write(closeParenBytes)
+		d.w.Write(spaceBytes)
+	}
+	d.ignoreNextType = false
+
+	// Display length and capacity if the built-in len and cap functions
+	// work with the value's kind and the len/cap itself is non-zero.
+	valueLen, valueCap := 0, 0
+	switch v.Kind() {
+	case reflect.Array, reflect.Slice, reflect.Chan:
+		valueLen, valueCap = v.Len(), v.Cap()
+	case reflect.Map, reflect.String:
+		valueLen = v.Len()
+	}
+	if valueLen != 0 || !d.cs.DisableCapacities && valueCap != 0 {
+		d.w.Write(openParenBytes)
+		if valueLen != 0 {
+			d.w.Write(lenEqualsBytes)
+			printInt(d.w, int64(valueLen), 10)
+		}
+		if !d.cs.DisableCapacities && valueCap != 0 {
+			if valueLen != 0 {
+				d.w.Write(spaceBytes)
+			}
+			d.w.Write(capEqualsBytes)
+			printInt(d.w, int64(valueCap), 10)
+		}
+		d.w.Write(closeParenBytes)
+		d.w.Write(spaceBytes)
+	}
+
+	// Call Stringer/error interfaces if they exist and the handle methods flag
+	// is enabled
+	if !d.cs.DisableMethods {
+		if (kind != reflect.Invalid) && (kind != reflect.Interface) {
+			if handled := handleMethods(d.cs, d.w, v); handled {
+				return
+			}
+		}
+	}
+
+	switch kind {
+	case reflect.Invalid:
+		// Do nothing.  We should never get here since invalid has already
+		// been handled above.
+
+	case reflect.Bool:
+		printBool(d.w, v.Bool())
+
+	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
+		printInt(d.w, v.Int(), 10)
+
+	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
+		printUint(d.w, v.Uint(), 10)
+
+	case reflect.Float32:
+		printFloat(d.w, v.Float(), 32)
+
+	case reflect.Float64:
+		printFloat(d.w, v.Float(), 64)
+
+	case reflect.Complex64:
+		printComplex(d.w, v.Complex(), 32)
+
+	case reflect.Complex128:
+		printComplex(d.w, v.Complex(), 64)
+
+	case reflect.Slice:
+		if v.IsNil() {
+			d.w.Write(nilAngleBytes)
+			break
+		}
+		fallthrough
+
+	case reflect.Array:
+		d.w.Write(openBraceNewlineBytes)
+		d.depth++
+		if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) {
+			d.indent()
+			d.w.Write(maxNewlineBytes)
+		} else {
+			d.dumpSlice(v)
+		}
+		d.depth--
+		d.indent()
+		d.w.Write(closeBraceBytes)
+
+	case reflect.String:
+		d.w.Write([]byte(strconv.Quote(v.String())))
+
+	case reflect.Interface:
+		// The only time we should get here is for nil interfaces due to
+		// unpackValue calls.
+		if v.IsNil() {
+			d.w.Write(nilAngleBytes)
+		}
+
+	case reflect.Ptr:
+		// Do nothing.  We should never get here since pointers have already
+		// been handled above.
+
+	case reflect.Map:
+		// nil maps should be indicated as different than empty maps
+		if v.IsNil() {
+			d.w.Write(nilAngleBytes)
+			break
+		}
+
+		d.w.Write(openBraceNewlineBytes)
+		d.depth++
+		if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) {
+			d.indent()
+			d.w.Write(maxNewlineBytes)
+		} else {
+			numEntries := v.Len()
+			keys := v.MapKeys()
+			if d.cs.SortKeys {
+				sortValues(keys, d.cs)
+			}
+			for i, key := range keys {
+				d.dump(d.unpackValue(key))
+				d.w.Write(colonSpaceBytes)
+				d.ignoreNextIndent = true
+				d.dump(d.unpackValue(v.MapIndex(key)))
+				if i < (numEntries - 1) {
+					d.w.Write(commaNewlineBytes)
+				} else {
+					d.w.Write(newlineBytes)
+				}
+			}
+		}
+		d.depth--
+		d.indent()
+		d.w.Write(closeBraceBytes)
+
+	case reflect.Struct:
+		d.w.Write(openBraceNewlineBytes)
+		d.depth++
+		if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) {
+			d.indent()
+			d.w.Write(maxNewlineBytes)
+		} else {
+			vt := v.Type()
+			numFields := v.NumField()
+			for i := 0; i < numFields; i++ {
+				d.indent()
+				vtf := vt.Field(i)
+				d.w.Write([]byte(vtf.Name))
+				d.w.Write(colonSpaceBytes)
+				d.ignoreNextIndent = true
+				d.dump(d.unpackValue(v.Field(i)))
+				if i < (numFields - 1) {
+					d.w.Write(commaNewlineBytes)
+				} else {
+					d.w.Write(newlineBytes)
+				}
+			}
+		}
+		d.depth--
+		d.indent()
+		d.w.Write(closeBraceBytes)
+
+	case reflect.Uintptr:
+		printHexPtr(d.w, uintptr(v.Uint()))
+
+	case reflect.UnsafePointer, reflect.Chan, reflect.Func:
+		printHexPtr(d.w, v.Pointer())
+
+	// There were not any other types at the time this code was written, but
+	// fall back to letting the default fmt package handle it in case any new
+	// types are added.
+	default:
+		if v.CanInterface() {
+			fmt.Fprintf(d.w, "%v", v.Interface())
+		} else {
+			fmt.Fprintf(d.w, "%v", v.String())
+		}
+	}
+}
+
+// fdump is a helper function to consolidate the logic from the various public
+// methods which take varying writers and config states.
+func fdump(cs *ConfigState, w io.Writer, a ...interface{}) {
+	for _, arg := range a {
+		if arg == nil {
+			w.Write(interfaceBytes)
+			w.Write(spaceBytes)
+			w.Write(nilAngleBytes)
+			w.Write(newlineBytes)
+			continue
+		}
+
+		d := dumpState{w: w, cs: cs}
+		d.pointers = make(map[uintptr]int)
+		d.dump(reflect.ValueOf(arg))
+		d.w.Write(newlineBytes)
+	}
+}
+
+// Fdump formats and displays the passed arguments to io.Writer w.  It formats
+// exactly the same as Dump.
+func Fdump(w io.Writer, a ...interface{}) {
+	fdump(&Config, w, a...)
+}
+
+// Sdump returns a string with the passed arguments formatted exactly the same
+// as Dump.
+func Sdump(a ...interface{}) string {
+	var buf bytes.Buffer
+	fdump(&Config, &buf, a...)
+	return buf.String()
+}
+
+/*
+Dump displays the passed parameters to standard out with newlines, customizable
+indentation, and additional debug information such as complete types and all
+pointer addresses used to indirect to the final value.  It provides the
+following features over the built-in printing facilities provided by the fmt
+package:
+
+	* Pointers are dereferenced and followed
+	* Circular data structures are detected and handled properly
+	* Custom Stringer/error interfaces are optionally invoked, including
+	  on unexported types
+	* Custom types which only implement the Stringer/error interfaces via
+	  a pointer receiver are optionally invoked when passing non-pointer
+	  variables
+	* Byte arrays and slices are dumped like the hexdump -C command which
+	  includes offsets, byte values in hex, and ASCII output
+
+The configuration options are controlled by an exported package global,
+spew.Config.  See ConfigState for options documentation.
+
+See Fdump if you would prefer dumping to an arbitrary io.Writer or Sdump to
+get the formatted result as a string.
+*/
+func Dump(a ...interface{}) {
+	fdump(&Config, os.Stdout, a...)
+}

vendor/github.com/davecgh/go-spew/spew/format.go

@@ -0,0 +1,419 @@
+/*
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+package spew
+
+import (
+	"bytes"
+	"fmt"
+	"reflect"
+	"strconv"
+	"strings"
+)
+
+// supportedFlags is a list of all the character flags supported by fmt package.
+const supportedFlags = "0-+# "
+
+// formatState implements the fmt.Formatter interface and contains information
+// about the state of a formatting operation.  The NewFormatter function can
+// be used to get a new Formatter which can be used directly as arguments
+// in standard fmt package printing calls.
+type formatState struct {
+	value          interface{}
+	fs             fmt.State
+	depth          int
+	pointers       map[uintptr]int
+	ignoreNextType bool
+	cs             *ConfigState
+}
+
+// buildDefaultFormat recreates the original format string without precision
+// and width information to pass in to fmt.Sprintf in the case of an
+// unrecognized type.  Unless new types are added to the language, this
+// function won't ever be called.
+func (f *formatState) buildDefaultFormat() (format string) {
+	buf := bytes.NewBuffer(percentBytes)
+
+	for _, flag := range supportedFlags {
+		if f.fs.Flag(int(flag)) {
+			buf.WriteRune(flag)
+		}
+	}
+
+	buf.WriteRune('v')
+
+	format = buf.String()
+	return format
+}
+
+// constructOrigFormat recreates the original format string including precision
+// and width information to pass along to the standard fmt package.  This allows
+// automatic deferral of all format strings this package doesn't support.
+func (f *formatState) constructOrigFormat(verb rune) (format string) {
+	buf := bytes.NewBuffer(percentBytes)
+
+	for _, flag := range supportedFlags {
+		if f.fs.Flag(int(flag)) {
+			buf.WriteRune(flag)
+		}
+	}
+
+	if width, ok := f.fs.Width(); ok {
+		buf.WriteString(strconv.Itoa(width))
+	}
+
+	if precision, ok := f.fs.Precision(); ok {
+		buf.Write(precisionBytes)
+		buf.WriteString(strconv.Itoa(precision))
+	}
+
+	buf.WriteRune(verb)
+
+	format = buf.String()
+	return format
+}
+
+// unpackValue returns values inside of non-nil interfaces when possible and
+// ensures that types for values which have been unpacked from an interface
+// are displayed when the show types flag is also set.
+// This is useful for data types like structs, arrays, slices, and maps which
+// can contain varying types packed inside an interface.
+func (f *formatState) unpackValue(v reflect.Value) reflect.Value {
+	if v.Kind() == reflect.Interface {
+		f.ignoreNextType = false
+		if !v.IsNil() {
+			v = v.Elem()
+		}
+	}
+	return v
+}
+
+// formatPtr handles formatting of pointers by indirecting them as necessary.
+func (f *formatState) formatPtr(v reflect.Value) {
+	// Display nil if top level pointer is nil.
+	showTypes := f.fs.Flag('#')
+	if v.IsNil() && (!showTypes || f.ignoreNextType) {
+		f.fs.Write(nilAngleBytes)
+		return
+	}
+
+	// Remove pointers at or below the current depth from map used to detect
+	// circular refs.
+	for k, depth := range f.pointers {
+		if depth >= f.depth {
+			delete(f.pointers, k)
+		}
+	}
+
+	// Keep list of all dereferenced pointers to possibly show later.
+	pointerChain := make([]uintptr, 0)
+
+	// Figure out how many levels of indirection there are by derferencing
+	// pointers and unpacking interfaces down the chain while detecting circular
+	// references.
+	nilFound := false
+	cycleFound := false
+	indirects := 0
+	ve := v
+	for ve.Kind() == reflect.Ptr {
+		if ve.IsNil() {
+			nilFound = true
+			break
+		}
+		indirects++
+		addr := ve.Pointer()
+		pointerChain = append(pointerChain, addr)
+		if pd, ok := f.pointers[addr]; ok && pd < f.depth {
+			cycleFound = true
+			indirects--
+			break
+		}
+		f.pointers[addr] = f.depth
+
+		ve = ve.Elem()
+		if ve.Kind() == reflect.Interface {
+			if ve.IsNil() {
+				nilFound = true
+				break
+			}
+			ve = ve.Elem()
+		}
+	}
+
+	// Display type or indirection level depending on flags.
+	if showTypes && !f.ignoreNextType {
+		f.fs.Write(openParenBytes)
+		f.fs.Write(bytes.Repeat(asteriskBytes, indirects))
+		f.fs.Write([]byte(ve.Type().String()))
+		f.fs.Write(closeParenBytes)
+	} else {
+		if nilFound || cycleFound {
+			indirects += strings.Count(ve.Type().String(), "*")
+		}
+		f.fs.Write(openAngleBytes)
+		f.fs.Write([]byte(strings.Repeat("*", indirects)))
+		f.fs.Write(closeAngleBytes)
+	}
+
+	// Display pointer information depending on flags.
+	if f.fs.Flag('+') && (len(pointerChain) > 0) {
+		f.fs.Write(openParenBytes)
+		for i, addr := range pointerChain {
+			if i > 0 {
+				f.fs.Write(pointerChainBytes)
+			}
+			printHexPtr(f.fs, addr)
+		}
+		f.fs.Write(closeParenBytes)
+	}
+
+	// Display dereferenced value.
+	switch {
+	case nilFound:
+		f.fs.Write(nilAngleBytes)
+
+	case cycleFound:
+		f.fs.Write(circularShortBytes)
+
+	default:
+		f.ignoreNextType = true
+		f.format(ve)
+	}
+}
+
+// format is the main workhorse for providing the Formatter interface.  It
+// uses the passed reflect value to figure out what kind of object we are
+// dealing with and formats it appropriately.  It is a recursive function,
+// however circular data structures are detected and handled properly.
+func (f *formatState) format(v reflect.Value) {
+	// Handle invalid reflect values immediately.
+	kind := v.Kind()
+	if kind == reflect.Invalid {
+		f.fs.Write(invalidAngleBytes)
+		return
+	}
+
+	// Handle pointers specially.
+	if kind == reflect.Ptr {
+		f.formatPtr(v)
+		return
+	}
+
+	// Print type information unless already handled elsewhere.
+	if !f.ignoreNextType && f.fs.Flag('#') {
+		f.fs.Write(openParenBytes)
+		f.fs.Write([]byte(v.Type().String()))
+		f.fs.Write(closeParenBytes)
+	}
+	f.ignoreNextType = false
+
+	// Call Stringer/error interfaces if they exist and the handle methods
+	// flag is enabled.
+	if !f.cs.DisableMethods {
+		if (kind != reflect.Invalid) && (kind != reflect.Interface) {
+			if handled := handleMethods(f.cs, f.fs, v); handled {
+				return
+			}
+		}
+	}
+
+	switch kind {
+	case reflect.Invalid:
+		// Do nothing.  We should never get here since invalid has already
+		// been handled above.
+
+	case reflect.Bool:
+		printBool(f.fs, v.Bool())
+
+	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
+		printInt(f.fs, v.Int(), 10)
+
+	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
+		printUint(f.fs, v.Uint(), 10)
+
+	case reflect.Float32:
+		printFloat(f.fs, v.Float(), 32)
+
+	case reflect.Float64:
+		printFloat(f.fs, v.Float(), 64)
+
+	case reflect.Complex64:
+		printComplex(f.fs, v.Complex(), 32)
+
+	case reflect.Complex128:
+		printComplex(f.fs, v.Complex(), 64)
+
+	case reflect.Slice:
+		if v.IsNil() {
+			f.fs.Write(nilAngleBytes)
+			break
+		}
+		fallthrough
+
+	case reflect.Array:
+		f.fs.Write(openBracketBytes)
+		f.depth++
+		if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {
+			f.fs.Write(maxShortBytes)
+		} else {
+			numEntries := v.Len()
+			for i := 0; i < numEntries; i++ {
+				if i > 0 {
+					f.fs.Write(spaceBytes)
+				}
+				f.ignoreNextType = true
+				f.format(f.unpackValue(v.Index(i)))
+			}
+		}
+		f.depth--
+		f.fs.Write(closeBracketBytes)
+
+	case reflect.String:
+		f.fs.Write([]byte(v.String()))
+
+	case reflect.Interface:
+		// The only time we should get here is for nil interfaces due to
+		// unpackValue calls.
+		if v.IsNil() {
+			f.fs.Write(nilAngleBytes)
+		}
+
+	case reflect.Ptr:
+		// Do nothing.  We should never get here since pointers have already
+		// been handled above.
+
+	case reflect.Map:
+		// nil maps should be indicated as different than empty maps
+		if v.IsNil() {
+			f.fs.Write(nilAngleBytes)
+			break
+		}
+
+		f.fs.Write(openMapBytes)
+		f.depth++
+		if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {
+			f.fs.Write(maxShortBytes)
+		} else {
+			keys := v.MapKeys()
+			if f.cs.SortKeys {
+				sortValues(keys, f.cs)
+			}
+			for i, key := range keys {
+				if i > 0 {
+					f.fs.Write(spaceBytes)
+				}
+				f.ignoreNextType = true
+				f.format(f.unpackValue(key))
+				f.fs.Write(colonBytes)
+				f.ignoreNextType = true
+				f.format(f.unpackValue(v.MapIndex(key)))
+			}
+		}
+		f.depth--
+		f.fs.Write(closeMapBytes)
+
+	case reflect.Struct:
+		numFields := v.NumField()
+		f.fs.Write(openBraceBytes)
+		f.depth++
+		if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {
+			f.fs.Write(maxShortBytes)
+		} else {
+			vt := v.Type()
+			for i := 0; i < numFields; i++ {
+				if i > 0 {
+					f.fs.Write(spaceBytes)
+				}
+				vtf := vt.Field(i)
+				if f.fs.Flag('+') || f.fs.Flag('#') {
+					f.fs.Write([]byte(vtf.Name))
+					f.fs.Write(colonBytes)
+				}
+				f.format(f.unpackValue(v.Field(i)))
+			}
+		}
+		f.depth--
+		f.fs.Write(closeBraceBytes)
+
+	case reflect.Uintptr:
+		printHexPtr(f.fs, uintptr(v.Uint()))
+
+	case reflect.UnsafePointer, reflect.Chan, reflect.Func:
+		printHexPtr(f.fs, v.Pointer())
+
+	// There were not any other types at the time this code was written, but
+	// fall back to letting the default fmt package handle it if any get added.
+	default:
+		format := f.buildDefaultFormat()
+		if v.CanInterface() {
+			fmt.Fprintf(f.fs, format, v.Interface())
+		} else {
+			fmt.Fprintf(f.fs, format, v.String())
+		}
+	}
+}
+
+// Format satisfies the fmt.Formatter interface. See NewFormatter for usage
+// details.
+func (f *formatState) Format(fs fmt.State, verb rune) {
+	f.fs = fs
+
+	// Use standard formatting for verbs that are not v.
+	if verb != 'v' {
+		format := f.constructOrigFormat(verb)
+		fmt.Fprintf(fs, format, f.value)
+		return
+	}
+
+	if f.value == nil {
+		if fs.Flag('#') {
+			fs.Write(interfaceBytes)
+		}
+		fs.Write(nilAngleBytes)
+		return
+	}
+
+	f.format(reflect.ValueOf(f.value))
+}
+
+// newFormatter is a helper function to consolidate the logic from the various
+// public methods which take varying config states.
+func newFormatter(cs *ConfigState, v interface{}) fmt.Formatter {
+	fs := &formatState{value: v, cs: cs}
+	fs.pointers = make(map[uintptr]int)
+	return fs
+}
+
+/*
+NewFormatter returns a custom formatter that satisfies the fmt.Formatter
+interface.  As a result, it integrates cleanly with standard fmt package
+printing functions.  The formatter is useful for inline printing of smaller data
+types similar to the standard %v format specifier.
+
+The custom formatter only responds to the %v (most compact), %+v (adds pointer
+addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb
+combinations.  Any other verbs such as %x and %q will be sent to the the
+standard fmt package for formatting.  In addition, the custom formatter ignores
+the width and precision arguments (however they will still work on the format
+specifiers not handled by the custom formatter).
+
+Typically this function shouldn't be called directly.  It is much easier to make
+use of the custom formatter by calling one of the convenience functions such as
+Printf, Println, or Fprintf.
+*/
+func NewFormatter(v interface{}) fmt.Formatter {
+	return newFormatter(&Config, v)
+}

vendor/github.com/davecgh/go-spew/spew/spew.go

@@ -0,0 +1,148 @@
+/*
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+package spew
+
+import (
+	"fmt"
+	"io"
+)
+
+// Errorf is a wrapper for fmt.Errorf that treats each argument as if it were
+// passed with a default Formatter interface returned by NewFormatter.  It
+// returns the formatted string as a value that satisfies error.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Errorf(format, spew.NewFormatter(a), spew.NewFormatter(b))
+func Errorf(format string, a ...interface{}) (err error) {
+	return fmt.Errorf(format, convertArgs(a)...)
+}
+
+// Fprint is a wrapper for fmt.Fprint that treats each argument as if it were
+// passed with a default Formatter interface returned by NewFormatter.  It
+// returns the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Fprint(w, spew.NewFormatter(a), spew.NewFormatter(b))
+func Fprint(w io.Writer, a ...interface{}) (n int, err error) {
+	return fmt.Fprint(w, convertArgs(a)...)
+}
+
+// Fprintf is a wrapper for fmt.Fprintf that treats each argument as if it were
+// passed with a default Formatter interface returned by NewFormatter.  It
+// returns the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Fprintf(w, format, spew.NewFormatter(a), spew.NewFormatter(b))
+func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
+	return fmt.Fprintf(w, format, convertArgs(a)...)
+}
+
+// Fprintln is a wrapper for fmt.Fprintln that treats each argument as if it
+// passed with a default Formatter interface returned by NewFormatter.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Fprintln(w, spew.NewFormatter(a), spew.NewFormatter(b))
+func Fprintln(w io.Writer, a ...interface{}) (n int, err error) {
+	return fmt.Fprintln(w, convertArgs(a)...)
+}
+
+// Print is a wrapper for fmt.Print that treats each argument as if it were
+// passed with a default Formatter interface returned by NewFormatter.  It
+// returns the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Print(spew.NewFormatter(a), spew.NewFormatter(b))
+func Print(a ...interface{}) (n int, err error) {
+	return fmt.Print(convertArgs(a)...)
+}
+
+// Printf is a wrapper for fmt.Printf that treats each argument as if it were
+// passed with a default Formatter interface returned by NewFormatter.  It
+// returns the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Printf(format, spew.NewFormatter(a), spew.NewFormatter(b))
+func Printf(format string, a ...interface{}) (n int, err error) {
+	return fmt.Printf(format, convertArgs(a)...)
+}
+
+// Println is a wrapper for fmt.Println that treats each argument as if it were
+// passed with a default Formatter interface returned by NewFormatter.  It
+// returns the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Println(spew.NewFormatter(a), spew.NewFormatter(b))
+func Println(a ...interface{}) (n int, err error) {
+	return fmt.Println(convertArgs(a)...)
+}
+
+// Sprint is a wrapper for fmt.Sprint that treats each argument as if it were
+// passed with a default Formatter interface returned by NewFormatter.  It
+// returns the resulting string.  See NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Sprint(spew.NewFormatter(a), spew.NewFormatter(b))
+func Sprint(a ...interface{}) string {
+	return fmt.Sprint(convertArgs(a)...)
+}
+
+// Sprintf is a wrapper for fmt.Sprintf that treats each argument as if it were
+// passed with a default Formatter interface returned by NewFormatter.  It
+// returns the resulting string.  See NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Sprintf(format, spew.NewFormatter(a), spew.NewFormatter(b))
+func Sprintf(format string, a ...interface{}) string {
+	return fmt.Sprintf(format, convertArgs(a)...)
+}
+
+// Sprintln is a wrapper for fmt.Sprintln that treats each argument as if it
+// were passed with a default Formatter interface returned by NewFormatter.  It
+// returns the resulting string.  See NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Sprintln(spew.NewFormatter(a), spew.NewFormatter(b))
+func Sprintln(a ...interface{}) string {
+	return fmt.Sprintln(convertArgs(a)...)
+}
+
+// convertArgs accepts a slice of arguments and returns a slice of the same
+// length with each argument converted to a default spew Formatter interface.
+func convertArgs(args []interface{}) (formatters []interface{}) {
+	formatters = make([]interface{}, len(args))
+	for index, arg := range args {
+		formatters[index] = NewFormatter(arg)
+	}
+	return formatters
+}

vendor/github.com/go-co-op/gocron/v2/errors.go

@@ -4,6 +4,7 @@ import "fmt"
 
 // Public error definitions
 var (
+	ErrCronJobInvalid                = fmt.Errorf("gocron: CronJob: invalid crontab")
 	ErrCronJobParse                  = fmt.Errorf("gocron: CronJob: crontab parse failure")
 	ErrDailyJobAtTimeNil             = fmt.Errorf("gocron: DailyJob: atTime within atTimes must not be nil")
 	ErrDailyJobAtTimesNil            = fmt.Errorf("gocron: DailyJob: atTimes must not be nil")

vendor/github.com/go-co-op/gocron/v2/executor.go

@@ -196,7 +196,7 @@ func (e *executor) start() {
 							default:
 								// runner is busy, reschedule the work for later
 								// which means we just skip it here and do nothing
-								// TODO when metrics are added, this should increment a rescheduled metric
+								e.incrementJobCounter(*j, SingletonRescheduled)
 								e.sendOutForRescheduling(&jIn)
 							}
 						} else {
@@ -397,9 +397,7 @@ func (e *executor) runJob(j internalJob, jIn jobIn) {
 
 	startTime := time.Now()
 	err := e.callJobWithRecover(j)
-	if e.monitor != nil {
+	e.recordJobTiming(startTime, time.Now(), j)
-		e.monitor.RecordJobTiming(startTime, time.Now(), j.id, j.name, j.tags)
-	}
 	if err != nil {
 		_ = callJobFuncWithParams(j.afterJobRunsWithError, j.id, j.name, err)
 		e.incrementJobCounter(j, Fail)
@@ -422,6 +420,12 @@ func (e *executor) callJobWithRecover(j internalJob) (err error) {
 	return callJobFuncWithParams(j.function, j.parameters...)
 }
 
+func (e *executor) recordJobTiming(start time.Time, end time.Time, j internalJob) {
+	if e.monitor != nil {
+		e.monitor.RecordJobTiming(start, end, j.id, j.name, j.tags)
+	}
+}
+
 func (e *executor) incrementJobCounter(j internalJob, status JobStatus) {
 	if e.monitor != nil {
 		e.monitor.IncrementJob(j.id, j.name, j.tags, status)

vendor/github.com/go-co-op/gocron/v2/job.go

@@ -116,7 +116,7 @@ type cronJobDefinition struct {
 	withSeconds bool
 }
 
-func (c cronJobDefinition) setup(j *internalJob, location *time.Location, _ time.Time) error {
+func (c cronJobDefinition) setup(j *internalJob, location *time.Location, now time.Time) error {
 	var withLocation string
 	if strings.HasPrefix(c.crontab, "TZ=") || strings.HasPrefix(c.crontab, "CRON_TZ=") {
 		withLocation = c.crontab
@@ -140,6 +140,9 @@ func (c cronJobDefinition) setup(j *internalJob, location *time.Location, _ time
 	if err != nil {
 		return errors.Join(ErrCronJobParse, err)
 	}
+	if cronSchedule.Next(now).IsZero() {
+		return ErrCronJobInvalid
+	}
 
 	j.jobSchedule = &cronJob{cronSchedule: cronSchedule}
 	return nil
@@ -456,6 +459,8 @@ type oneTimeJobDefinition struct {
 func (o oneTimeJobDefinition) setup(j *internalJob, _ *time.Location, now time.Time) error {
 	sortedTimes := o.startAt(j)
 	slices.SortStableFunc(sortedTimes, ascendingTime)
+	// deduplicate the times
+	sortedTimes = removeSliceDuplicatesTimeOnSortedSlice(sortedTimes)
 	// keep only schedules that are in the future
 	idx, found := slices.BinarySearchFunc(sortedTimes, now, ascendingTime)
 	if found {
@@ -469,6 +474,16 @@ func (o oneTimeJobDefinition) setup(j *internalJob, _ *time.Location, now time.T
 	return nil
 }
 
+func removeSliceDuplicatesTimeOnSortedSlice(times []time.Time) []time.Time {
+	ret := make([]time.Time, 0, len(times))
+	for i, t := range times {
+		if i == 0 || t != times[i-1] {
+			ret = append(ret, t)
+		}
+	}
+	return ret
+}
+
 // OneTimeJobStartAtOption defines when the one time job is run
 type OneTimeJobStartAtOption func(*internalJob) []time.Time
 

vendor/github.com/go-co-op/gocron/v2/monitor.go

@@ -14,6 +14,7 @@ const (
 	Fail                 JobStatus = "fail"
 	Success              JobStatus = "success"
 	Skip                 JobStatus = "skip"
+	SingletonRescheduled JobStatus = "singleton_rescheduled"
 )
 
 // Monitor represents the interface to collect jobs metrics.

vendor/github.com/go-co-op/gocron/v2/scheduler.go

@@ -311,7 +311,7 @@ func (s *scheduler) selectRemoveJob(id uuid.UUID) {
 }
 
 // Jobs coming back from the executor to the scheduler that
-// need to evaluated for rescheduling.
+// need to be evaluated for rescheduling.
 func (s *scheduler) selectExecJobsOutForRescheduling(id uuid.UUID) {
 	select {
 	case <-s.shutdownCtx.Done():
@@ -359,6 +359,13 @@ func (s *scheduler) selectExecJobsOutForRescheduling(id uuid.UUID) {
 			next = j.next(next)
 		}
 	}
+
+	// Clean up any existing timer to prevent leaks
+	if j.timer != nil {
+		j.timer.Stop()
+		j.timer = nil // Ensure timer is cleared for GC
+	}
+
 	j.nextScheduled = append(j.nextScheduled, next)
 	j.timer = s.exec.clock.AfterFunc(next.Sub(s.now()), func() {
 		// set the actual timer on the job here and listen for

vendor/modules.txt

@@ -12,10 +12,13 @@ github.com/BurntSushi/xgbutil/xprop
 github.com/adrg/xdg
 github.com/adrg/xdg/internal/pathutil
 github.com/adrg/xdg/internal/userdirs
+# github.com/davecgh/go-spew v1.1.1
+## explicit
+github.com/davecgh/go-spew/spew
 # github.com/distatus/battery v0.11.0
 ## explicit; go 1.18
 github.com/distatus/battery
-# github.com/go-co-op/gocron/v2 v2.11.0
+# github.com/go-co-op/gocron/v2 v2.12.1
 ## explicit; go 1.20
 github.com/go-co-op/gocron/v2
 # github.com/go-ole/go-ole v1.3.0