Merge pull request #6 from superhawk610/fix/handle-boundary-characters

CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+## Version 0.0.2: Fix verb token leading character parsing
+
+This version addresses a bug with custom format strings that include a verb token preceded
+by a non-whitespace character, such as `(:bar)`.
+
+## Version 0.0.1: Initial Release
+
+This version released alongside [superhawk610/terminal](https://github.com/superhawk610/terminal).

README.md

@@ -192,6 +192,10 @@ Debugging crowded layouts can be difficult, so this helper swaps each bar compon
  <barToken p={4} t={10}> <percentToken "40.0%"> <customVerbToken verb="hello" value="Hello!">
 ```
 
+## Changelog
+
+See [CHANGELOG.md](CHANGELOG.md).
+
 ## License
 
 Copyright &copy; 2019 Aaron Ross, all rights reserved. View the ISC license [here](LICENSE).

bar.go

@@ -72,7 +72,7 @@ func New(t int) *Bar {
 		formatString: defaultFormat,
 		format:       tokenize(defaultFormat, []string{}),
 		callback:     noop,
-		output:       &stdout{},
+		output:       initializeStdout(),
 	}
 }
 

opts.go

@@ -40,7 +40,7 @@ func NewWithFormat(t int, f string) *Bar {
 		formatString: f,
 		format:       tokenize(f, nil),
 		callback:     noop,
-		output:       &stdout{},
+		output:       initializeStdout(),
 	}
 }
 
@@ -55,7 +55,7 @@ func NewWithOpts(opts ...func(o *barOpts)) *Bar {
 		end:          ")",
 		formatString: defaultFormat,
 		callback:     noop,
-		output:       &stdout{},
+		output:       initializeStdout(),
 	}
 
 	for _, aug := range opts {

output.go

@@ -12,15 +12,21 @@ type Output interface {
 	Printf(format string, vals ...interface{})
 }
 
-type stdout struct{}
+type stdout struct {
+	terminal terminal.Terminal
+}
+
+func initializeStdout() *stdout {
+	return &stdout{}
+}
 
 // ClearLine clears the current output line and returns the cursor
 // to the first index
-func (stdout) ClearLine() {
-	terminal.ClearLine()
+func (s *stdout) ClearLine() {
+	s.terminal.ClearLine()
 }
 
 // Printf accepts a format string and any number of input values
-func (stdout) Printf(format string, vals ...interface{}) {
-	terminal.Overwritef(format, vals...)
+func (s *stdout) Printf(format string, vals ...interface{}) {
+	s.terminal.Overwritef(format, vals...)
 }

tokens.go

@@ -33,6 +33,8 @@ type literalToken struct {
 	content string
 }
 
+// tokenize takes a format string and a slice of custom verbs (if any)
+// and returns a slice of tokens that represent the format string.
 func tokenize(f string, customVerbs []string) tokens {
 	var t tokens
 
@@ -53,6 +55,9 @@ func tokenize(f string, customVerbs []string) tokens {
 	}
 }
 
+// nextToken consumes characters from the input until a complete token is
+// found and returned. If an error is encountered, it is returned alongside
+// a `nil` token.
 func (f *tokenFormat) nextToken(customVerbs []string) (token, error) {
 	for {
 		r, _, err := f.stream.ReadRune()
@@ -71,6 +76,9 @@ func (f *tokenFormat) nextToken(customVerbs []string) (token, error) {
 	}
 }
 
+// readAction will consume characters from the input until it finds a valid
+// action verb, returning the corresponding verb token. If no valid verb is
+// found when the input runs out, a literal token will be returned instead.
 func (f *tokenFormat) readAction(customVerbs []string) (token, error) {
 	var verb bytes.Buffer
 
@@ -97,36 +105,42 @@ func (f *tokenFormat) readAction(customVerbs []string) (token, error) {
 	}
 }
 
+// readLiteral will consume characters from the input until it encounters
+// a separator character (see `readSeparator`), returning a literal token
+// containing the characters it consumed.
 func (f *tokenFormat) readLiteral(prefix rune) (token, error) {
 	var value bytes.Buffer
 
 	value.Write([]byte(string([]rune{prefix})))
 
 	for {
+		if f.readSeparator() {
+			return literalToken{value.String()}, nil
+		}
+
 		r, _, err := f.stream.ReadRune()
 
 		if err != nil {
 			return nil, err
 		}
 
 		value.Write([]byte(string([]rune{r})))
-
-		if f.readSeparator() {
-			return literalToken{value.String()}, nil
-		}
 	}
 }
 
+// readSeparator looks for a separator character (one of ` `, `:`, or *EOF*), returning
+// `true` if one is found and `false` otherwise. It does not consume any characters
+// from the input.
 func (f *tokenFormat) readSeparator() bool {
 	p, err := f.stream.Peek(1)
-	if err != nil || p[0] == ' ' || p[0] == ':' {
+	if err != nil || p[0] == byte(' ') || p[0] == byte(':') {
 		return true
 	}
 	return false
 }
 
 // tokenFromString will return the token parsed from s, as well as a
-// bool determining whether a valid token was found
+// bool determining whether a valid token was found.
 func tokenFromString(s string, customVerbs []string) (token, bool) {
 	// check for standard verbs
 	switch s {
@@ -150,6 +164,10 @@ func tokenFromString(s string, customVerbs []string) (token, bool) {
 	return nil, false
 }
 
+//
+// print implementations
+//
+
 func (t spaceToken) print(_ *Bar) string {
 	return " "
 }
@@ -197,6 +215,10 @@ func (t literalToken) print(_ *Bar) string {
 	return t.content
 }
 
+//
+// debug implementations
+//
+
 func (t spaceToken) debug(b *Bar) string {
 	return " "
 }

tokens_test.go

@@ -28,7 +28,31 @@ func TestTokenize(t *testing.T) {
 		got := tokenize(testCase.formatString, nil)
 		if !reflect.DeepEqual(got, testCase.expected) {
 			t.Errorf(
-				"[%d] tokenize(%#v, nil) = %#v; want %#v",
+				"[%d] tokenize(%#v, nil)\n\n  got %#v\n  want %#v",
+				i,
+				testCase.formatString,
+				got,
+				testCase.expected,
+			)
+		}
+	}
+}
+
+func TestTokenizeWithBoundaryCharacters(t *testing.T) {
+	var testCases = []struct {
+		formatString string
+		expected     tokens
+	}{
+		{"(:bar", tokens{literalToken{"("}, barToken{}}},
+		{"(:bar)", tokens{literalToken{"("}, barToken{}, literalToken{")"}}},
+		{":bar (:eta remaining)", tokens{barToken{}, spaceToken{}, literalToken{"("}, etaToken{}, spaceToken{}, literalToken{"remaining)"}}},
+	}
+
+	for i, testCase := range testCases {
+		got := tokenize(testCase.formatString, nil)
+		if !reflect.DeepEqual(got, testCase.expected) {
+			t.Errorf(
+				"[%d] tokenize(%#v, nil)\n\n  got %#v\n  want %#v",
 				i,
 				testCase.formatString,
 				got,
@@ -53,7 +77,7 @@ func TestTokenizeWithCustomVerbs(t *testing.T) {
 		got := tokenize(testCase.formatString, testCase.customVerbs)
 		if !reflect.DeepEqual(got, testCase.expected) {
 			t.Errorf(
-				"[%d] tokenize(%#v, %#v) = %#v; want %#v",
+				"[%d] tokenize(%#v, %#v)\n\n  got %#v\n  want %#v",
 				i,
 				testCase.formatString,
 				testCase.customVerbs,