renaming tables to sections and adding more docs

Author: xibz

aws/session/internal/ini/ast.go

@@ -10,8 +10,8 @@ const (
 	ASTKindExpr
 	ASTKindStatement
 	ASTKindExprStatement
-	ASTKindNestedTableStatement
-	ASTKindCompletedNestedTableStatement
+	ASTKindNestedSectionStatement
+	ASTKindCompletedNestedSectionStatement
 	ASTKindCommentStatement
 )
 
@@ -27,8 +27,8 @@ func (k ASTKind) String() string {
 		return "stmt"
 	case ASTKindExprStatement:
 		return "expr_stmt"
-	case ASTKindNestedTableStatement:
-		return "nested_table_stmt"
+	case ASTKindNestedSectionStatement:
+		return "nested_section_stmt"
 	default:
 		return ""
 	}

aws/session/internal/ini/comment_token.go

@@ -7,6 +7,8 @@ type CommentToken struct {
 	comment string
 }
 
+// isComment will return whether or not the next byte(s) is a
+// comment.
 func isComment(b []byte) bool {
 	if len(b) == 0 {
 		return false
@@ -26,6 +28,8 @@ func isComment(b []byte) bool {
 	return false
 }
 
+// newCommentToken will create a comment token and
+// return how many bytes were read.
 func newCommentToken(b []byte) (CommentToken, int, error) {
 	i := 0
 	value := ""

aws/session/internal/ini/ini.go

@@ -4,7 +4,9 @@ import (
 	"os"
 )
 
-func OpenFile(path string) (Tables, error) {
+// OpenFile takes a path to a given file, and will open  and parse
+// that file.
+func OpenFile(path string) (Sections, error) {
 	f, err := os.Open(path)
 	if err != nil {
 		return nil, err
@@ -14,7 +16,9 @@ func OpenFile(path string) (Tables, error) {
 	return ParseFile(f)
 }
 
-func ParseFile(f *os.File) (Tables, error) {
+// ParseFile will parse the given file using the shared config
+// visitor.
+func ParseFile(f *os.File) (Sections, error) {
 	tree, err := Parse(f)
 	if err != nil {
 		return nil, err
@@ -25,5 +29,5 @@ func ParseFile(f *os.File) (Tables, error) {
 		return nil, err
 	}
 
-	return v.Tables, nil
+	return v.Sections, nil
 }

aws/session/internal/ini/ini_parser.go

@@ -61,14 +61,14 @@ var parseTable = map[ASTKind]map[tokenType]int{
 		tokenNL:      -1,
 		tokenComment: 11, // comment -> #comment' | ;comment' | /comment_slash
 	},
-	ASTKindNestedTableStatement: map[tokenType]int{
+	ASTKindNestedSectionStatement: map[tokenType]int{
 		tokenLit:     7, // table_nested -> label nested_array_close
 		tokenSep:     8, // nested_array_close -> ] array_close
 		tokenWS:      -1,
 		tokenNL:      -1,
 		tokenComment: 11, // comment -> #comment' | ;comment' | /comment_slash
 	},
-	ASTKindCompletedNestedTableStatement: map[tokenType]int{
+	ASTKindCompletedNestedSectionStatement: map[tokenType]int{
 		tokenSep:     9, // nested_array_close -> ] epsilon
 		tokenWS:      -1,
 		tokenNL:      -1,
@@ -173,28 +173,28 @@ func Parse(r io.Reader) ([]AST, error) {
 
 			var stmt AST
 
-			if t, ok := k.(TableStatement); ok {
+			if t, ok := k.(SectionStatement); ok {
 				t.Name = strings.Join([]string{t.Name, tok.Raw()}, " ")
 				stmt = t
 			} else {
-				stmt = newTableStatement(tok)
+				stmt = newSectionStatement(tok)
 			}
 			stack.Push(stmt)
 		case 6:
 			if tok.Raw() == "]" {
 				stack.Epsilon(k)
 			} else if tok.Raw() == "[" {
-				stmt := newNestedTableStatement()
+				stmt := newNestedSectionStatement()
 				stack.Push(stmt)
 			} else {
 				return stack.list, awserr.New(ErrCodeParseError, "expected ']'", nil)
 			}
 		case 7:
 			switch tok.Type() {
 			case tokenLit:
-				stmt, ok := k.(NestedTableStatement)
+				stmt, ok := k.(NestedSectionStatement)
 				if !ok {
-					return stack.list, awserr.New(ErrCodeParseError, "expected nested table statement", nil)
+					return stack.list, awserr.New(ErrCodeParseError, "expected nested section statement", nil)
 				}
 
 				stmt.Labels = append(stmt.Labels, tok.Raw())
@@ -207,7 +207,7 @@ func Parse(r io.Reader) ([]AST, error) {
 				return stack.list, awserr.New(ErrCodeParseError, "expected closing bracket", nil)
 			}
 
-			stmt := newCompletedNestedTableStatement(k)
+			stmt := newCompletedNestedSectionStatement(k)
 			stack.Push(stmt)
 		case 9:
 			if tok.Raw() != "]" {

aws/session/internal/ini/ini_parser_test.go

@@ -82,20 +82,20 @@ func TestParser(t *testing.T) {
 		{
 			r: bytes.NewBuffer([]byte(`[ default ]`)),
 			expectedStack: []AST{
-				newTableStatement(defaultId),
+				newSectionStatement(defaultId),
 			},
 		},
 		{
 			r: bytes.NewBuffer([]byte(`[default]`)),
 			expectedStack: []AST{
-				newTableStatement(defaultId),
+				newSectionStatement(defaultId),
 			},
 		},
 		{
 			r: bytes.NewBuffer([]byte(`[default]
 					region="us-west-2"`)),
 			expectedStack: []AST{
-				newTableStatement(defaultId),
+				newSectionStatement(defaultId),
 				newExprStatement(EqualExpr{
 					Left:  newExpression(regionId),
 					Root:  equalOp,
@@ -114,7 +114,7 @@ output = json
 region = us-west-2
 		`)),
 			expectedStack: []AST{
-				newTableStatement(defaultId),
+				newSectionStatement(defaultId),
 				newExprStatement(EqualExpr{
 					Left:  newExpression(regionId),
 					Root:  equalOp,
@@ -130,7 +130,7 @@ region = us-west-2
 					Root:  equalOp,
 					Right: newExpression(outputLit),
 				}),
-				newTableStatement(assumeId),
+				newSectionStatement(assumeId),
 				newExprStatement(EqualExpr{
 					Left:  newExpression(outputId),
 					Root:  equalOp,
@@ -157,7 +157,7 @@ output = json
 region = us-west-2
 		`)),
 			expectedStack: []AST{
-				newTableStatement(defaultId),
+				newSectionStatement(defaultId),
 				newExprStatement(EqualExpr{
 					Left:  newExpression(regionId),
 					Root:  equalOp,
@@ -173,7 +173,7 @@ region = us-west-2
 					Root:  equalOp,
 					Right: newExpression(outputLit),
 				}),
-				newTableStatement(assumeId),
+				newSectionStatement(assumeId),
 				newExprStatement(EqualExpr{
 					Left:  newExpression(outputId),
 					Root:  equalOp,
@@ -200,7 +200,7 @@ output = json
 region = us-west-2
 		`)),
 			expectedStack: []AST{
-				newTableStatement(defaultId),
+				newSectionStatement(defaultId),
 				newExprStatement(EqualExpr{
 					Left:  newExpression(regionId),
 					Root:  equalOp,
@@ -216,7 +216,7 @@ region = us-west-2
 					Root:  equalOp,
 					Right: newExpression(outputLit),
 				}),
-				newTableStatement(assumeId),
+				newSectionStatement(assumeId),
 				newExprStatement(EqualExpr{
 					Left:  newExpression(outputId),
 					Root:  equalOp,

aws/session/internal/ini/statement.go

@@ -12,21 +12,21 @@ func (stmt Statement) Kind() ASTKind {
 	return ASTKindStatement
 }
 
-type TableStatement struct {
+type SectionStatement struct {
 	Name string
 }
 
-func newTableStatement(tok iniToken) TableStatement {
-	return TableStatement{
+func newSectionStatement(tok iniToken) SectionStatement {
+	return SectionStatement{
 		Name: tok.Raw(),
 	}
 }
 
-func (stmt TableStatement) Kind() ASTKind {
+func (stmt SectionStatement) Kind() ASTKind {
 	return ASTKindStatement
 }
 
-func (stmt TableStatement) String() string {
+func (stmt SectionStatement) String() string {
 	return fmt.Sprintf("{%s}", stmt.Name)
 }
 
@@ -48,40 +48,40 @@ func (stmt ExprStatement) String() string {
 	return fmt.Sprintf("{%v}", stmt.V)
 }
 
-type NestedTableStatement struct {
+type NestedSectionStatement struct {
 	Labels []string
 	kind   ASTKind
 }
 
-func newNestedTableStatement() NestedTableStatement {
-	return NestedTableStatement{
-		kind: ASTKindNestedTableStatement,
+func newNestedSectionStatement() NestedSectionStatement {
+	return NestedSectionStatement{
+		kind: ASTKindNestedSectionStatement,
 	}
 }
 
-func (stmt NestedTableStatement) Kind() ASTKind {
-	return ASTKindNestedTableStatement
+func (stmt NestedSectionStatement) Kind() ASTKind {
+	return ASTKindNestedSectionStatement
 }
 
-func (stmt NestedTableStatement) String() string {
+func (stmt NestedSectionStatement) String() string {
 	return fmt.Sprintf("{[[ %v ]]}", stmt.Labels)
 }
 
-type CompletedNestedTableStatement struct {
+type CompletedNestedSectionStatement struct {
 	Root AST
 }
 
-func newCompletedNestedTableStatement(k AST) CompletedNestedTableStatement {
-	return CompletedNestedTableStatement{
+func newCompletedNestedSectionStatement(k AST) CompletedNestedSectionStatement {
+	return CompletedNestedSectionStatement{
 		Root: k,
 	}
 }
 
-func (stmt CompletedNestedTableStatement) Kind() ASTKind {
-	return ASTKindCompletedNestedTableStatement
+func (stmt CompletedNestedSectionStatement) Kind() ASTKind {
+	return ASTKindCompletedNestedSectionStatement
 }
 
-func (stmt CompletedNestedTableStatement) String() string {
+func (stmt CompletedNestedSectionStatement) String() string {
 	return fmt.Sprintf("{[[ %v ]]}", stmt.Root)
 }
 

aws/session/internal/ini/visitor.go

@@ -6,46 +6,48 @@ import (
 	"github.com/aws/aws-sdk-go/aws/awserr"
 )
 
+// Visitor is an interface used by walkers that will
+// traverse an array of ASTs.
 type Visitor interface {
 	VisitExpr(AST) error
 	VisitStatement(AST) error
 }
 
-type Tables map[string]Table
+type Sections map[string]Section
 
 type SharedConfigVisitor struct {
-	scope  string
-	Tables Tables
+	scope    string
+	Sections Sections
 }
 
 func NewSharedConfigVisitor() *SharedConfigVisitor {
 	return &SharedConfigVisitor{
-		Tables: Tables{},
+		Sections: Sections{},
 	}
 }
 
-func (t Tables) GetSection(p string) (Table, bool) {
-	tables := map[string]Table(t)
-	v, ok := tables[p]
+func (t Sections) GetSection(p string) (Section, bool) {
+	sections := map[string]Section(t)
+	v, ok := sections[p]
 	return v, ok
 }
 
 type Values map[string]iniToken
 
-type Table struct {
+type Section struct {
 	Name   string
 	Values Values
 }
 
-func (t Table) Int(k string) int64 {
+func (t Section) Int(k string) int64 {
 	return t.Values[k].IntValue()
 }
 
-func (t Table) Float64(k string) float64 {
+func (t Section) Float64(k string) float64 {
 	return t.Values[k].FloatValue()
 }
 
-func (t Table) String(k string) string {
+func (t Section) String(k string) string {
 	_, ok := t.Values[k]
 	if !ok {
 		return ""
@@ -54,7 +56,7 @@ func (t Table) String(k string) string {
 }
 
 func (v *SharedConfigVisitor) VisitExpr(expr AST) error {
-	t := v.Tables[v.scope]
+	t := v.Sections[v.scope]
 	if t.Values == nil {
 		t.Values = Values{}
 	}
@@ -69,14 +71,14 @@ func (v *SharedConfigVisitor) VisitExpr(expr AST) error {
 		return awserr.New(ErrCodeParseError, "unsupported expression", nil)
 	}
 
-	v.Tables[v.scope] = t
+	v.Sections[v.scope] = t
 	return nil
 }
 
 func (v *SharedConfigVisitor) VisitStatement(stmt AST) error {
 	switch s := stmt.(type) {
-	case TableStatement:
-		v.Tables[s.Name] = Table{}
+	case SectionStatement:
+		v.Sections[s.Name] = Section{}
 		v.scope = s.Name
 	default:
 		return awserr.New(ErrCodeParseError, fmt.Sprintf("unsupported statement: %T", s), nil)

aws/session/internal/ini/walker.go

@@ -10,8 +10,8 @@ func Walk(tree []AST, v Visitor) error {
 				return err
 			}
 		case ASTKindStatement,
-			ASTKindNestedTableStatement,
-			ASTKindCompletedNestedTableStatement:
+			ASTKindNestedSectionStatement,
+			ASTKindCompletedNestedSectionStatement:
 
 			if err := v.VisitStatement(node); err != nil {
 				return err

aws/session/internal/ini/walker_test.go

@@ -111,7 +111,7 @@ func TestDataFiles(t *testing.T) {
 		}
 
 		for profile, tableIface := range e {
-			p, ok := v.Tables.GetSection(profile)
+			p, ok := v.Sections.GetSection(profile)
 			if !ok {
 				t.Fatal("could not find profile " + profile)
 			}