Alias set functions, bug fixes, and more

# Changes

* Added a RWMutex for when updating color aliases or parsing strings
* Fixed [bug](#10) and included tests for it.
* New functions `SetAlias()` and `SetAliases()` to set/override specific aliases
* `LoadAliases()` now has a variadic argument, allowing multiple files to be loaded in sequence.

Author: Volte6

ansiproperties.go

@@ -4,6 +4,7 @@ import (
 	"regexp"
 	"strconv"
 	"strings"
+	"sync"
 )
 
 type ColorMode uint8
@@ -89,6 +90,8 @@ var (
 	}
 
 	colorMode ColorMode = Color8
+
+	rwLock = sync.RWMutex{}
 )
 
 type ansiProperties struct {

ansitags.go

@@ -3,6 +3,7 @@ package ansitags
 import (
 	"bufio"
 	"bytes"
+	"fmt"
 	"io"
 	"os"
 	"strconv"
@@ -15,18 +16,19 @@ type parseMode uint8
 type ParseBehavior uint8
 
 const (
-	tagStart byte = '<'
-	tagEnd   byte = '>'
-
-	tagOpen  string = "ansi"  // will be wrapped in tagStart and tagEnd
-	tagClose string = "/ansi" // will be wrapped in tagStart and tagEnd
-
 	parseModeNone     parseMode = 0
 	parseModeMatching parseMode = 1
 
 	StripTags  ParseBehavior = iota // remove all valid ansitags
 	Monochrome                      // ignore any color changing properties
+)
 
+var (
+	tagStart byte = '<'
+	tagEnd   byte = '>'
+
+	tagOpen  string = "ansi"  // will be wrapped in tagStart and tagEnd
+	tagClose string = "/ansi" // will be wrapped in tagStart and tagEnd
 )
 
 func Parse(str string, behaviors ...ParseBehavior) string {
@@ -42,6 +44,9 @@ func Parse(str string, behaviors ...ParseBehavior) string {
 
 func ParseStreaming(inbound *bufio.Reader, outbound *bufio.Writer, behaviors ...ParseBehavior) {
 
+	rwLock.RLock()
+	defer rwLock.RUnlock()
+
 	var stripAllTags bool = false
 	var stripAllColor bool = false
 
@@ -64,13 +69,13 @@ func ParseStreaming(inbound *bufio.Reader, outbound *bufio.Writer, behaviors ...
 
 	for {
 		input, err := inbound.ReadByte()
+
 		if err != nil && err == io.EOF {
 			break
 		}
 
 		// If not currently in any modes, look for any tags
 		if mode == parseModeNone {
-
 			if input != tagStart {
 				// If it's not an opening tag and we're looking for it (zero position)
 				// Write it to the output string and go to next
@@ -89,6 +94,7 @@ func ParseStreaming(inbound *bufio.Reader, outbound *bufio.Writer, behaviors ...
 			closeMatch, closeMatchDone := closeMatcher.MatchNext(input)
 
 			if openMatch {
+
 				currentTagBuilder.WriteByte(input)
 
 				if !openMatchDone {
@@ -161,6 +167,10 @@ func ParseStreaming(inbound *bufio.Reader, outbound *bufio.Writer, behaviors ...
 			// No close match was found. Reset the matcher
 			closeMatcher.Reset()
 
+			if closeMatchDone && openMatchDone {
+				currentTagBuilder.WriteByte(input)
+			}
+
 			// open and close both failed to match. Reset everything
 			mode = parseModeNone
 
@@ -188,57 +198,115 @@ func ParseStreaming(inbound *bufio.Reader, outbound *bufio.Writer, behaviors ...
 	outbound.Flush()
 }
 
-func LoadAliases(yamlFilePath string) error {
+func SetAlias(alias string, value int, aliasGroup ...string) error {
 
-	data := make(map[string]map[string]string, 100)
+	rwLock.Lock()
+	defer rwLock.Unlock()
+
+	if value < 0 || value > 255 {
+		return fmt.Errorf(`value "%d" out of allowable range for alias "%s"`, value, alias)
+	}
 
-	if yfile, err := os.ReadFile(yamlFilePath); err != nil {
-		return err
+	g := `color256`
+	if len(aliasGroup) > 0 {
+		if aliasGroup[0] == `color8` {
+			g = `color8`
+		}
+	}
+
+	if g == "color8" {
+		colorMap8[alias] = value
 	} else {
-		if err := yaml.Unmarshal(yfile, &data); err != nil {
-			return err
+		colorMap256[alias] = value
+	}
+
+	return nil
+}
+
+func SetAliases(aliases map[string]int, aliasGroup ...string) error {
+
+	rwLock.Lock()
+	defer rwLock.Unlock()
+
+	g := `color256`
+	if len(aliasGroup) > 0 {
+		if aliasGroup[0] == `color8` {
+			g = `color8`
 		}
 	}
 
-	for aliasGroup, aliases := range data {
-
-		if aliasGroup == "color8" {
-			for alias, real := range aliases {
-				// try mapping to an existing color alias
-				if val, ok := colorMap8[real]; ok {
-					colorMap8[alias] = val
-				} else {
-					// allow a numeric mapping
-					if numVal, err := strconv.Atoi(real); err == nil {
-						colorMap8[alias] = numVal
+	for alias, value := range aliases {
+		if value < 0 || value > 255 {
+			return fmt.Errorf(`value "%d" out of allowable range for alias "%s"`, value, alias)
+		}
+
+		if g == "color8" {
+			colorMap8[alias] = value
+		} else {
+			colorMap256[alias] = value
+		}
+	}
+
+	return nil
+}
+
+func LoadAliases(yamlFilePaths ...string) error {
+
+	rwLock.Lock()
+	defer rwLock.Unlock()
+
+	data := make(map[string]map[string]string, 100)
+
+	for _, yamlFilePath := range yamlFilePaths {
+
+		if yfile, err := os.ReadFile(yamlFilePath); err != nil {
+			return err
+		} else {
+			if err := yaml.Unmarshal(yfile, &data); err != nil {
+				return err
+			}
+		}
+
+		for aliasGroup, aliases := range data {
+
+			if aliasGroup == "color8" {
+				for alias, real := range aliases {
+					// try mapping to an existing color alias
+					if val, ok := colorMap8[real]; ok {
+						colorMap8[alias] = val
+					} else {
+						// allow a numeric mapping
+						if numVal, err := strconv.Atoi(real); err == nil {
+							colorMap8[alias] = numVal
+						}
 					}
 				}
 			}
-		}
 
-		if aliasGroup == "color256" {
-			for alias, real := range aliases {
-				// try mapping to an existing color alias
-				if val, ok := colorMap256[real]; ok {
-					colorMap256[alias] = val
-				} else {
-					// allow a numeric mapping
-					if numVal, err := strconv.Atoi(real); err == nil {
-						colorMap256[alias] = numVal
+			if aliasGroup == "color256" {
+				for alias, real := range aliases {
+					// try mapping to an existing color alias
+					if val, ok := colorMap256[real]; ok {
+						colorMap256[alias] = val
+					} else {
+						// allow a numeric mapping
+						if numVal, err := strconv.Atoi(real); err == nil {
+							colorMap256[alias] = numVal
+						}
 					}
 				}
 			}
-		}
 
-		if aliasGroup == "position" {
-			for alias, real := range aliases {
-				posArr := strings.Split(real, ",")
-				if len(posArr) == 2 {
-					positionMap[alias] = posArr
+			if aliasGroup == "position" {
+				for alias, real := range aliases {
+					posArr := strings.Split(real, ",")
+					if len(posArr) == 2 {
+						positionMap[alias] = posArr
+					}
 				}
 			}
-		}
 
+		}
 	}
 
 	return nil

ansitags_test.go

@@ -16,6 +16,25 @@ type TestCase struct {
 	Expected string `yaml:"expected"`
 }
 
+func TestParseTagOpenerMismatches(t *testing.T) {
+
+	testTable := loadTestFile("testdata/ansitags_test_tag_openers.yaml")
+
+	for name, testCase := range testTable {
+
+		t.Run(name, func(t *testing.T) {
+
+			output := Parse(testCase.Input)
+			assert.Equal(t, testCase.Expected, output)
+
+			//fmt.Println(output)
+			//bytes, _ := json.Marshal(output)
+			//fmt.Println(string(bytes))
+		})
+	}
+
+}
+
 func TestParseAliases(t *testing.T) {
 
 	testTable := loadTestFile("testdata/ansitags_test_aliases.yaml")
@@ -167,6 +186,91 @@ func loadRawFile(filename string) string {
 	return string(yfile)
 }
 
+func TestSetAliasValidDefaultGroup(t *testing.T) {
+	alias := "testAlias256"
+	value := 123
+	// Ensure clean state
+	delete(colorMap256, alias)
+	// Set alias in default (color256) group
+	if err := SetAlias(alias, value); err != nil {
+		t.Fatalf("expected no error, got %v", err)
+	}
+	if got := colorMap256[alias]; got != value {
+		t.Errorf("colorMap256[%q] = %d; want %d", alias, got, value)
+	}
+}
+
+func TestSetAliasValidColor8Group(t *testing.T) {
+	alias := "testAlias8"
+	value := 45
+	delete(colorMap8, alias)
+	// Set alias in color8 group
+	if err := SetAlias(alias, value, "color8"); err != nil {
+		t.Fatalf("expected no error, got %v", err)
+	}
+	if got := colorMap8[alias]; got != value {
+		t.Errorf("colorMap8[%q] = %d; want %d", alias, got, value)
+	}
+}
+
+func TestSetAliasInvalidValue(t *testing.T) {
+	alias := "invalidAlias"
+	invalidValue := -5
+	// Expect error for out-of-range value
+	if err := SetAlias(alias, invalidValue); err == nil {
+		t.Errorf("expected error for invalid value %d, got none", invalidValue)
+	}
+}
+
+func TestSetAliasesValidDefaultGroup(t *testing.T) {
+	aliases := map[string]int{
+		"multi256_1": 200,
+		"multi256_2": 201,
+	}
+	delete(colorMap256, "multi256_1")
+	delete(colorMap256, "multi256_2")
+	// Bulk set in default (color256) group
+	if err := SetAliases(aliases); err != nil {
+		t.Fatalf("expected no error, got %v", err)
+	}
+	for alias, expected := range aliases {
+		if got := colorMap256[alias]; got != expected {
+			t.Errorf("colorMap256[%q] = %d; want %d", alias, got, expected)
+		}
+	}
+}
+
+func TestSetAliasesValidColor8Group(t *testing.T) {
+	aliases := map[string]int{
+		"multi8_1": 10,
+		"multi8_2": 20,
+	}
+	delete(colorMap8, "multi8_1")
+	delete(colorMap8, "multi8_2")
+	// Bulk set in color8 group
+	if err := SetAliases(aliases, "color8"); err != nil {
+		t.Fatalf("expected no error, got %v", err)
+	}
+	for alias, expected := range aliases {
+		if got := colorMap8[alias]; got != expected {
+			t.Errorf("colorMap8[%q] = %d; want %d", alias, got, expected)
+		}
+	}
+}
+
+func TestSetAliasesInvalidValue(t *testing.T) {
+	aliases := map[string]int{
+		"badAlias1": -1,
+		"badAlias2": 300,
+	}
+	delete(colorMap256, "badAlias1")
+	delete(colorMap256, "badAlias2")
+	// Expect error and no partial application
+	if err := SetAliases(aliases); err == nil {
+		t.Fatalf("expected error for invalid alias value, got none")
+	}
+}
+
 //
 // Benchmarks
 // cpu: Intel(R) Core(TM) i9-9880H CPU @ 2.30GHz

testdata/ansitags_test_tag_openers.yaml

@@ -0,0 +1,9 @@
+No Tag:
+    input: "This string has no ansi tags"
+    expected: "This string has no ansi tags"
+Non Tags:
+    input: "<this is just> some <text"
+    expected: "<this is just> some <text"
+Tags with Non Tags:
+    input: "<ansi fg='blue'>This is in<side of ansi tags</ansi>"
+    expected: "\x1b[34;49mThis is in<side of ansi tags\x1b[0m"