Add support for parsing functions in RDF

Following are now possible (useful in upsert API)
  * uid(v) <predicate> "object" .
  * <0x01> <predicate> uid(foo) .

For now, we only support uid function. In future, we can
add support for more functions, starting with `val`.

Author: mangalaman93

Diff for: chunker/rdf/parse.go

@@ -77,17 +77,17 @@ L:
 		case itemSubject:
 			rnq.Subject = strings.Trim(item.Val, " ")
 
-		case itemVarKeyword:
-			it.Next()
-			if item = it.Item(); item.Typ != itemLeftRound {
-				return rnq, errors.Errorf("Expected '(', found: %s", item.Val)
-			}
-			it.Next()
-			if item = it.Item(); item.Typ != itemVarName {
-				return rnq, errors.Errorf("Expected variable name, found: %s", item.Val)
+		case itemSubjectFunc:
+			var err error
+			if rnq.Subject, err = parseFunction(it); err != nil {
+				return rnq, err
 			}
 
-			it.Next() // parse ')'
+		case itemObjectFunc:
+			var err error
+			if rnq.ObjectId, err = parseFunction(it); err != nil {
+				return rnq, err
+			}
 
 		case itemPredicate:
 			// Here we split predicate and lang directive (ex: "name@en"), if needed.
@@ -202,6 +202,29 @@ L:
 	return rnq, nil
 }
 
+func parseFunction(it *lex.ItemIterator) (string, error) {
+	item := it.Item()
+	s := item.Val
+
+	it.Next()
+	if item = it.Item(); item.Typ != itemLeftRound {
+		return "", errors.Errorf("Expected '(', found: %s", item.Val)
+	}
+
+	it.Next()
+	if item = it.Item(); item.Typ != itemVarName {
+		return "", errors.Errorf("Expected variable name, found: %s", item.Val)
+	}
+	s += "(" + item.Val + ")"
+
+	it.Next()
+	if item = it.Item(); item.Typ != itemRightRound {
+		return "", errors.Errorf("Expected ')', found: %s", item.Val)
+	}
+
+	return s, nil
+}
+
 func parseFacets(it *lex.ItemIterator, rnq *api.NQuad) error {
 	if !it.Next() {
 		return errors.Errorf("Unexpected end of facets.")

Diff for: chunker/rdf/parse_test.go

@@ -895,6 +895,51 @@ var testNQuads = []struct {
 		input:       `<alice> <age> "13"^^<xs:double> (salary=NaN) .`,
 		expectedErr: true,
 	},
+	{
+		input: `uid(v) <lives> "\x02 wonderland" .`,
+		nq: api.NQuad{
+			Subject:     "uid(v)",
+			Predicate:   "lives",
+			ObjectValue: &api.Value{Val: &api.Value_DefaultVal{DefaultVal: "\x02 wonderland"}},
+		},
+		expectedErr: false,
+	},
+	{
+		input: `uid  (  v  ) <lives> "vrinadavan" .`,
+		nq: api.NQuad{
+			Subject:     "uid(v)",
+			Predicate:   "lives",
+			ObjectValue: &api.Value{Val: &api.Value_DefaultVal{DefaultVal: "vrinadavan"}},
+		},
+		expectedErr: false,
+	},
+	{
+		input: `uid  (  val  ) <lives> "vrinadavan" .`,
+		nq: api.NQuad{
+			Subject:     "uid(val)",
+			Predicate:   "lives",
+			ObjectValue: &api.Value{Val: &api.Value_DefaultVal{DefaultVal: "vrinadavan"}},
+		},
+		expectedErr: false,
+	},
+	{
+		input: `uid  (  val  ) <lives> uid(g) .`,
+		nq: api.NQuad{
+			Subject:   "uid(val)",
+			Predicate: "lives",
+			ObjectId:  "uid(g)",
+		},
+		expectedErr: false,
+	},
+	{
+		input: `uid  (  val  ) <lives> uid ( g )  .`,
+		nq: api.NQuad{
+			Subject:   "uid(val)",
+			Predicate: "lives",
+			ObjectId:  "uid(g)",
+		},
+		expectedErr: false,
+	},
 }
 
 func TestLex(t *testing.T) {

Diff for: chunker/rdf/state.go

@@ -26,23 +26,24 @@ import (
 
 // The constants represent different types of lexed Items possible for an rdf N-Quad.
 const (
-	itemText       lex.ItemType = 5 + iota // plain text
-	itemSubject                            // subject, 6
-	itemPredicate                          // predicate, 7
-	itemObject                             // object, 8
-	itemLabel                              // label, 9
-	itemLiteral                            // literal, 10
-	itemLanguage                           // language, 11
-	itemObjectType                         // object type, 12
-	itemValidEnd                           // end with dot, 13
-	itemComment                            // comment, 14
-	itemComma                              // comma, 15
-	itemEqual                              // equal, 16
-	itemLeftRound                          // '(', 17
-	itemRightRound                         // ')', 18
-	itemStar                               // *, 19
-	itemVarKeyword                         // var, 20
-	itemVarName                            // 21
+	itemText        lex.ItemType = 5 + iota // plain text
+	itemSubject                             // subject, 6
+	itemPredicate                           // predicate, 7
+	itemObject                              // object, 8
+	itemLabel                               // label, 9
+	itemLiteral                             // literal, 10
+	itemLanguage                            // language, 11
+	itemObjectType                          // object type, 12
+	itemValidEnd                            // end with dot, 13
+	itemComment                             // comment, 14
+	itemComma                               // comma, 15
+	itemEqual                               // equal, 16
+	itemLeftRound                           // '(', 17
+	itemRightRound                          // ')', 18
+	itemStar                                // *, 19
+	itemSubjectFunc                         // uid, 20
+	itemObjectFunc                          // uid, 21
+	itemVarName                             // 22
 )
 
 // These constants keep a track of the depth while parsing an rdf N-Quad.
@@ -138,6 +139,7 @@ func lexText(l *lex.Lexer) lex.StateFn {
 				l.Depth = atSubject
 			}
 
+		// TODO(Aman): add support for more functions here.
 		case r == 'u':
 			if l.Depth != atSubject && l.Depth != atObject {
 				return l.Errorf("Unexpected char 'u'")
@@ -423,19 +425,23 @@ func lexComment(l *lex.Lexer) lex.StateFn {
 func lexVariable(l *lex.Lexer) lex.StateFn {
 	var r rune
 
+	// TODO(Aman): add support for more functions here.
 	for _, c := range "uid" {
 		if r = l.Next(); r != c {
 			return l.Errorf("Unexpected char '%c' when parsing var keyword", r)
 		}
 	}
-	l.Emit(itemVarKeyword)
+	if l.Depth == atObject {
+		l.Emit(itemObjectFunc)
+	} else if l.Depth == atSubject {
+		l.Emit(itemSubjectFunc)
+	}
 	l.IgnoreRun(isSpace)
 
 	if r = l.Next(); r != '(' {
 		return l.Errorf("Expected '(' after var keyword, found: '%c'", r)
 	}
 	l.Emit(itemLeftRound)
-
 	l.IgnoreRun(isSpace)
 
 	for {
@@ -448,11 +454,11 @@ func lexVariable(l *lex.Lexer) lex.StateFn {
 			break
 		}
 		if isSpace(r) {
+			l.Backup()
 			break
 		}
 	}
 	l.Emit(itemVarName)
-
 	l.IgnoreRun(isSpace)
 
 	if r = l.Next(); r != ')' {