Updated tests with benchmarks.

door/bar.go

@@ -28,7 +28,7 @@ const (
 
 type BarRange struct {
 	Percent int64
-	Color   string
+	Color   []byte
 }
 
 type BarLine struct {
@@ -89,7 +89,7 @@ func (bl *BarLine) Output() []byte {
 
 	bl.CheckRange()
 	// CheckRange can change the DefaultColor.
-	bl.render.WriteString(bl.DefaultColor)
+	bl.render.Write(bl.DefaultColor)
 
 	if bl.update == nil {
 		bl.update = &bytes.Buffer{}

door/bar_test.go

@@ -77,17 +77,17 @@ func testBars(t *testing.T) {
 		{9500, Bar95},
 		{10100, Bar100}}
 
-	BarSolid := map[int]string{0: Bar25 + "          ",
-		5:   Bar25 + "          ",
-		10:  Bar25 + BARS.Solid + "         ",
-		20:  Bar25 + strings.Repeat(BARS.Solid, 2) + "        ",
-		25:  Bar25 + strings.Repeat(BARS.Solid, 2) + "        ",
-		30:  Bar50 + strings.Repeat(BARS.Solid, 3) + "       ",
-		50:  Bar50 + strings.Repeat(BARS.Solid, 5) + "     ",
-		75:  Bar75 + strings.Repeat(BARS.Solid, 7) + "   ",
-		90:  Bar95 + strings.Repeat(BARS.Solid, 9) + " ",
-		95:  Bar95 + strings.Repeat(BARS.Solid, 9) + " ",
-		100: Bar100 + strings.Repeat(BARS.Solid, 10) + "",
+	BarSolid := map[int]string{0: string(Bar25) + "          ",
+		5:   string(Bar25) + "          ",
+		10:  string(Bar25) + BARS.Solid + "         ",
+		20:  string(Bar25) + strings.Repeat(BARS.Solid, 2) + "        ",
+		25:  string(Bar25) + strings.Repeat(BARS.Solid, 2) + "        ",
+		30:  string(Bar50) + strings.Repeat(BARS.Solid, 3) + "       ",
+		50:  string(Bar50) + strings.Repeat(BARS.Solid, 5) + "     ",
+		75:  string(Bar75) + strings.Repeat(BARS.Solid, 7) + "   ",
+		90:  string(Bar95) + strings.Repeat(BARS.Solid, 9) + " ",
+		95:  string(Bar95) + strings.Repeat(BARS.Solid, 9) + " ",
+		100: string(Bar100) + strings.Repeat(BARS.Solid, 10) + "",
 	}
 
 	for pct, text := range BarSolid {
@@ -100,17 +100,17 @@ func testBars(t *testing.T) {
 
 	BarColor = ColorText("BLA ON WHI")
 	bar = BarLine{Line: Line{DefaultColor: BarColor}, Width: 10, Style: HALF_STEP, PercentStyle: PERCENT_SPACE}
-	BarHalf := map[int]string{0: BarColor + "     0%   ",
-		5:   BarColor + BARS.Half[1] + "    5%   ",
-		6:   BarColor + BARS.Half[1] + "    6%   ",
-		10:  BarColor + BARS.Half[0] + "   10%   ",
-		20:  BarColor + BARS.Half[0] + BARS.Half[0] + "  20%   ",
-		25:  BarColor + BARS.Half[0] + BARS.Half[0] + BARS.Half[1] + " 25%   ",
-		26:  BarColor + BARS.Half[0] + BARS.Half[0] + BARS.Half[1] + " 26%   ",
-		50:  BarColor + strings.Repeat(BARS.Half[0], 3) + " 50%   ",
-		75:  BarColor + strings.Repeat(BARS.Half[0], 3) + " 75%   ",
-		90:  BarColor + strings.Repeat(BARS.Half[0], 3) + " 90% " + BARS.Half[0] + " ",
-		100: BarColor + strings.Repeat(BARS.Half[0], 3) + " 100 " + strings.Repeat(BARS.Half[0], 2),
+	BarHalf := map[int]string{0: string(BarColor) + "     0%   ",
+		5:   string(BarColor) + BARS.Half[1] + "    5%   ",
+		6:   string(BarColor) + BARS.Half[1] + "    6%   ",
+		10:  string(BarColor) + BARS.Half[0] + "   10%   ",
+		20:  string(BarColor) + BARS.Half[0] + BARS.Half[0] + "  20%   ",
+		25:  string(BarColor) + BARS.Half[0] + BARS.Half[0] + BARS.Half[1] + " 25%   ",
+		26:  string(BarColor) + BARS.Half[0] + BARS.Half[0] + BARS.Half[1] + " 26%   ",
+		50:  string(BarColor) + strings.Repeat(BARS.Half[0], 3) + " 50%   ",
+		75:  string(BarColor) + strings.Repeat(BARS.Half[0], 3) + " 75%   ",
+		90:  string(BarColor) + strings.Repeat(BARS.Half[0], 3) + " 90% " + BARS.Half[0] + " ",
+		100: string(BarColor) + strings.Repeat(BARS.Half[0], 3) + " 100 " + strings.Repeat(BARS.Half[0], 2),
 	}
 
 	for pct, text := range BarHalf {
@@ -123,16 +123,16 @@ func testBars(t *testing.T) {
 
 	BarColor = ColorText("RED")
 	bar = BarLine{Line: Line{DefaultColor: BarColor}, Width: 10, Style: GRADIENT}
-	BarGrad := map[int]string{0: BarColor + "          ",
-		3:   BarColor + BARS.Gradient[1] + "         ",
-		5:   BarColor + BARS.Gradient[2] + "         ",
-		8:   BarColor + BARS.Gradient[3] + "         ",
-		10:  BarColor + BARS.Gradient[0] + "         ",
-		20:  BarColor + BARS.Gradient[0] + BARS.Gradient[0] + "        ",
-		25:  BarColor + BARS.Gradient[0] + BARS.Gradient[0] + BARS.Gradient[2] + "       ",
-		50:  BarColor + strings.Repeat(BARS.Gradient[0], 5) + "     ",
-		75:  BarColor + strings.Repeat(BARS.Gradient[0], 7) + BARS.Gradient[2] + "  ",
-		100: BarColor + strings.Repeat(BARS.Gradient[0], 10),
+	BarGrad := map[int]string{0: string(BarColor) + "          ",
+		3:   string(BarColor) + BARS.Gradient[1] + "         ",
+		5:   string(BarColor) + BARS.Gradient[2] + "         ",
+		8:   string(BarColor) + BARS.Gradient[3] + "         ",
+		10:  string(BarColor) + BARS.Gradient[0] + "         ",
+		20:  string(BarColor) + BARS.Gradient[0] + BARS.Gradient[0] + "        ",
+		25:  string(BarColor) + BARS.Gradient[0] + BARS.Gradient[0] + BARS.Gradient[2] + "       ",
+		50:  string(BarColor) + strings.Repeat(BARS.Gradient[0], 5) + "     ",
+		75:  string(BarColor) + strings.Repeat(BARS.Gradient[0], 7) + BARS.Gradient[2] + "  ",
+		100: string(BarColor) + strings.Repeat(BARS.Gradient[0], 10),
 	}
 
 	var percent int64

door/color.go

@@ -1,6 +1,7 @@
 package door
 
 import (
+	"bytes"
 	"log"
 	"strconv"
 	"strings"
@@ -30,7 +31,20 @@ import (
 	}
 */
 
-func Color(arg []int) string {
+func Color(arg []int) []byte {
+	var result *bytes.Buffer = &bytes.Buffer{}
+	result.WriteString("\x1b[")
+	for idx, i := range arg {
+		if idx != 0 {
+			result.WriteString(";")
+		}
+		result.WriteString(strconv.Itoa(i))
+	}
+	result.WriteString("m")
+	return result.Bytes()
+}
+
+func ColorS(arg []int) string {
 	var result strings.Builder
 	result.WriteString("\x1b[")
 	for idx, i := range arg {
@@ -56,7 +70,7 @@ func Color(arg []int) string {
 // BLACK, RED, GREEN, BROWN / YELLOW, BLUE, MAGENTA, CYAN, WHITE
 // https://en.wikipedia.org/wiki/ANSI_escape_code#SGR_(Select_Graphic_Rendition)_parameters
 // https://en.wikipedia.org/wiki/ANSI_escape_code#3-bit_and_4-bit
-func ColorText(color string) string {
+func ColorText(color string) []byte {
 	// split on spaces, uppercase, match first 3 letter
 	var res [5]int
 	var result []int = res[0:0]
@@ -147,3 +161,95 @@ func ColorText(color string) string {
 	}
 	return Color(result)
 }
+
+func ColorTextS(color string) string {
+	// split on spaces, uppercase, match first 3 letter
+	var res [5]int
+	var result []int = res[0:0]
+	var bg bool
+
+	result = append(result, 0)
+
+	parts := strings.Fields(strings.ToUpper(color))
+	for _, part := range parts {
+		if len(part) > 3 {
+			part = part[:3]
+		}
+
+		switch part {
+		case "BLA":
+			if bg {
+				result = append(result, 40)
+			} else {
+				result = append(result, 30)
+			}
+
+		case "RED":
+			if bg {
+				result = append(result, 41)
+			} else {
+				result = append(result, 31)
+			}
+
+		case "GRE":
+			if bg {
+				result = append(result, 42)
+			} else {
+				result = append(result, 32)
+			}
+
+		case "BRO", "YEL":
+			if bg {
+				result = append(result, 43)
+			} else {
+				result = append(result, 33)
+			}
+
+		case "BLU":
+			if bg {
+				result = append(result, 44)
+			} else {
+				result = append(result, 34)
+			}
+
+		case "MAG":
+			if bg {
+				result = append(result, 45)
+			} else {
+				result = append(result, 35)
+			}
+
+		case "CYA":
+			if bg {
+				result = append(result, 46)
+			} else {
+				result = append(result, 36)
+			}
+
+		case "WHI":
+			if bg {
+				result = append(result, 47)
+			} else {
+				result = append(result, 37)
+			}
+
+		case "BOL", "BRI":
+			result = append(result, 1)
+
+		case "ON":
+			bg = true
+
+		case "BLI":
+			result = append(result, 5)
+
+		// Invert is't well supported in terminals
+		// case "INV":
+		//	result = append(result, 7)
+
+		default:
+			log.Panicf("ColorText Unknown: [%s] in %s\n", part, color)
+		}
+
+	}
+	return ColorS(result)
+}

door/color_test.go

@@ -13,7 +13,7 @@ func TestColor(t *testing.T) {
 
 	for text, code := range ColorMap {
 		ct := Color(code)
-		if text != ct {
+		if text != string(ct) {
 			t.Errorf("Color: Expected %#v (%#v), got %#v", text, code, ct)
 		}
 	}
@@ -42,8 +42,8 @@ func TestColorText(t *testing.T) {
 	}
 
 	for text, code := range ColorMap {
-		ct := ColorText(text)
-		cc := Color(code)
+		ct := string(ColorText(text))
+		cc := string(Color(code))
 		if ct != cc {
 			t.Errorf("ColorText: Expected %#v (%#v), got %#v", cc, code, ct)
 		}

door/input_windows.go

@@ -27,10 +27,6 @@ func extended_output(buffer []rune) string {
 	return output
 }
 
-func RuneToInt8(r rune) int8 {
-	return int8(r)
-}
-
 func Reader(d *Door) {
 	// handle syscall.Handle, readerChannel *chan byte
 	C.init_wsa()
@@ -44,9 +40,9 @@ func Reader(d *Door) {
 
 	defer func() {
 		log.Printf("~Reader")
-		if d.ReaderCanClose {
-			d.wg.Done()
-		}
+		// if d.ReaderCanClose {
+		d.wg.Done()
+		// }
 	}()
 
 	defer func() {

door/line.go

@@ -81,7 +81,7 @@ Line of text to display.
 type Line struct {
 	Text         *bytes.Buffer // Text to be displayed
 	update       *bytes.Buffer // Buffer for updates
-	DefaultColor string        // Default Color to use
+	DefaultColor []byte        // Default Color to use
 	RenderF      ColorRender   // Render function (displays string with colors)
 	render       *bytes.Buffer // Buffer for rendering
 	UpdateF      Updater       // Update function updates the text
@@ -189,8 +189,8 @@ func (l *Line) Output() []byte {
 
 	if l.RenderF == nil {
 		l.render.Reset()
-		if l.DefaultColor != "" {
-			l.render.WriteString(l.DefaultColor)
+		if len(l.DefaultColor) != 0 {
+			l.render.Write(l.DefaultColor)
 		}
 		l.render.Write(l.Text.Bytes())
 		return l.render.Bytes()
@@ -267,19 +267,19 @@ func RenderBlueYellow(output *bytes.Buffer, text []byte) {
 	// var output = RenderPool.Get().(*strings.Builder)
 	// output.Reset()
 
-	var blue string = ColorText("BOLD BLUE")
-	var yellow string = ColorText("BOLD YELLOW")
-	var last *string
+	var blue []byte = ColorText("BOLD BLUE")
+	var yellow []byte = ColorText("BOLD YELLOW")
+	var last *[]byte
 
 	for _, letter := range text {
 		if unicode.IsUpper(rune(letter)) {
 			if last != &blue {
-				output.WriteString(blue)
+				output.Write(blue)
 				last = &blue
 			}
 		} else {
 			if last != &yellow {
-				output.WriteString(yellow)
+				output.Write(yellow)
 				last = &yellow
 			}
 		}

door/line_test.go

@@ -35,8 +35,8 @@ func TestLine(t *testing.T) {
 	// line.DefaultColor = ""
 	line.RenderF = RenderBlueYellow
 	output = string(line.Output())
-	var blue string = ColorText("BOLD BLUE")
-	var yellow string = ColorText("BOLD YELLOW")
+	var blue string = string(ColorText("BOLD BLUE"))
+	var yellow string = string(ColorText("BOLD YELLOW"))
 
 	expect = blue + "T" + yellow + "est " + blue + "M" + yellow + "e "
 	if output != expect {
@@ -289,31 +289,31 @@ func BenchmarkLineRenderUpdate(b *testing.B) {
 
 	var render = func(output *bytes.Buffer, text []byte) {
 		output.Reset()
-		var last *string
+		var last *[]byte
 		// var r Render = Render{Line: text}
 
 		for _, letter := range text {
 			if unicode.IsUpper(rune(letter)) {
 				if last != &Up {
-					output.WriteString(Up)
+					output.Write(Up)
 					last = &Up
 				}
 				// r.Append(Up, 1)
 			} else if unicode.IsLower(rune(letter)) {
 				if last != &Down {
-					output.WriteString(Down)
+					output.Write(Down)
 					last = &Down
 				}
 				// r.Append(Down, 1)
 			} else if unicode.IsDigit(rune(letter)) {
 				if last != &Num {
-					output.WriteString(Num)
+					output.Write(Num)
 					last = &Num
 				}
 				// r.Append(Num, 1)
 			} else {
 				if last != &Sym {
-					output.WriteString(Sym)
+					output.Write(Sym)
 					last = &Sym
 				}
 				//r.Append(Sym, 1)
@@ -351,33 +351,35 @@ func BenchmarkLineRenderUpdateUnicode(b *testing.B) {
 	var Num = ColorText("BRI GREEN")
 	var Sym = ColorText("CYAN")
 
+	// var unicodeBuff *bytes.Buffer = &bytes.Buffer{}
+
 	var render = func(output *bytes.Buffer, text []byte) {
 		output.Reset()
-		var last *string
+		var last *[]byte
 		// var r Render = Render{Line: text}
 
 		for _, letter := range text {
 			if unicode.IsUpper(rune(letter)) {
 				if last != &Up {
-					output.WriteString(Up)
+					output.Write(Up)
 					last = &Up
 				}
 				// r.Append(Up, 1)
 			} else if unicode.IsLower(rune(letter)) {
 				if last != &Down {
-					output.WriteString(Down)
+					output.Write(Down)
 					last = &Down
 				}
 				// r.Append(Down, 1)
 			} else if unicode.IsDigit(rune(letter)) {
 				if last != &Num {
-					output.WriteString(Num)
+					output.Write(Num)
 					last = &Num
 				}
 				// r.Append(Num, 1)
 			} else {
 				if last != &Sym {
-					output.WriteString(Sym)
+					output.Write(Sym)
 					last = &Sym
 				}
 				//r.Append(Sym, 1)

door/menu.go

@@ -24,23 +24,23 @@ type Menu struct {
 	Panel
 }
 
-func MakeMenuRender(bracketColor, optionColor, upperColor, lowerColor string) ColorRender {
+func MakeMenuRender(bracketColor, optionColor, upperColor, lowerColor []byte) ColorRender {
 	f := func(output *bytes.Buffer, text []byte) {
 		output.Reset()
-		var lastColor *string
+		var lastColor *[]byte
 		option := true
 		for _, c := range text {
 			if option {
 				if c == '[' || c == ']' {
 					if lastColor != &bracketColor {
-						output.WriteString(bracketColor)
+						output.Write(bracketColor)
 						lastColor = &bracketColor
 					}
 					output.WriteByte(c)
 					option = (c == '[')
 				} else {
 					if lastColor != &optionColor {
-						output.WriteString(optionColor)
+						output.Write(optionColor)
 						lastColor = &optionColor
 					}
 					output.WriteByte(c)
@@ -48,13 +48,13 @@ func MakeMenuRender(bracketColor, optionColor, upperColor, lowerColor string) Co
 			} else {
 				if unicode.IsUpper(rune(c)) {
 					if lastColor != &upperColor {
-						output.WriteString(upperColor)
+						output.Write(upperColor)
 						lastColor = &upperColor
 					}
 					output.WriteByte(c)
 				} else {
 					if lastColor != &lowerColor {
-						output.WriteString(lowerColor)
+						output.Write(lowerColor)
 						lastColor = &lowerColor
 					}
 					output.WriteByte(c)
@@ -126,7 +126,7 @@ func (m *Menu) Choose(d *Door) int {
 			if len(changed) == 0 {
 				var output bytes.Buffer
 				output.Write(m.Output())
-				output.WriteString(blank)
+				output.Write(blank)
 				d.Write(output.Bytes()) //m.Output() + blank)
 			} else {
 				// Update just the lines that have changed
@@ -135,7 +135,7 @@ func (m *Menu) Choose(d *Door) int {
 					output.Write(m.UpdateLine(line))
 				}
 				output.Write(m.GotoEnd())
-				output.WriteString(blank)
+				output.Write(blank)
 				d.Write(output.Bytes())
 			}
 			if m.Activated != nil {
@@ -143,7 +143,7 @@ func (m *Menu) Choose(d *Door) int {
 				// Reposition to the end of the menu
 				var output bytes.Buffer
 				output.Write(m.GotoEnd())
-				output.WriteString(blank)
+				output.Write(blank)
 				d.Write(output.Bytes())
 			}
 		}

door/menu_test.go

@@ -13,10 +13,10 @@ import (
 )
 
 func TestMenuRender(t *testing.T) {
-	var bracket string = ColorText("BLUE")
-	var option string = ColorText("BRI GREEN")
-	var upper string = ColorText("CYAN")
-	var lower string = ColorText("MAGENTA")
+	var bracket []byte = ColorText("BLUE")
+	var option []byte = ColorText("BRI GREEN")
+	var upper []byte = ColorText("CYAN")
+	var lower []byte = ColorText("MAGENTA")
 
 	var render ColorRender = MakeMenuRender(bracket, option, upper, lower)
 
@@ -26,8 +26,8 @@ func TestMenuRender(t *testing.T) {
 	// var got string = string(render(buff, []byte(input)))
 	render(buff, []byte(input))
 	var got string = buff.String()
-	var expected string = bracket + "[" + option + "X" + bracket + "]"
-	expected += lower + " " + upper + "BUGZ" + lower + " test"
+	var expected string = string(bracket) + "[" + string(option) + "X" + string(bracket) + "]"
+	expected += string(lower) + " " + string(upper) + "BUGZ" + string(lower) + " test"
 
 	if got != expected {
 		t.Errorf("MenuRender expected %#v, got %#v", expected, got)
@@ -157,12 +157,12 @@ func TestMenuConnection(t *testing.T) {
 	// Use simple renders for testing
 	m.SelectedR = func(output *bytes.Buffer, text []byte) {
 		output.Reset()
-		output.WriteString(ColorText("BLACK ON WHITE"))
+		output.Write(ColorText("BLACK ON WHITE"))
 		output.Write(text)
 	}
 	m.UnselectedR = func(output *bytes.Buffer, text []byte) {
 		output.Reset()
-		output.WriteString(ColorText("WHI ON BLA"))
+		output.Write(ColorText("WHI ON BLA"))
 		output.Write(text)
 	}
 

door/nomoresecrets.go

@@ -20,7 +20,7 @@ type NoMoreSecretsConfig struct {
 	Jumble_Loop_Speed int    // in ms
 	Reveal_Loop_Speed int    // in ms
 	Max_Time          int    // Max value before reveal (per character)
-	Color             string // Color to use before reveal
+	Color             []byte // Color to use before reveal
 }
 
 // The default configuration for NoMoreSecrets
@@ -145,13 +145,13 @@ func NoMoreSecrets(output []byte, Door *Door, config *NoMoreSecretsConfig) {
 		var charpos []int = make([]int, 0, len(original))  // where characters are we can change
 		var chartime []int = make([]int, 0, len(original)) // character time / reveal timeout
 		var revealpos map[int]int                          // workpos to original position
-		var colormap map[int]string                        // index to color end position (workpos)
+		var colormap map[int][]byte                        // index to color end position (workpos)
 		var coloridx []int                                 // index of positions (map isn't ordered)
 		var lastcolor []int                                // LastColor tracking for keeping colors proper
 		var currentANSI string                             // ANSI Escape code we've extracted
 		var ANSIchar rune                                  // Last character of the ANSI Escape code
 
-		colormap = make(map[int]string)
+		colormap = make(map[int][]byte)
 		revealpos = make(map[int]int)
 		coloridx = make([]int, 0)
 
@@ -226,7 +226,7 @@ func NoMoreSecrets(output []byte, Door *Door, config *NoMoreSecretsConfig) {
 
 		var renderF func() []byte = func() []byte {
 			renderResults.Reset()
-			var lastcolor *string
+			var lastcolor *[]byte
 			var pos int = 0
 
 			for idx, char := range work {
@@ -239,12 +239,12 @@ func NoMoreSecrets(output []byte, Door *Door, config *NoMoreSecretsConfig) {
 					// This is a character
 					if chartime[pos] != 0 && char != ' ' {
 						if lastcolor != &config.Color {
-							renderResults.WriteString(config.Color)
+							renderResults.Write(config.Color)
 							lastcolor = &config.Color
 						}
 					} else {
 						// look up the color in the colormap
-						var best string
+						var best []byte
 
 						// use the coloridx, lookup in colormap
 						for _, cpos := range coloridx {
@@ -255,7 +255,7 @@ func NoMoreSecrets(output []byte, Door *Door, config *NoMoreSecretsConfig) {
 						}
 
 						if lastcolor != &best {
-							renderResults.WriteString(best)
+							renderResults.Write(best)
 							lastcolor = &best
 						}
 					}
@@ -354,14 +354,14 @@ func NoMoreSecrets(output []byte, Door *Door, config *NoMoreSecretsConfig) {
 		var charpos []int                    // where characters are we can change
 		var chartime []int                   // character time / reveal timeout
 		var revealpos map[int]int            // workpos to original position
-		var colormap map[int]string          // index to color end position (workpos)
+		var colormap map[int][]byte          // index to color end position (workpos)
 		var coloridx []int                   // index of positions (map isn't ordered)
 		var lastcolor []int                  // LastColor tracking for keeping color proper
 		var currentANSI string               // ANSI Escape code we've extracted
 		var ANSIchar byte                    // Last character of the ANSI Escape code
 
 		work = make([]byte, 0)
-		colormap = make(map[int]string)
+		colormap = make(map[int][]byte)
 		revealpos = make(map[int]int)
 		coloridx = make([]int, 0)
 
@@ -430,7 +430,7 @@ func NoMoreSecrets(output []byte, Door *Door, config *NoMoreSecretsConfig) {
 		// jumble loop
 		var renderF func() []byte = func() []byte {
 			renderResults.Reset()
-			var lastcolor *string
+			var lastcolor *[]byte
 			var pos int = 0
 
 			for idx, char := range work {
@@ -443,12 +443,12 @@ func NoMoreSecrets(output []byte, Door *Door, config *NoMoreSecretsConfig) {
 
 					if chartime[pos] != 0 && char != ' ' {
 						if lastcolor != &config.Color {
-							renderResults.WriteString(config.Color)
+							renderResults.Write(config.Color)
 							lastcolor = &config.Color
 						}
 					} else {
 						// look up the color in the colormap
-						var best string
+						var best []byte
 
 						for _, cpos := range coloridx {
 							if cpos > idx {
@@ -458,7 +458,7 @@ func NoMoreSecrets(output []byte, Door *Door, config *NoMoreSecretsConfig) {
 						}
 
 						if lastcolor != &best {
-							renderResults.WriteString(best)
+							renderResults.Write(best)
 							lastcolor = &best
 						}
 					}

door/nomoresecrets_test.go

@@ -20,9 +20,14 @@ func TestRandom(t *testing.T) {
 
 }
 
+// I currently can't test NMS.  It's monolithic.
+// Need to break it up so I can test it!
+
+/*
 func TestNoMoreSecrets(t *testing.T) {
 
 }
+*/
 
 // Benchmark / profiling
 

door/panel.go

@@ -21,10 +21,10 @@ type Panel struct {
 	Y           int
 	Width       int
 	Style       BorderStyle
-	BorderColor string
+	BorderColor []byte
 	Lines       []*Line
 	Title       string
-	TitleColor  string
+	TitleColor  []byte
 	TitleOffset int
 	output      *bytes.Buffer
 }
@@ -156,7 +156,7 @@ func (p *Panel) Output() []byte {
 		// Top line / border
 		// p.output.Write(Goto(p.X, row))
 		GotoW(p.X, row, p.output)
-		p.output.WriteString(p.BorderColor)
+		p.output.Write(p.BorderColor)
 		p.output.WriteString(box_style.Top_Left)
 		if p.Title != "" {
 			if p.TitleOffset+len(p.Title) > p.Width {
@@ -164,7 +164,9 @@ func (p *Panel) Output() []byte {
 					p.Width, len(p.Title), p.TitleOffset, p.TitleOffset+len(p.Title))
 			}
 			p.output.WriteString(strings.Repeat(box_style.Top, p.TitleOffset))
-			p.output.WriteString(p.TitleColor + p.Title + p.BorderColor)
+			p.output.Write(p.TitleColor)
+			p.output.WriteString(p.Title)
+			p.output.Write(p.BorderColor)
 		}
 		p.output.WriteString(strings.Repeat(box_style.Top, p.Width-(p.TitleOffset+len(p.Title))) + box_style.Top_Right)
 		row++
@@ -182,21 +184,23 @@ func (p *Panel) Output() []byte {
 			// This only works in non-unicode mode
 			if bytes.Compare(line.Text.Bytes()[0:len(top)], []byte(top)) == 0 {
 				// Yes, this line needs to be joined...
-				p.output.WriteString(p.BorderColor + box_style.Middle_Left)
+				p.output.Write(p.BorderColor)
+				p.output.WriteString(box_style.Middle_Left)
 				p.output.Write(line.Output())
-				p.output.WriteString(p.BorderColor + box_style.Middle_Right)
+				p.output.Write(p.BorderColor)
+				p.output.WriteString(box_style.Middle_Right)
 				joined = true
 			}
 		}
 
 		if !joined {
 			if p.HasBorder() {
-				p.output.WriteString(p.BorderColor)
+				p.output.Write(p.BorderColor)
 				p.output.WriteString(box_style.Side)
 			}
 			p.output.Write(line.Output())
 			if style > 0 {
-				p.output.WriteString(p.BorderColor)
+				p.output.Write(p.BorderColor)
 				p.output.WriteString(box_style.Side)
 			}
 		}
@@ -208,7 +212,7 @@ func (p *Panel) Output() []byte {
 		// Bottom / border
 		// p.output.Write(Goto(p.X, row))
 		GotoW(p.X, row, p.output)
-		p.output.WriteString(p.BorderColor)
+		p.output.Write(p.BorderColor)
 		p.output.WriteString(box_style.Bottom_Left)
 		p.output.WriteString(strings.Repeat(box_style.Top, p.Width) + box_style.Bottom_Right)
 	}

door/spinrite.go

@@ -7,7 +7,7 @@ import (
 type SpinRite struct {
 	Width     uint8         // Width of the animation (must be odd)
 	Length    uint8         // Width of the worm (must be odd)
-	Color     string        // Color (default CYAN ON BLUE)
+	Color     []byte        // Color (default CYAN ON BLUE)
 	OutputB   []byte        // Output CP437/bytes (Width)
 	OutputR   []rune        // Output Unicode (Width)
 	Buffer    []uint8       // Output calculate buffer (Width)
@@ -47,8 +47,8 @@ We default to ∞
 4 = Full Block
 */
 
-func SpinRiteInit(width uint8, length uint8, color string) SpinRite {
-	if color == "" {
+func SpinRiteInit(width uint8, length uint8, color []byte) SpinRite {
+	if len(color) == 0 {
 		color = ColorText("CYAN ON BLUE")
 	}
 	var center uint8 = ((width - 1) / 2)
@@ -179,7 +179,7 @@ func (sr *SpinRite) Output() []byte {
 	// var result string
 	sr.output.Reset()
 	// sr.Result.Reset()
-	sr.output.WriteString(sr.Color)
+	sr.output.Write(sr.Color)
 
 	sr.Calculate()
 	if Unicode {
@@ -208,7 +208,7 @@ type SpinRiteMsg struct {
 	Next     bool
 }
 
-func SpinRiteMsgInit(width uint8, length uint8, color string, messages []string) SpinRiteMsg {
+func SpinRiteMsgInit(width uint8, length uint8, color []byte, messages []string) SpinRiteMsg {
 	var result SpinRiteMsg = SpinRiteMsg{SpinRite: SpinRiteInit(width, length, color)}
 	if Unicode {
 		result.Runes[1] = result.Runes[0]
@@ -295,7 +295,7 @@ func (sr *SpinRiteMsg) Output() []byte {
 		}
 	*/
 
-	sr.output.WriteString(sr.Color)
+	sr.output.Write(sr.Color)
 
 	if Unicode {
 		for _, r := range sr.OutputR {

door/wopr.go

@@ -54,8 +54,8 @@ func (w *WOPR) Clear() []byte {
 // Initialize, Set X, Y on Panels, Animate()
 
 // Initialize, and create panels
-func (w *WOPR) Init(elapsed time.Time, remaining time.Time, color string) {
-	if color == "" {
+func (w *WOPR) Init(elapsed time.Time, remaining time.Time, color []byte) {
+	if len(color) == 0 {
 		color = ColorText("BLACK ON CYAN")
 	}
 	w.output = &bytes.Buffer{}

door/wopr_test.go

@@ -9,7 +9,7 @@ func BenchmarkWOPR(b *testing.B) {
 	Unicode = false
 
 	var wopr WOPR
-	wopr.Init(time.Now(), time.Now().Add(time.Hour), "")
+	wopr.Init(time.Now(), time.Now().Add(time.Hour), []byte{})
 	wopr.ElapsedPanel.X = 1
 	wopr.ElapsedPanel.Y = 2
 	wopr.RemainingPanel.X = 1

door/write_windows.go

@@ -1,12 +1,57 @@
 package door
 
 import (
-	"fmt"
-	"log"
-	"strings"
 	"syscall"
 )
 
+// OS Specific Writer
+// This assumes that d.writerMutex is locked.
+
+type OSWriter struct {
+	Handle syscall.Handle
+	BaseWriter
+}
+
+func (ow *OSWriter) Init(d *Door) {
+	ow.Closed = false
+	ow.Handle = syscall.Handle(d.WRITEFD)
+	ow.ansiCode = make([]byte, 0, 32)
+}
+
+// The low-level writer function
+func (ow *OSWriter) OSWrite(buffer []byte) (int, error) {
+	var l uint32 = uint32(len(buffer))
+	WSA_Buffer := syscall.WSABuf{Len: uint32(l), Buf: &buffer[0]}
+	var UitnZero_1 uint32 = uint32(0)
+	var DataWrite uint32 = uint32(0)
+	var err error
+	err = syscall.WSASend(ow.Handle, &WSA_Buffer, 1, &DataWrite, UitnZero_1, nil, nil)
+	if (err != nil) || (l != DataWrite) {
+		if !ow.Closed {
+			ow.Closed = true
+			// Don't need to close reader, it will close itself.
+			// It knows when the caller is gone before the writer ever will!
+		}
+	}
+	return int(DataWrite), err
+}
+
+func (ow *OSWriter) Write(buffer []byte) (int, error) {
+	if ow.Closed {
+		return 0, ErrDisconnected
+	}
+	return ow.OSWrite(buffer)
+}
+
+func (ow *OSWriter) Stop() {
+	ow.Closed = true
+}
+
+func (ow *OSWriter) IsClosed() bool {
+	return ow.Closed
+}
+
+/*
 func Writer(d *Door) {
 	var handle syscall.Handle = syscall.Handle(d.WRITEFD) // Config.Comm_handle)
 	// handle syscall.Handle, writerChannel *chan string
@@ -15,36 +60,6 @@ func Writer(d *Door) {
 	var Closed bool = false
 
 	for output := range d.writerChannel {
-		// for {
-		/*
-			select {
-			case <-d.closeChannel:
-				close(d.writerChannel)
-				log.Println("~Writer")
-				return
-			default:
-			}
-		*/
-		// select {
-		/*
-			case <-d.closeChannel:
-				close(d.writerChannel)
-				log.Println("~Writer")
-				return
-		*/
-		/*
-			case output, ok := <-d.writerChannel:
-				if !ok {
-					log.Println("closeChannel")
-					d.writerMutex.Lock()
-					if !d.WriterClosed {
-						d.WriterClosed = true
-					}
-					d.writerMutex.Unlock()
-					log.Println("~Writer")
-					return
-				} else {
-		*/
 		if output == "" {
 			Closed = true
 			continue
@@ -85,14 +100,6 @@ func Writer(d *Door) {
 				d.WriterClosed = true
 			}
 			d.writerMutex.Unlock()
-			/*
-				if !d.Disconnect() {
-					atomic.StoreInt32(&d.Disconnected, 1)
-					close(d.writerChannel)
-				}
-				log.Println("~Writer")
-				return
-			*/
 			// }
 			// }
 		}
@@ -107,22 +114,5 @@ func Writer(d *Door) {
 	log.Println("~Writer")
 	// return
 
-	/*
-		for output := range *writerChannel {
-			l := uint32(len(output))
-			buffer := []byte(output)
-			WSA_Buffer := syscall.WSABuf{Len: uint32(l), Buf: &buffer[0]}
-			UitnZero_1 := uint32(0)
-			DataWrite := uint32(0)
-			err := syscall.WSASend(handle, &WSA_Buffer, 1, &DataWrite, UitnZero_1, nil, nil)
-			if err != nil {
-				fmt.Printf("write: %d bytes, error: %#v\n", DataWrite, err)
-			}
-
-			if (err != nil) || (l != DataWrite) {
-				close(*writerChannel)
-				break
-			}
-		}
-	*/
 }
+*/