Adding number helper

Author: xibz

aws/session/internal/ini/ini.go

@@ -1,6 +1,7 @@
 package ini
 
 import (
+	"io"
 	"os"
 )
 
@@ -13,13 +14,13 @@ func OpenFile(path string) (Sections, error) {
 	}
 	defer f.Close()
 
-	return ParseFile(f)
+	return Parse(f)
 }
 
-// ParseFile will parse the given file using the shared config
+// Parse will parse the given file using the shared config
 // visitor.
-func ParseFile(f *os.File) (Sections, error) {
-	tree, err := Parse(f)
+func Parse(f io.Reader) (Sections, error) {
+	tree, err := ParseAST(f)
 	if err != nil {
 		return nil, err
 	}

aws/session/internal/ini/ini_parser.go

@@ -110,9 +110,9 @@ func (s *skipper) Continue() {
 	s.prevTok = nil
 }
 
-// Parse will parse input from an io.Reader using
+// ParseAST will parse input from an io.Reader using
 // an LL(1) parser.
-func Parse(r io.Reader) ([]AST, error) {
+func ParseAST(r io.Reader) ([]AST, error) {
 	lexer := iniLexer{}
 	tokens, err := lexer.Tokenize(r)
 	if err != nil {

aws/session/internal/ini/ini_parser_test.go

@@ -232,7 +232,7 @@ region = us-west-2
 	}
 
 	for i, c := range cases {
-		stack, err := Parse(c.r)
+		stack, err := ParseAST(c.r)
 
 		if e, a := c.expectedError, err != nil; e != a {
 			t.Errorf("%d: expected %t, but received %t with error %v", i+1, e, a, err)

aws/session/internal/ini/literal_tokens.go

@@ -26,62 +26,50 @@ func isBoolValue(b []byte) bool {
 	return false
 }
 
+// isNumberValue will return whether not the leading characters in
+// a byte slice is a number. A number is delimited by whitespace or
+// the newline token.
+//
+// A number is defined to be in a binary, octal, decimal (int | float), hex format,
+// or in scientific notation.
 func isNumberValue(b []byte) bool {
-	foundDecimal := false
-	foundBinary := false
-	foundOctal := false
-	foundHex := false
-	foundExponent := false
-	foundNegative := false
 	negativeIndex := 0
+	helper := numberHelper{}
 
 	for i := 0; i < len(b); i++ {
 		negativeIndex++
 
 		switch b[i] {
 		case '-':
-			if foundNegative || negativeIndex != 1 {
+			if helper.IsNegative() || negativeIndex != 1 {
 				return false
 			}
-			foundNegative = true
-			continue
-		case '.':
-			if foundDecimal ||
-				foundBinary ||
-				foundOctal ||
-				foundHex ||
-				foundExponent {
-				return false
-			}
-			foundDecimal = true
+			helper.Determine(b[i])
 			continue
 		case 'e', 'E':
-			if foundDecimal ||
-				foundBinary ||
-				foundOctal ||
-				foundHex ||
-				foundExponent {
+			if helper.Exists() {
 				return false
 			}
 
-			foundExponent = true
-			foundNegative = false
 			negativeIndex = 0
+			helper.Determine(b[i])
 			continue
-		case 'b', 'o', 'x':
+		case 'b':
+			if helper.hex {
+				break
+			}
+			fallthrough
+		case 'o', 'x':
 			if i == 0 {
 				return false
 			}
-			if foundDecimal ||
-				foundBinary ||
-				foundOctal ||
-				foundHex ||
-				foundExponent {
+
+			fallthrough
+		case '.':
+			if helper.Exists() {
 				return false
 			}
-			foundBinary = foundBinary || b[i] == 'b'
-			foundOctal = foundOctal || b[i] == 'o'
-			foundHex = foundHex || b[i] == 'x'
+			helper.Determine(b[i])
 			continue
 		}
 
@@ -90,49 +78,14 @@ func isNumberValue(b []byte) bool {
 			return true
 		}
 
-		switch {
-		case foundBinary:
-			if b[i] != '0' && b[i] != '1' {
-				return false
-			}
-		case foundOctal:
-			switch b[i] {
-			case '0', '1', '2', '3', '4', '5', '6', '7':
-			default:
-				return false
-			}
-		case foundHex:
-			if !isHexByte(b[i]) {
-				return false
-			}
-		case foundDecimal:
-			if !isDigit(b[i]) {
-				return false
-			}
-		case foundExponent:
-			if !isDigit(b[i]) {
-				return false
-			}
-		case foundNegative:
-			if !isDigit(b[i]) {
-				return false
-			}
-		default:
-			if !isDigit(b[i]) {
-				return false
-			}
+		if !helper.CorrectByte(b[i]) {
+			return false
 		}
-
 	}
 
 	return true
 }
 
-// isDigit will return whether or not something is an integer
-func isDigit(b byte) bool {
-	return b >= '0' && b <= '9'
-}
-
 func isValid(b byte) bool {
 	return utf8.ValidRune(rune(b)) && b != '=' && b != '[' && b != ']' && b != ' ' && b != '\n'
 }
@@ -286,7 +239,3 @@ func (token literalToken) String() string {
 
 	return "invalid token"
 }
-
-func hasExponent(v string) bool {
-	return strings.Contains(v, "e") || strings.Contains(v, "E")
-}

aws/session/internal/ini/literal_tokens_test.go

@@ -30,6 +30,10 @@ func TestIsNumberValue(t *testing.T) {
 			[]byte("1E234"),
 			true,
 		},
+		{
+			[]byte("1ea4"),
+			false,
+		},
 		{
 			[]byte("1-23"),
 			false,

aws/session/internal/ini/newline_token.go

@@ -1,5 +1,7 @@
 package ini
 
+// newlineToken acts as a delimeter in ini is will be used
+// primarily to handle nesting expressions.
 type newlineToken struct {
 	emptyToken
 	raw string

aws/session/internal/ini/number_helper.go

@@ -0,0 +1,131 @@
+package ini
+
+import (
+	"bytes"
+	"fmt"
+
+	"github.com/aws/aws-sdk-go/aws/awserr"
+)
+
+// numberHelper is used to dictate what format a number is in
+// and what to do for negative values. Since -1e-4 is a valid
+// number, we cannot just simply check for duplicate negatives.
+type numberHelper struct {
+	binary  bool
+	octal   bool
+	decimal bool
+	hex     bool
+
+	exponent bool
+	negative bool
+}
+
+func (b numberHelper) Exists() bool {
+	return b.decimal || b.binary || b.octal || b.hex || b.exponent
+}
+
+func (b numberHelper) IsNegative() bool {
+	return b.negative
+}
+
+func (b *numberHelper) Determine(c byte) error {
+	switch c {
+	case 'b':
+		b.binary = true
+	case 'o':
+		b.octal = true
+	case 'x':
+		b.hex = true
+	case 'e', 'E':
+		b.exponent = true
+		b.negative = false
+	case '-':
+		b.negative = true
+	case '.':
+		b.decimal = true
+	default:
+		return awserr.New(ErrCodeParseError, fmt.Sprintf("invalid number character: %v", string(c)), nil)
+	}
+
+	return nil
+}
+
+func (b numberHelper) CorrectByte(c byte) bool {
+	switch {
+	case b.binary:
+		if !isBinaryByte(c) {
+			return false
+		}
+	case b.octal:
+		if !isOctalByte(c) {
+			return false
+		}
+	case b.hex:
+		if !isHexByte(c) {
+			return false
+		}
+	case b.decimal:
+		if !isDigit(c) {
+			return false
+		}
+	case b.exponent:
+		if !isDigit(c) {
+			return false
+		}
+	case b.negative:
+		if !isDigit(c) {
+			return false
+		}
+	default:
+		if !isDigit(c) {
+			return false
+		}
+	}
+
+	return true
+}
+
+func (b numberHelper) Base() int {
+	switch {
+	case b.binary:
+		return 2
+	case b.octal:
+		return 8
+	case b.hex:
+		return 16
+	default:
+		return 10
+	}
+}
+
+func (b numberHelper) String() string {
+	buf := bytes.Buffer{}
+	i := 0
+
+	if b.binary {
+		i++
+		buf.WriteString(string(i+'0') + ": binary format\n")
+	}
+
+	if b.octal {
+		i++
+		buf.WriteString(string(i+'0') + ": octal format\n")
+	}
+
+	if b.hex {
+		i++
+		buf.WriteString(string(i+'0') + ": hex format\n")
+	}
+
+	if b.exponent {
+		i++
+		buf.WriteString(string(i+'0') + ": exponent format\n")
+	}
+
+	if b.negative {
+		i++
+		buf.WriteString(string(i+'0') + ": negative format\n")
+	}
+
+	return buf.String()
+}

aws/session/internal/ini/op_tokens.go

@@ -24,6 +24,7 @@ const (
 	opTypeEqual
 )
 
+// opToken is an operation token that signifies an expression.
 type opToken struct {
 	emptyToken
 

aws/session/internal/ini/parse_stack.go

@@ -5,26 +5,34 @@ import (
 	"fmt"
 )
 
+// ParseStack is a stack that contains a container, the stack portion,
+// and the list which is the list of ASTs that have been successfully
+// parsed.
 type ParseStack struct {
 	container []AST
 	list      []AST
 }
 
+// Pop will return and truncate the last container element.
 func (s *ParseStack) Pop() AST {
 	temp := s.container[0]
 	s.container = s.container[1:]
 	return temp
 }
 
+// Push will add the new AST to the container
 func (s *ParseStack) Push(ast AST) {
 	s.container = append(s.container, ast)
 }
 
+// Epsilon will push Start{} back to the stack and append the
+// AST to the list of completed statements
 func (s *ParseStack) Epsilon(ast AST) {
 	s.Push(Start{})
 	s.list = append(s.list, ast)
 }
 
+// Len will return the length of the container
 func (s *ParseStack) Len() int {
 	return len(s.container)
 }

aws/session/internal/ini/sep_tokens.go

@@ -25,6 +25,8 @@ const (
 	sepTypeCloseBrace
 )
 
+// sepToken is a separator token which represents the concept of
+// scoping in ini files.
 type sepToken struct {
 	emptyToken