From f43287845286d055fbf28b6cc706e076f2aaa3f0 Mon Sep 17 00:00:00 2001
From: Fatih Arslan <ftharsln@gmail.com>
Date: Fri, 16 Oct 2015 14:16:12 +0300
Subject: [PATCH] parser: simplfiy code

---
 parser/parser.go      | 73 +++++++++++++++++++++++++------------------
 parser/parser_test.go |  2 ++
 2 files changed, 45 insertions(+), 30 deletions(-)

diff --git a/parser/parser.go b/parser/parser.go
index 2192829..72b4b3d 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -56,6 +56,17 @@ func (p *Parser) parseObjectItem() (*ObjectItem, error) {
 		return nil, err
 	}
 
+	// either an assignment or object
+	switch p.tok.Type {
+	case scanner.ASSIGN:
+	case scanner.LBRACE:
+		if len(keys) > 1 {
+			// nested object
+		}
+
+		// object or nested object
+	}
+
 	switch len(keys) {
 	case 1:
 		// assignment or object
@@ -85,42 +96,44 @@ func (p *Parser) parseObjectItem() (*ObjectItem, error) {
 // parseObjectKey parses an object key and returns a ObjectKey AST
 func (p *Parser) parseObjectKey() ([]*ObjectKey, error) {
 	tok := p.scan()
+
+	keys := make([]*ObjectKey, 0)
+
 	switch tok.Type {
 	case scanner.IDENT, scanner.STRING:
 		// add first found token
-		keys := []*ObjectKey{&ObjectKey{tok}}
-		nestedObj := false
-
-		// now we have three casses
-		// 1. assignment: KEY = NODE
-		// 2. object: KEY { }
-		// 2. nested object: KEY KEY2 ... KEYN {}
-		for {
-			tok := p.scan()
-			switch tok.Type {
-			case scanner.ASSIGN:
-				// assignment or object, but not nested objects
-				if nestedObj {
-					return nil, fmt.Errorf("nested object expected: LBRACE got: %s", tok.Type)
-				}
-
-				return keys, nil
-			case scanner.LBRACE:
-				// object
-				return keys, nil
-			case scanner.IDENT, scanner.STRING:
-				// nested object
-				nestedObj = true
-				keys = append(keys, &ObjectKey{
-					token: tok,
-				})
-			default:
-				return nil, fmt.Errorf("expected: IDENT | STRING | ASSIGN | LBRACE got: %s", tok.Type)
-			}
-		}
+		keys = append(keys, &ObjectKey{token: tok})
 	default:
 		return nil, fmt.Errorf("expected: IDENT | STRING got: %s", tok.Type)
 	}
+
+	nestedObj := false
+
+	// we have three casses
+	// 1. assignment: KEY = NODE
+	// 2. object: KEY { }
+	// 2. nested object: KEY KEY2 ... KEYN {}
+	for {
+		tok := p.scan()
+		switch tok.Type {
+		case scanner.ASSIGN:
+			// assignment or object, but not nested objects
+			if nestedObj {
+				return nil, fmt.Errorf("nested object expected: LBRACE got: %s", tok.Type)
+			}
+
+			return keys, nil
+		case scanner.LBRACE:
+			// object
+			return keys, nil
+		case scanner.IDENT, scanner.STRING:
+			// nested object
+			nestedObj = true
+			keys = append(keys, &ObjectKey{token: tok})
+		default:
+			return nil, fmt.Errorf("expected: IDENT | STRING | ASSIGN | LBRACE got: %s", tok.Type)
+		}
+	}
 }
 
 // parseLiteralType parses a literal type and returns a LiteralType AST
diff --git a/parser/parser_test.go b/parser/parser_test.go
index 5a16f89..9e847f5 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -17,6 +17,8 @@ func TestObjectKey(t *testing.T) {
 	}{
 		{[]scanner.TokenType{scanner.IDENT}, `foo {}`},
 		{[]scanner.TokenType{scanner.IDENT}, `foo = {}`},
+		{[]scanner.TokenType{scanner.IDENT}, `foo = bar`},
+		{[]scanner.TokenType{scanner.IDENT}, `foo = 123`},
 		{[]scanner.TokenType{scanner.IDENT}, `foo = "${var.bar}`},
 		{[]scanner.TokenType{scanner.STRING}, `"foo" {}`},
 		{[]scanner.TokenType{scanner.STRING}, `"foo" = {}`},