You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@tinkerpop.apache.org by jo...@apache.org on 2021/05/11 18:01:16 UTC
[tinkerpop] 01/02: Add Gremlin traversal specification in YAML
This is an automated email from the ASF dual-hosted git repository.
joshsh pushed a commit to branch TINKERPOP-2563-language
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git
commit aa35e7065e77b84b6efd8075f561c1a8fa310c1d
Author: Joshua Shinavier <jo...@uber.com>
AuthorDate: Tue May 11 07:41:21 2021 -0700
Add Gremlin traversal specification in YAML
---
.../gremlin/language/model/constants.yaml | 200 +++
.../tinkerpop/gremlin/language/model/literals.yaml | 404 +++++
.../tinkerpop/gremlin/language/model/methods.yaml | 113 ++
.../gremlin/language/model/predicates.yaml | 234 +++
.../tinkerpop/gremlin/language/model/query.yaml | 60 +
.../tinkerpop/gremlin/language/model/steps.yaml | 1802 ++++++++++++++++++++
.../gremlin/language/model/traversal.yaml | 575 +++++++
7 files changed, 3388 insertions(+)
diff --git a/gremlin-language/src/main/yaml/org/apache/tinkerpop/gremlin/language/model/constants.yaml b/gremlin-language/src/main/yaml/org/apache/tinkerpop/gremlin/language/model/constants.yaml
new file mode 100644
index 0000000..af33642
--- /dev/null
+++ b/gremlin-language/src/main/yaml/org/apache/tinkerpop/gremlin/language/model/constants.yaml
@@ -0,0 +1,200 @@
+# // Gremlin specific lexer rules
+
+definitions:
+
+ # gremlinStringConstants
+ # : withOptionsStringConstants
+ # | shortestPathStringConstants
+ # | pageRankStringConstants
+ # | peerPressureStringConstants
+ # ;
+
+ - name: GremlinStringConstant
+ type:
+ union:
+ - name: withOptions
+ type: WithOptionsStringConstant
+
+ - name: shortestPath
+ type: ShortestPathStringConstant
+
+ - name: pageRank
+ type: PageRankStringConstant
+
+ - name: peerPressure
+ type: PeerPressureStringConstant
+
+ # pageRankStringConstants
+ # : gremlinStringConstants_pageRankStringConstants_edges
+ # | gremlinStringConstants_pageRankStringConstants_times
+ # | gremlinStringConstants_pageRankStringConstants_propertyName
+ # ;
+
+ - name: PageRankStringConstant
+ type:
+ enum:
+ - edges
+ - times
+ - propertyName
+
+ # peerPressureStringConstants
+ # : gremlinStringConstants_peerPressureStringConstants_edges
+ # | gremlinStringConstants_peerPressureStringConstants_times
+ # | gremlinStringConstants_peerPressureStringConstants_propertyName
+ # ;
+
+ - name: PeerPressureStringConstant
+ type:
+ enum:
+ - edges
+ - times
+ - propertyName
+
+ # shortestPathStringConstants
+ # : gremlinStringConstants_shortestPathStringConstants_target
+ # | gremlinStringConstants_shortestPathStringConstants_edges
+ # | gremlinStringConstants_shortestPathStringConstants_distance
+ # | gremlinStringConstants_shortestPathStringConstants_maxDistance
+ # | gremlinStringConstants_shortestPathStringConstants_includeEdges
+ # ;
+
+ - name: ShortestPathStringConstant
+ type:
+ enum:
+ - tokens
+ - none
+ - ids
+ - labels
+ - keys
+ - values
+ - all
+ - indexer
+ - list
+ - map
+
+ # withOptionsStringConstants
+ # : gremlinStringConstants_withOptionsStringConstants_tokens
+ # | gremlinStringConstants_withOptionsStringConstants_none
+ # | gremlinStringConstants_withOptionsStringConstants_ids
+ # | gremlinStringConstants_withOptionsStringConstants_labels
+ # | gremlinStringConstants_withOptionsStringConstants_keys
+ # | gremlinStringConstants_withOptionsStringConstants_values
+ # | gremlinStringConstants_withOptionsStringConstants_all
+ # | gremlinStringConstants_withOptionsStringConstants_indexer
+ # | gremlinStringConstants_withOptionsStringConstants_list
+ # | gremlinStringConstants_withOptionsStringConstants_map
+ # ;
+
+ - name: WithOptionsStringConstant
+ type:
+ enum:
+ - tokens
+ - none
+ - ids
+ - labels
+ - keys
+ - values
+ - all
+ - indexer
+ - list
+ - map
+
+# gremlinStringConstants_pageRankStringConstants_edges
+# : pageRankStringConstant DOT 'edges'
+# ;
+#
+# gremlinStringConstants_pageRankStringConstants_times
+# : pageRankStringConstant DOT 'times'
+# ;
+#
+# gremlinStringConstants_pageRankStringConstants_propertyName
+# : pageRankStringConstant DOT 'propertyName'
+# ;
+#
+# gremlinStringConstants_peerPressureStringConstants_edges
+# : peerPressureStringConstant DOT 'edges'
+# ;
+#
+# gremlinStringConstants_peerPressureStringConstants_times
+# : peerPressureStringConstant DOT 'times'
+# ;
+#
+# gremlinStringConstants_peerPressureStringConstants_propertyName
+# : peerPressureStringConstant DOT 'propertyName'
+# ;
+#
+# gremlinStringConstants_shortestPathStringConstants_target
+# : shortestPathStringConstant DOT 'target'
+# ;
+#
+# gremlinStringConstants_shortestPathStringConstants_edges
+# : shortestPathStringConstant DOT 'edges'
+# ;
+#
+# gremlinStringConstants_shortestPathStringConstants_distance
+# : shortestPathStringConstant DOT 'distance'
+# ;
+#
+# gremlinStringConstants_shortestPathStringConstants_maxDistance
+# : shortestPathStringConstant DOT 'maxDistance'
+# ;
+#
+# gremlinStringConstants_shortestPathStringConstants_includeEdges
+# : shortestPathStringConstant DOT 'includeEdges'
+# ;
+#
+# gremlinStringConstants_withOptionsStringConstants_tokens
+# : withOptionsStringConstant DOT 'tokens'
+# ;
+#
+# gremlinStringConstants_withOptionsStringConstants_none
+# : withOptionsStringConstant DOT 'none'
+# ;
+#
+# gremlinStringConstants_withOptionsStringConstants_ids
+# : withOptionsStringConstant DOT 'ids'
+# ;
+#
+# gremlinStringConstants_withOptionsStringConstants_labels
+# : withOptionsStringConstant DOT 'labels'
+# ;
+#
+# gremlinStringConstants_withOptionsStringConstants_keys
+# : withOptionsStringConstant DOT 'keys'
+# ;
+#
+# gremlinStringConstants_withOptionsStringConstants_values
+# : withOptionsStringConstant DOT 'values'
+# ;
+#
+# gremlinStringConstants_withOptionsStringConstants_all
+# : withOptionsStringConstant DOT 'all'
+# ;
+#
+# gremlinStringConstants_withOptionsStringConstants_indexer
+# : withOptionsStringConstant DOT 'indexer'
+# ;
+#
+# gremlinStringConstants_withOptionsStringConstants_list
+# : withOptionsStringConstant DOT 'list'
+# ;
+#
+# gremlinStringConstants_withOptionsStringConstants_map
+# : withOptionsStringConstant DOT 'map'
+# ;
+#
+# pageRankStringConstant
+# : 'PageRank'
+# ;
+#
+# peerPressureStringConstant
+# : 'PeerPressure'
+# ;
+#
+# shortestPathStringConstant
+# : 'ShortestPath'
+# ;
+#
+# withOptionsStringConstant
+# : 'WithOptions'
+# ;
diff --git a/gremlin-language/src/main/yaml/org/apache/tinkerpop/gremlin/language/model/literals.yaml b/gremlin-language/src/main/yaml/org/apache/tinkerpop/gremlin/language/model/literals.yaml
new file mode 100644
index 0000000..89c68bb
--- /dev/null
+++ b/gremlin-language/src/main/yaml/org/apache/tinkerpop/gremlin/language/model/literals.yaml
@@ -0,0 +1,404 @@
+# /*********************************************
+# LEXER RULES
+# **********************************************/
+#
+# // Lexer rules
+# // These rules are extracted from Java ANTLRv4 Grammar.
+# // Source: https://github.com/antlr/grammars-v4/blob/master/java8/Java8.g4
+
+status: experimental
+comments:
+ - >
+ These definitions greatly simplify the original lexer rules from gremlin-language,
+ because we are not concerned with encoding here.
+
+includes:
+ - constants
+
+definitions:
+
+# // 3.9 Keywords
+#
+# NEW : 'new';
+#
+# // Integer Literals
+#
+# IntegerLiteral
+# : Sign? DecimalIntegerLiteral
+# | Sign? HexIntegerLiteral
+# | Sign? OctalIntegerLiteral
+# ;
+#
+# fragment
+# DecimalIntegerLiteral
+# : DecimalNumeral IntegerTypeSuffix?
+# ;
+#
+# fragment
+# HexIntegerLiteral
+# : HexNumeral IntegerTypeSuffix?
+# ;
+#
+# fragment
+# OctalIntegerLiteral
+# : OctalNumeral IntegerTypeSuffix?
+# ;
+#
+# fragment
+# IntegerTypeSuffix
+# : [lL]
+# ;
+#
+# fragment
+# DecimalNumeral
+# : '0'
+# | NonZeroDigit (Digits? | Underscores Digits)
+# ;
+#
+# fragment
+# Digits
+# : Digit (DigitsAndUnderscores? Digit)?
+# ;
+#
+# fragment
+# Digit
+# : '0'
+# | NonZeroDigit
+# ;
+#
+# fragment
+# NonZeroDigit
+# : [1-9]
+# ;
+#
+# fragment
+# DigitsAndUnderscores
+# : DigitOrUnderscore+
+# ;
+#
+# fragment
+# DigitOrUnderscore
+# : Digit
+# | '_'
+# ;
+#
+# fragment
+# Underscores
+# : '_'+
+# ;
+#
+# fragment
+# HexNumeral
+# : '0' [xX] HexDigits
+# ;
+#
+# fragment
+# HexDigits
+# : HexDigit (HexDigitsAndUnderscores? HexDigit)?
+# ;
+#
+# fragment
+# HexDigit
+# : [0-9a-fA-F]
+# ;
+#
+# fragment
+# HexDigitsAndUnderscores
+# : HexDigitOrUnderscore+
+# ;
+#
+# fragment
+# HexDigitOrUnderscore
+# : HexDigit
+# | '_'
+# ;
+#
+# fragment
+# OctalNumeral
+# : '0' Underscores? OctalDigits
+# ;
+#
+# fragment
+# OctalDigits
+# : OctalDigit (OctalDigitsAndUnderscores? OctalDigit)?
+# ;
+#
+# fragment
+# OctalDigit
+# : [0-7]
+# ;
+#
+# fragment
+# OctalDigitsAndUnderscores
+# : OctalDigitOrUnderscore+
+# ;
+#
+# fragment
+# OctalDigitOrUnderscore
+# : OctalDigit
+# | '_'
+# ;
+#
+# // Floating-Point Literals
+#
+# FloatingPointLiteral
+# : Sign? DecimalFloatingPointLiteral
+# ;
+#
+# fragment
+# DecimalFloatingPointLiteral
+# : Digits ('.' Digits ExponentPart? | ExponentPart) FloatTypeSuffix?
+# | Digits FloatTypeSuffix
+# ;
+#
+# fragment
+# ExponentPart
+# : ExponentIndicator SignedInteger
+# ;
+#
+# fragment
+# ExponentIndicator
+# : [eE]
+# ;
+#
+# fragment
+# SignedInteger
+# : Sign? Digits
+# ;
+#
+# fragment
+# Sign
+# : [+-]
+# ;
+#
+# fragment
+# FloatTypeSuffix
+# : [fFdD]
+# ;
+#
+# // Boolean Literals
+#
+# BooleanLiteral
+# : 'true'
+# | 'false'
+# ;
+#
+# // Null Literal
+#
+# NullLiteral
+# : 'null'
+# ;
+#
+# // String Literals
+#
+# // String literal is customized since Java only allows double quoted strings where Groovy supports single quoted
+# // literals also. A side effect of this is ANTLR will not be able to parse single character string literals with
+# // single quoted so we instead remove char literal altogether and only have string literal in lexer tokens.
+# NonEmptyStringLiteral
+# : '"' DoubleQuotedStringCharacters '"'
+# | '\'' SingleQuotedStringCharacters '\''
+# ;
+
+ - name: NonEmptyStringLiteral
+ type: string
+
+# // We define NonEmptyStringLiteral and EmptyStringLiteral separately so that we can unambiguously handle empty queries
+# EmptyStringLiteral
+# : '""'
+# | '\'\''
+# ;
+
+ - name: EmptyStringLiteral
+
+# fragment
+# DoubleQuotedStringCharacters
+# : DoubleQuotedStringCharacter+
+# ;
+#
+# fragment
+# DoubleQuotedStringCharacter
+# : ~('"' | '\\')
+# | JoinLineEscape
+# | EscapeSequence
+# ;
+#
+# fragment
+# SingleQuotedStringCharacters
+# : SingleQuotedStringCharacter+
+# ;
+#
+# fragment
+# SingleQuotedStringCharacter
+# : ~('\'' | '\\')
+# | JoinLineEscape
+# | EscapeSequence
+# ;
+#
+# // Escape Sequences for Character and String Literals
+# fragment JoinLineEscape
+# : '\\' '\r'? '\n'
+# ;
+#
+# fragment
+# EscapeSequence
+# : '\\' [btnfr"'\\]
+# | OctalEscape
+# | UnicodeEscape // This is not in the spec but prevents having to preprocess the input
+# ;
+#
+# fragment
+# OctalEscape
+# : '\\' OctalDigit
+# | '\\' OctalDigit OctalDigit
+# | '\\' ZeroToThree OctalDigit OctalDigit
+# ;
+#
+# fragment
+# ZeroToThree
+# : [0-3]
+# ;
+#
+# // This is not in the spec but prevents having to preprocess the input
+# fragment
+# UnicodeEscape
+# : '\\' 'u'+ HexDigit HexDigit HexDigit HexDigit
+# ;
+#
+# // Separators
+#
+# LPAREN : '(';
+# RPAREN : ')';
+# LBRACE : '{';
+# RBRACE : '}';
+# LBRACK : '[';
+# RBRACK : ']';
+# SEMI : ';';
+# COMMA : ',';
+# DOT : '.';
+# COLON : ':';
+#
+# TRAVERSAL_ROOT: 'g';
+# ANON_TRAVERSAL_ROOT: '__';
+#
+# // Trim whitespace and comments if present
+#
+# WS : [ \t\r\n\u000C]+ -> skip
+# ;
+#
+# LINE_COMMENT
+# : '//' ~[\r\n]* -> skip
+# ;
+
+
+ # genericLiteralList
+ # : genericLiteralExpr?
+ # ;
+ #
+ # genericLiteralExpr
+ # : genericLiteral (COMMA genericLiteral)*
+ # ;
+ #
+ # genericLiteralRange
+ # : integerLiteral DOT DOT integerLiteral
+ # | stringLiteral DOT DOT stringLiteral
+ # ;
+ #
+ # genericLiteralCollection
+ # : LBRACK (genericLiteral (COMMA genericLiteral)*)? RBRACK
+ # ;
+ #
+ # stringLiteralList
+ # : stringLiteralExpr?
+ # | LBRACK stringLiteralExpr? RBRACK
+ # ;
+ #
+ # stringLiteralExpr
+ # : stringLiteral (COMMA stringLiteral)*
+ # ;
+ #
+ # genericLiteral
+ # : integerLiteral
+ # | floatLiteral
+ # | booleanLiteral
+ # | stringLiteral
+ # | dateLiteral
+ # | nullLiteral
+ # // Allow the generic literal to match specific gremlin tokens also
+ # | traversalToken
+ # | traversalCardinality
+ # | traversalDirection
+ # | traversalOptionParent
+ # | genericLiteralCollection
+ # | genericLiteralRange
+ # | nestedTraversal
+ # | terminatedTraversal
+ # | genericLiteralMap
+ # ;
+
+ - name: GenericLiteral
+ type:
+ union:
+ - name: integer
+ type: integer
+
+ - name: float
+ type: float
+
+ - name: boolean
+ type: boolean
+
+ - name: string
+ type: string
+
+ - name: date
+ type: DateLiteral
+
+ - name: "null"
+
+ # TODO: others
+
+ # genericLiteralMap
+ # : LBRACK (genericLiteral)? COLON (genericLiteral)? (COMMA (genericLiteral)? COLON (genericLiteral)?)* RBRACK
+ # ;
+ #
+ # integerLiteral
+ # : IntegerLiteral
+ # ;
+ #
+ # floatLiteral
+ # : FloatingPointLiteral
+ # ;
+ #
+ # booleanLiteral
+ # : BooleanLiteral
+ # ;
+ #
+ # stringLiteral
+ # : NonEmptyStringLiteral
+ # | EmptyStringLiteral
+ # | gremlinStringConstants
+ # ;
+
+ - name: StringLiteral
+ type:
+ union:
+ - name: empty
+ type: EmptyStringLiteral
+
+ - name: nonEmpty
+ type: NonEmptyStringLiteral
+
+ - name: constant
+ type: constants.GremlinStringConstant
+
+ # dateLiteral
+ # : 'datetime' LPAREN stringLiteral RPAREN
+ # ;
+
+ - name: DateLiteral
+ type: string
+
+# nullLiteral
+# : NullLiteral
+# ;
+#
diff --git a/gremlin-language/src/main/yaml/org/apache/tinkerpop/gremlin/language/model/methods.yaml b/gremlin-language/src/main/yaml/org/apache/tinkerpop/gremlin/language/model/methods.yaml
new file mode 100644
index 0000000..ca2369e
--- /dev/null
+++ b/gremlin-language/src/main/yaml/org/apache/tinkerpop/gremlin/language/model/methods.yaml
@@ -0,0 +1,113 @@
+status: experimental
+
+definitions:
+
+ # traversalSackMethod
+ # : 'normSack' | 'Barrier.normSack'
+ # ;
+
+ - name: TraversalSackMethod
+
+ # traversalSelfMethod
+ # : traversalSelfMethod_none
+ # ;
+
+ - name: TraversalSelfMethod
+ type:
+ union:
+ - name: none
+
+ # traversalSelfMethod_none
+ # : 'none' LPAREN RPAREN
+ # ;
+ #
+ #
+
+ # traversalTerminalMethod
+ # : traversalTerminalMethod_explain
+ # | traversalTerminalMethod_iterate
+ # | traversalTerminalMethod_hasNext
+ # | traversalTerminalMethod_tryNext
+ # | traversalTerminalMethod_next
+ # | traversalTerminalMethod_toList
+ # | traversalTerminalMethod_toSet
+ # | traversalTerminalMethod_toBulkSet
+ # ;
+
+ - name: TraversalTerminalMethod
+ type:
+ union:
+ - name: explain
+ type: ExplainMethod
+
+ - name: iterate
+ type: IterateMethod
+
+ - name: hasNext
+ type: HasNextMethod
+
+ - name: tryNext
+ type: TryNextMethod
+
+ - name: next
+ type: NextMethod
+
+ - name: toList
+ type: ToListMethod
+
+ - name: toSet
+ type: ToSetMethod
+
+ - name: toBulkSet
+ type: ToBulkSetMethod
+
+ # traversalTerminalMethod_explain
+ # : 'explain' LPAREN RPAREN
+ # ;
+
+ - name: ExplainMethod
+
+ # traversalTerminalMethod_hasNext
+ # : 'hasNext' LPAREN RPAREN
+ # ;
+
+ - name: HasNextMethod
+
+ # traversalTerminalMethod_iterate
+ # : 'iterate' LPAREN RPAREN
+ # ;
+
+ - name: IterateMethod
+
+ # traversalTerminalMethod_tryNext
+ # : 'tryNext' LPAREN RPAREN
+ # ;
+
+ - name: TryNextMethod
+
+ # traversalTerminalMethod_next
+ # : 'next' LPAREN RPAREN
+ # | 'next' LPAREN integerLiteral RPAREN
+ # ;
+
+ - name: NextMethod
+ type:
+ optional: integer
+
+ # traversalTerminalMethod_toList
+ # : 'toList' LPAREN RPAREN
+ # ;
+
+ - name: ToListMethod
+
+ # traversalTerminalMethod_toSet
+ # : 'toSet' LPAREN RPAREN
+ # ;
+
+ - name: ToSetMethod
+
+ # traversalTerminalMethod_toBulkSet
+ # : 'toBulkSet' LPAREN RPAREN
+ # ;
+
+ - name: ToBulkSetMethod
diff --git a/gremlin-language/src/main/yaml/org/apache/tinkerpop/gremlin/language/model/predicates.yaml b/gremlin-language/src/main/yaml/org/apache/tinkerpop/gremlin/language/model/predicates.yaml
new file mode 100644
index 0000000..17bacb8
--- /dev/null
+++ b/gremlin-language/src/main/yaml/org/apache/tinkerpop/gremlin/language/model/predicates.yaml
@@ -0,0 +1,234 @@
+status: experimental
+
+includes:
+ - literals
+
+definitions:
+
+ # traversalPredicate
+ # : traversalPredicate_eq
+ # | traversalPredicate_neq
+ # | traversalPredicate_lt
+ # | traversalPredicate_lte
+ # | traversalPredicate_gt
+ # | traversalPredicate_gte
+ # | traversalPredicate_inside
+ # | traversalPredicate_outside
+ # | traversalPredicate_between
+ # | traversalPredicate_within
+ # | traversalPredicate_without
+ # | traversalPredicate_not
+ # | traversalPredicate_startingWith
+ # | traversalPredicate_notStartingWith
+ # | traversalPredicate_endingWith
+ # | traversalPredicate_notEndingWith
+ # | traversalPredicate_containing
+ # | traversalPredicate_notContaining
+ # | traversalPredicate DOT 'and' LPAREN traversalPredicate RPAREN
+ # | traversalPredicate DOT 'or' LPAREN traversalPredicate RPAREN
+ # | traversalPredicate DOT 'negate' LPAREN RPAREN
+ # ;
+
+ - name: TraversalPredicate
+ type:
+ union:
+ - name: eq
+ type: Eq
+
+ - name: neq
+ type: Neq
+
+ - name: lt
+ type: Lt
+
+ - name: lte
+ type: Lte
+
+ - name: gt
+ type: Gt
+
+ - name: gte
+ type: Gte
+
+ - name: inside
+ type: Inside
+
+ - name: outside
+ type: Outside
+
+ - name: between
+ type: Between
+
+ - name: within
+ type: Within
+
+ - name: without
+ type: Without
+
+ - name: not
+ type: Not
+
+ - name: startingWith
+ type: StartingWith
+
+ - name: notStartingWith
+ type: NotStartingWith
+
+ - name: endingWith
+ type: NotEndingWith
+
+ - name: containing
+ type: NotContaining
+
+ - name: and
+ type: TraversalPredicate
+
+ - name: or
+ type: TraversalPredicate
+
+ - name: negate
+
+ # traversalPredicate_eq
+ # : ('P.eq' | 'eq') LPAREN genericLiteral RPAREN
+ # ;
+ - name: Eq
+ type: literals.GenericLiteral
+
+ # traversalPredicate_neq
+ # : ('P.neq' | 'neq') LPAREN genericLiteral RPAREN
+ # ;
+
+ - name: Neq
+ type: literals.GenericLiteral
+
+ # traversalPredicate_lt
+ # : ('P.lt' | 'lt') LPAREN genericLiteral RPAREN
+ # ;
+
+ - name: Lt
+ type: literals.GenericLiteral
+
+ # traversalPredicate_lte
+ # : ('P.lte' | 'lte') LPAREN genericLiteral RPAREN
+ # ;
+
+ - name: Lte
+ type: literals.GenericLiteral
+
+ # traversalPredicate_gt
+ # : ('P.gt' | 'gt') LPAREN genericLiteral RPAREN
+ # ;
+
+ - name: Gt
+ type: literals.GenericLiteral
+
+ # traversalPredicate_gte
+ # : ('P.gte' | 'gte') LPAREN genericLiteral RPAREN
+ # ;
+
+ - name: Gte
+ type: literals.GenericLiteral
+
+ # traversalPredicate_inside
+ # : ('P.inside' | 'inside') LPAREN genericLiteral COMMA genericLiteral RPAREN
+ # ;
+
+ - name: Inside
+ type:
+ record:
+ - name: min
+ type: literals.GenericLiteral
+
+ - name: max
+ type: literals.GenericLiteral
+
+ # traversalPredicate_outside
+ # : ('P.outside' | 'outside') LPAREN genericLiteral COMMA genericLiteral RPAREN
+ # ;
+
+ - name: Outside
+ type:
+ record:
+ - name: min
+ type: literals.GenericLiteral
+
+ - name: max
+ type: literals.GenericLiteral
+
+ # traversalPredicate_between
+ # : ('P.between' | 'between') LPAREN genericLiteral COMMA genericLiteral RPAREN
+ # ;
+
+ - name: Between
+ type:
+ record:
+ - name: min
+ type: literals.GenericLiteral
+
+ - name: max
+ type: literals.GenericLiteral
+
+ # traversalPredicate_within
+ # : ('P.within' | 'within') LPAREN genericLiteralList RPAREN
+ # ;
+
+ - name: Within
+ type:
+ list: literals.GenericLiteral
+
+ # traversalPredicate_without
+ # : ('P.without' | 'without') LPAREN genericLiteralList RPAREN
+ # ;
+
+ - name: Without
+ type:
+ list: literals.GenericLiteral
+
+ # traversalPredicate_not
+ # : ('P.not' | 'not') LPAREN traversalPredicate RPAREN
+ # ;
+
+ - name: Not
+ type: string
+
+ # traversalPredicate_containing
+ # : ('TextP.containing' | 'containing') LPAREN stringLiteral RPAREN
+ # ;
+
+ - name: Containing
+ type: string
+
+ # traversalPredicate_notContaining
+ # : ('TextP.notContaining' | 'notContaining') LPAREN stringLiteral RPAREN
+ # ;
+
+ - name: NotContaining
+ type: string
+
+ # traversalPredicate_startingWith
+ # : ('TextP.startingWith' | 'startingWith') LPAREN stringLiteral RPAREN
+ # ;
+
+ - name: StartingWith
+ type: string
+
+ # traversalPredicate_notStartingWith
+ # : ('TextP.notStartingWith' | 'notStartingWith') LPAREN stringLiteral RPAREN
+ # ;
+
+ - name: NotStartingWith
+ type: string
+
+ # traversalPredicate_endingWith
+ # : ('TextP.endingWith' | 'endingWith') LPAREN stringLiteral RPAREN
+ # ;
+
+ - name: EndingWith
+ type: string
+
+ # traversalPredicate_notEndingWith
+ # : ('TextP.notEndingWith' | 'notEndingWith') LPAREN stringLiteral RPAREN
+ # ;
+
+ - name: NotEndingWith
+ type: string
diff --git a/gremlin-language/src/main/yaml/org/apache/tinkerpop/gremlin/language/model/query.yaml b/gremlin-language/src/main/yaml/org/apache/tinkerpop/gremlin/language/model/query.yaml
new file mode 100644
index 0000000..85ef1d5
--- /dev/null
+++ b/gremlin-language/src/main/yaml/org/apache/tinkerpop/gremlin/language/model/query.yaml
@@ -0,0 +1,60 @@
+status: experimental
+
+includes:
+ - methods
+ - traversal
+
+definitions:
+
+ # queryList
+ # : query (SEMI? query)* SEMI? EOF
+ # ;
+ #
+ # query
+ # : traversalSource (DOT transactionPart)?
+ # | rootTraversal (DOT traversalTerminalMethod)?
+ # | query DOT 'toString' LPAREN RPAREN
+ # | emptyQuery
+ # ;
+
+ - name: Query
+ type:
+ union:
+ - name: withSource
+ type:
+ record:
+ - name: source
+ type: traversal.TraversalSource
+
+ - name: transactionPart
+ type:
+ optional: TransactionPart
+
+ - name: withRoot
+ type:
+ record:
+ - name: root
+ type: traversal.RootTraversal
+
+ - name: method
+ type:
+ optional: methods.TraversalTerminalMethod
+
+ - name: toString
+ type: Query
+
+ - name: empty
+
+ # emptyQuery
+ # : EmptyStringLiteral
+ # ;
+
+ # transactionPart
+ # : 'tx' LPAREN RPAREN DOT ('commit' | 'rollback')? LPAREN RPAREN
+ # ;
+
+ - name: TransactionPart
+ type:
+ enum:
+ - commit
+ - rollback
diff --git a/gremlin-language/src/main/yaml/org/apache/tinkerpop/gremlin/language/model/steps.yaml b/gremlin-language/src/main/yaml/org/apache/tinkerpop/gremlin/language/model/steps.yaml
new file mode 100644
index 0000000..edafef7
--- /dev/null
+++ b/gremlin-language/src/main/yaml/org/apache/tinkerpop/gremlin/language/model/steps.yaml
@@ -0,0 +1,1802 @@
+# /*********************************************
+# GENERATED GRAMMAR - DO NOT CHANGE
+# **********************************************/
+
+status: experimental
+
+includes:
+ - literals
+ - methods
+ - predicates
+ - traversal
+
+definitions:
+
+# traversalMethod
+# : traversalMethod_V
+# | traversalMethod_addE
+# | traversalMethod_addV
+# | traversalMethod_aggregate
+# | traversalMethod_and
+# | traversalMethod_as
+# | traversalMethod_barrier
+# | traversalMethod_both
+# | traversalMethod_bothE
+# | traversalMethod_bothV
+# | traversalMethod_branch
+# | traversalMethod_by
+# | traversalMethod_cap
+# | traversalMethod_choose
+# | traversalMethod_coalesce
+# | traversalMethod_coin
+# | traversalMethod_connectedComponent
+# | traversalMethod_constant
+# | traversalMethod_count
+# | traversalMethod_cyclicPath
+# | traversalMethod_dedup
+# | traversalMethod_drop
+# | traversalMethod_elementMap
+# | traversalMethod_emit
+# | traversalMethod_filter
+# | traversalMethod_flatMap
+# | traversalMethod_fold
+# | traversalMethod_from
+# | traversalMethod_group
+# | traversalMethod_groupCount
+# | traversalMethod_has
+# | traversalMethod_hasId
+# | traversalMethod_hasKey
+# | traversalMethod_hasLabel
+# | traversalMethod_hasNot
+# | traversalMethod_hasValue
+# | traversalMethod_id
+# | traversalMethod_identity
+# | traversalMethod_in
+# | traversalMethod_inE
+# | traversalMethod_inV
+# | traversalMethod_index
+# | traversalMethod_inject
+# | traversalMethod_is
+# | traversalMethod_key
+# | traversalMethod_label
+# | traversalMethod_limit
+# | traversalMethod_local
+# | traversalMethod_loops
+# | traversalMethod_map
+# | traversalMethod_match
+# | traversalMethod_math
+# | traversalMethod_max
+# | traversalMethod_mean
+# | traversalMethod_min
+# | traversalMethod_not
+# | traversalMethod_option
+# | traversalMethod_optional
+# | traversalMethod_or
+# | traversalMethod_order
+# | traversalMethod_otherV
+# | traversalMethod_out
+# | traversalMethod_outE
+# | traversalMethod_outV
+# | traversalMethod_pageRank
+# | traversalMethod_path
+# | traversalMethod_peerPressure
+# | traversalMethod_profile
+# | traversalMethod_project
+# | traversalMethod_properties
+# | traversalMethod_property
+# | traversalMethod_propertyMap
+# | traversalMethod_range
+# | traversalMethod_read
+# | traversalMethod_repeat
+# | traversalMethod_sack
+# | traversalMethod_sample
+# | traversalMethod_select
+# | traversalMethod_shortestPath
+# | traversalMethod_sideEffect
+# | traversalMethod_simplePath
+# | traversalMethod_skip
+# | traversalMethod_store
+# | traversalMethod_subgraph
+# | traversalMethod_sum
+# | traversalMethod_tail
+# | traversalMethod_timeLimit
+# | traversalMethod_times
+# | traversalMethod_to
+# | traversalMethod_toE
+# | traversalMethod_toV
+# | traversalMethod_tree
+# | traversalMethod_unfold
+# | traversalMethod_union
+# | traversalMethod_until
+# | traversalMethod_value
+# | traversalMethod_valueMap
+# | traversalMethod_values
+# | traversalMethod_where
+# | traversalMethod_with
+# | traversalMethod_write
+# ;
+
+ - name: TraversalMethod
+ type:
+ union:
+ - name: v
+ type: VStep
+
+ - name: addE
+ type: AddEStep
+
+ - name: addV
+ type: AddVStep
+
+ - name: aggregate
+ type: AggregateStep
+
+ - name: and
+ type: AndStep
+
+ - name: as
+ type: AsStep
+
+ - name: barrier
+ type: BarrierStep
+
+ - name: both
+ type: BothStep
+
+ - name: bothE
+ type: BothEStep
+
+ - name: bothV
+ type: BothVStep
+
+ - name: branch
+ type: BranchStep
+
+ - name: by
+ type: ByStep
+
+ - name: cap
+ type: CapStep
+
+ - name: choose
+ type: ChooseStep
+
+ - name: coalesce
+ type: CoalesceStep
+
+ - name: coin
+ type: CoinStep
+
+ - name: connectedComponent
+ type: ConnectedComponentStep
+
+ - name: constant
+ type: ConstantStep
+
+ - name: count
+ type: CountStep
+
+ - name: cyclicPath
+ type: CyclicPathStep
+
+ - name: dedup
+ type: DedupStep
+
+ - name: drop
+ type: DropStep
+
+ - name: elementMap
+ type: ElementMapStep
+
+ - name: emit
+ type: EmitStep
+
+ - name: filter
+ type: FilterStep
+
+ - name: flatMap
+ type: FlatMapStep
+
+ - name: fold
+ type: FoldStep
+
+ - name: from
+ type: FromStep
+
+ - name: group
+ type: GroupStep
+
+ - name: groupCount
+ type: GroupCountStep
+
+ - name: has
+ type: HasStep
+
+ - name: hasId
+ type: HasIdStep
+
+ - name: hasKey
+ type: HasKeyStep
+
+ - name: hasLabel
+ type: HasLabelStep
+
+ - name: hasNot
+ type: HasNotStep
+
+ - name: hasValue
+ type: HasValueStep
+
+ - name: id
+ type: IdStep
+
+ - name: identity
+ type: IdentityStep
+
+ - name: in
+ type: InStep
+
+ - name: inE
+ type: InEStep
+
+ - name: inV
+ type: InVStep
+
+ - name: index
+ type: IndexStep
+
+ - name: inject
+ type: InjectStep
+
+ - name: is
+ type: IsStep
+
+ - name: key
+ type: KeyStep
+
+ - name: label
+ type: LabelStep
+
+ - name: limit
+ type: LimitStep
+
+ - name: local
+ type: LocalStep
+
+ - name: loops
+ type: LoopsStep
+
+ - name: map
+ type: MapStep
+
+ - name: match
+ type: MatchStep
+
+ - name: math
+ type: MathStep
+
+ - name: max
+ type: MaxStep
+
+ - name: mean
+ type: MeanStep
+
+ - name: min
+ type: MinStep
+
+ - name: not
+ type: NotStep
+
+ - name: option
+ type: OptionStep
+
+ - name: optional
+ type: OptionalStep
+
+ - name: or
+ type: OrStep
+
+ - name: order
+ type: OrderStep
+
+ - name: otherV
+ type: OtherVStep
+
+ - name: out
+ type: OutStep
+
+ - name: outE
+ type: OutEStep
+
+ - name: outV
+ type: OutVStep
+
+ - name: pageRank
+ type: PageRankStep
+
+ - name: path
+ type: PathStep
+
+ - name: peerPressure
+ type: PeerPressureStep
+
+ - name: profile
+ type: ProfileStep
+
+ - name: project
+ type: ProjectStep
+
+ - name: properties
+ type: PropertiesStep
+
+ - name: property
+ type: PropertyStep
+
+ - name: propertyMap
+ type: PropertyMapStep
+
+ - name: range
+ type: RangeStep
+
+ - name: read
+ type: ReadStep
+
+ - name: repeat
+ type: RepeatStep
+
+ - name: sack
+ type: SackStep
+
+ - name: sample
+ type: SampleStep
+
+ - name: select
+ type: SelectStep
+
+ - name: shortestPath
+ type: ShortestPathStep
+
+ - name: sideEffect
+ type: SideEffectStep
+
+ - name: simplePath
+ type: SimplePathStep
+
+ - name: skip
+ type: SkipStep
+
+ - name: store
+ type: StoreStep
+
+ - name: subgraph
+ type: SubgraphStep
+
+ - name: sum
+ type: SumStep
+
+ - name: tail
+ type: TailStep
+
+ - name: timeLimit
+ type: TimeLimitStep
+
+ - name: times
+ type: TimesStep
+
+ - name: to
+ type: ToStep
+
+ - name: toE
+ type: ToEStep
+
+ - name: toV
+ type: ToVStep
+
+ - name: tree
+ type: TreeStep
+
+ - name: unfold
+ type: UnfoldStep
+
+ - name: union
+ type: UnionStep
+
+ - name: until
+ type: UntilStep
+
+ - name: value
+ type: ValueStep
+
+ - name: valueMap
+ type: ValueMapStep
+
+ - name: values
+ type: ValuesStep
+
+ - name: where
+ type: WhereStep
+
+ - name: with
+ type: WithStep
+
+ - name: write
+ type: WriteStep
+
+# traversalMethod_V
+# : 'V' LPAREN genericLiteralList RPAREN
+# ;
+
+ - name: VStep
+ properties:
+ - type: annotations.StepName
+ value: "V"
+ type:
+ record:
+ - name: vertexIdsOrElements
+ type:
+ list: literals.GenericLiteral
+
+# traversalMethod_addE
+# : 'addE' LPAREN stringLiteral RPAREN #traversalMethod_addE_String
+# | 'addE' LPAREN nestedTraversal RPAREN #traversalMethod_addE_Traversal
+# ;
+
+ - name: AddEStep
+ type:
+ union:
+ - name: edgeLabel
+ type: string
+
+ - name: edgeLabelTraversal
+ type: traversal.NestedTraversal
+
+# traversalMethod_addV
+# : 'addV' LPAREN RPAREN #traversalMethod_addV_Empty
+# | 'addV' LPAREN stringLiteral RPAREN #traversalMethod_addV_String
+# | 'addV' LPAREN nullLiteral RPAREN #traversalMethod_addV_String // null means use the default vertex label
+# | 'addV' LPAREN nestedTraversal RPAREN #traversalMethod_addV_Traversal
+# ;
+
+ - name: AddVStep
+ type:
+ union:
+ - name: empty
+
+ - name: vertexLabel
+ type: string
+
+ - name: "null"
+
+ - name: vertexLabelTraversal
+ type: traversal.NestedTraversal
+
+# traversalMethod_aggregate
+# : 'aggregate' LPAREN traversalScope COMMA stringLiteral RPAREN #traversalMethod_aggregate_Scope_String
+# | 'aggregate' LPAREN stringLiteral RPAREN #traversalMethod_aggregate_String
+# ;
+
+ - name: AggregateStep
+ type:
+ record:
+ - name: scope
+ type:
+ optional: traversal.TraversalScope
+
+ - name: sideEffectKey
+ type: string
+
+# traversalMethod_and
+# : 'and' LPAREN nestedTraversalList RPAREN
+# ;
+
+ - name: AndStep
+ type:
+ record:
+ - name: andTraversals
+ type:
+ list: traversal.NestedTraversal
+
+# traversalMethod_as
+# : 'as' LPAREN stringLiteral (COMMA stringLiteralList)? RPAREN
+# ;
+
+ - name: AsStep
+ type:
+ record:
+ - name: stepLabel
+ type: string
+
+ - name: stepLabels
+ type:
+ list: string
+
+# traversalMethod_barrier
+# : 'barrier' LPAREN traversalSackMethod RPAREN #traversalMethod_barrier_Consumer
+# | 'barrier' LPAREN RPAREN #traversalMethod_barrier_Empty
+# | 'barrier' LPAREN integerLiteral RPAREN #traversalMethod_barrier_int
+# ;
+
+ - name: BarrierStep
+ type:
+ optional:
+ union:
+ - name: barrierConsumer
+ type: methods.TraversalSackMethod
+
+ - name: maxBarrierSize
+ type: integer
+
+ # traversalMethod_both
+# : 'both' LPAREN stringLiteralList RPAREN
+# ;
+
+ - name: BothStep
+ type:
+ record:
+ - name: edgeLabels
+ type:
+ list: string
+
+# traversalMethod_bothE
+# : 'bothE' LPAREN stringLiteralList RPAREN
+# ;
+
+ - name: BothEStep
+ type:
+ record:
+ - name: edgeLabels
+ type:
+ list: string
+
+# traversalMethod_bothV
+# : 'bothV' LPAREN RPAREN
+# ;
+
+ - name: BothVStep
+
+# traversalMethod_branch
+# : 'branch' LPAREN nestedTraversal RPAREN
+# ;
+
+ - name: BranchStep
+ type:
+ record:
+ - name: branchTraversal
+ type: traversal.NestedTraversal
+
+# traversalMethod_by
+# : 'by' LPAREN traversalComparator RPAREN #traversalMethod_by_Comparator
+# | 'by' LPAREN RPAREN #traversalMethod_by_Empty
+# | 'by' LPAREN traversalFunction RPAREN #traversalMethod_by_Function
+# | 'by' LPAREN traversalFunction COMMA traversalComparator RPAREN #traversalMethod_by_Function_Comparator
+# | 'by' LPAREN traversalOrder RPAREN #traversalMethod_by_Order
+# | 'by' LPAREN stringLiteral RPAREN #traversalMethod_by_String
+# | 'by' LPAREN stringLiteral COMMA traversalComparator RPAREN #traversalMethod_by_String_Comparator
+# | 'by' LPAREN traversalToken RPAREN #traversalMethod_by_T
+# | 'by' LPAREN nestedTraversal RPAREN #traversalMethod_by_Traversal
+# | 'by' LPAREN nestedTraversal COMMA traversalComparator RPAREN #traversalMethod_by_Traversal_Comparator
+# ;
+
+ - name: ByStep
+ type:
+ optional:
+ union:
+ - name: withTraversal
+ type:
+ record:
+ - name: traversal
+ type: traversal.NestedTraversal
+
+ - name: comparator
+ type: traversal.TraversalComparator
+
+ - name: withKey
+ type:
+ record:
+ - name: key
+ type: string
+
+ - name: comparator
+ type:
+ optional: traversal.TraversalComparator
+
+ - name: withFunction
+ type:
+ record:
+ - name: function
+ type: traversal.TraversalFunction
+
+ - name: comparator
+ type:
+ optional: traversal.TraversalComparator
+
+ - name: token
+ type: traversal.TraversalToken
+
+ - name: comparator
+ type: traversal.TraversalComparator
+
+ - name: order
+ type: traversal.TraversalOrder
+
+# traversalMethod_cap
+# : 'cap' LPAREN stringLiteral (COMMA stringLiteralList)? RPAREN
+# ;
+
+ - name: CapStep
+ type:
+ record:
+ - name: sideEffectKey
+ type: string
+
+ - name: sideEffectKeys
+ type:
+ list: string
+
+# traversalMethod_choose
+# : 'choose' LPAREN traversalFunction RPAREN #traversalMethod_choose_Function
+# | 'choose' LPAREN traversalPredicate COMMA nestedTraversal RPAREN #traversalMethod_choose_Predicate_Traversal
+# | 'choose' LPAREN traversalPredicate COMMA nestedTraversal COMMA nestedTraversal RPAREN #traversalMethod_choose_Predicate_Traversal_Traversal
+# | 'choose' LPAREN nestedTraversal RPAREN #traversalMethod_choose_Traversal
+# | 'choose' LPAREN nestedTraversal COMMA nestedTraversal RPAREN #traversalMethod_choose_Traversal_Traversal
+# | 'choose' LPAREN nestedTraversal COMMA nestedTraversal COMMA nestedTraversal RPAREN #traversalMethod_choose_Traversal_Traversal_Traversal
+# ;
+
+ - name: ChooseStep
+ type:
+ union:
+ - name: choiceTraversal
+ type: traversal.NestedTraversal
+
+ - name: withTraversal
+ type:
+ record:
+ - name: traversalPredicate
+ type: traversal.NestedTraversal
+
+ - name: trueChoice
+ type: predicates.TraversalPredicate
+
+ - name: falseChoice
+ type:
+ optional: predicates.TraversalPredicate
+
+ - name: withPredicate
+ type:
+ record:
+ - name: traversalPredicate
+ type: predicates.TraversalPredicate
+
+ - name: trueChoice
+ type: predicates.TraversalPredicate
+
+ - name: falseChoice
+ type:
+ optional: predicates.TraversalPredicate
+
+# traversalMethod_coalesce
+# : 'coalesce' LPAREN nestedTraversalList RPAREN
+# ;
+
+ - name: CoalesceStep
+ type:
+ record:
+ - name: coalesceTraversals
+ type:
+ list: traversal.NestedTraversal
+
+# traversalMethod_coin
+# : 'coin' LPAREN floatLiteral RPAREN
+# ;
+
+ - name: CoinStep
+ type:
+ record:
+ - name: probability
+ type: float
+
+# traversalMethod_connectedComponent
+# : 'connectedComponent' LPAREN RPAREN
+# ;
+
+ - name: ConnectedComponentStep
+
+# traversalMethod_constant
+# : 'constant' LPAREN genericLiteral RPAREN
+# ;
+
+ - name: ConstantStep
+ type:
+ record:
+ - name: e
+ type: literals.GenericLiteral
+
+# traversalMethod_count
+# : 'count' LPAREN RPAREN #traversalMethod_count_Empty
+# | 'count' LPAREN traversalScope RPAREN #traversalMethod_count_Scope
+# ;
+
+ - name: CountStep
+ type:
+ record:
+ - name: scope
+ type:
+ optional: traversal.TraversalScope
+
+# traversalMethod_cyclicPath
+# : 'cyclicPath' LPAREN RPAREN
+# ;
+
+ - name: CyclicPathStep
+
+# traversalMethod_dedup
+# : 'dedup' LPAREN traversalScope (COMMA stringLiteralList)? RPAREN #traversalMethod_dedup_Scope_String
+# | 'dedup' LPAREN stringLiteralList RPAREN #traversalMethod_dedup_String
+# ;
+
+ - name: DedupStep
+ type:
+ record:
+ - name: scope
+ type:
+ optional: traversal.TraversalScope
+
+ - name: dedupLabels
+ type:
+ list: string
+
+# traversalMethod_drop
+# : 'drop' LPAREN RPAREN
+# ;
+
+ - name: DropStep
+
+# traversalMethod_elementMap
+# : 'elementMap' LPAREN stringLiteralList RPAREN
+# ;
+
+ - name: ElementMapStep
+ type:
+ record:
+ - name: propertyKeys
+ type:
+ list: string
+
+# traversalMethod_emit
+# : 'emit' LPAREN RPAREN #traversalMethod_emit_Empty
+# | 'emit' LPAREN traversalPredicate RPAREN #traversalMethod_emit_Predicate
+# | 'emit' LPAREN nestedTraversal RPAREN #traversalMethod_emit_Traversal
+# ;
+
+ - name: EmitStep
+ type:
+ optional:
+ union:
+ - name: emitPredicate
+ type: predicates.TraversalPredicate
+
+ - name: emitTraversal
+ type: traversal.NestedTraversal
+
+# traversalMethod_filter
+# : 'filter' LPAREN traversalPredicate RPAREN #traversalMethod_filter_Predicate
+# | 'filter' LPAREN nestedTraversal RPAREN #traversalMethod_filter_Traversal
+# ;
+
+ - name: FilterStep
+ type:
+ union:
+ - name: predicate
+ type: predicates.TraversalPredicate
+
+ - name: filterTraversal
+ type: traversal.NestedTraversal
+
+# traversalMethod_flatMap
+# : 'flatMap' LPAREN nestedTraversal RPAREN
+# ;
+
+ - name: FlatMapStep
+ type:
+ record:
+ - name: flatMapTraversal
+ type: traversal.NestedTraversal
+
+# traversalMethod_fold
+# : 'fold' LPAREN RPAREN #traversalMethod_fold_Empty
+# | 'fold' LPAREN genericLiteral COMMA traversalBiFunction RPAREN #traversalMethod_fold_Object_BiFunction
+# ;
+
+ - name: FoldStep
+ type:
+ optional:
+ record:
+ - name: seed
+ type: literals.GenericLiteral
+
+ - name: foldFunction
+ type: traversal.TraversalBiFunction
+
+# traversalMethod_from
+# : 'from' LPAREN stringLiteral RPAREN #traversalMethod_from_String
+# | 'from' LPAREN nestedTraversal RPAREN #traversalMethod_from_Traversal
+# ;
+
+ - name: FromStep
+ type:
+ union:
+ - name: fromStepLabel
+ type: string
+
+ - name: fromVertex
+ type: traversal.NestedTraversal
+
+# traversalMethod_group
+# : 'group' LPAREN RPAREN #traversalMethod_group_Empty
+# | 'group' LPAREN stringLiteral RPAREN #traversalMethod_group_String
+# ;
+
+ - name: GroupStep
+ type:
+ record:
+ - name: sideEffectKey
+ type:
+ optional: string
+
+# traversalMethod_groupCount
+# : 'groupCount' LPAREN RPAREN #traversalMethod_groupCount_Empty
+# | 'groupCount' LPAREN stringLiteral RPAREN #traversalMethod_groupCount_String
+# ;
+
+ - name: GroupCountStep
+ type:
+ record:
+ - name: sideEffectKey
+ type:
+ optional: string
+
+# traversalMethod_has
+# : 'has' LPAREN stringLiteral RPAREN #traversalMethod_has_String
+# | 'has' LPAREN stringLiteral COMMA genericLiteral RPAREN #traversalMethod_has_String_Object
+# | 'has' LPAREN stringLiteral COMMA traversalPredicate RPAREN #traversalMethod_has_String_P
+# | 'has' LPAREN stringLiteral COMMA stringLiteral COMMA genericLiteral RPAREN #traversalMethod_has_String_String_Object
+# | 'has' LPAREN stringLiteral COMMA stringLiteral COMMA traversalPredicate RPAREN #traversalMethod_has_String_String_P
+# | 'has' LPAREN stringLiteral COMMA nestedTraversal RPAREN #traversalMethod_has_String_Traversal
+# | 'has' LPAREN traversalToken COMMA genericLiteral RPAREN #traversalMethod_has_T_Object
+# | 'has' LPAREN traversalToken COMMA traversalPredicate RPAREN #traversalMethod_has_T_P
+# | 'has' LPAREN traversalToken COMMA nestedTraversal RPAREN #traversalMethod_has_T_Traversal
+# ;
+
+ - name: HasStep
+ type:
+ union:
+ - name: withPropertyKey
+ type:
+ record:
+ - name: propertyKey
+ type: string
+
+ - name: otherArguments
+ type:
+ optional:
+ union:
+ - name: predicate
+ type: predicates.TraversalPredicate
+
+ - name: value
+ type: literals.GenericLiteral
+
+ - name: traversal
+ type: traversal.NestedTraversal
+
+ - name: withAccessor
+ type:
+ record:
+ - name: accessor
+ type: traversal.TraversalToken
+
+ - name: other
+ type:
+ union:
+ - name: predicate
+ type: predicates.TraversalPredicate
+
+ - name: value
+ type: literals.GenericLiteral
+
+ - name: traversal
+ type: traversal.NestedTraversal
+
+ - name: withLabel
+ type:
+ record:
+ - name: label
+ type: string
+
+ - name: propertyKey
+ type: string
+
+ - name: other
+ type:
+ union:
+ - name: predicate
+ type: predicates.TraversalPredicate
+
+ - name: value
+ type: literals.GenericLiteral
+
+# traversalMethod_hasId
+# : 'hasId' LPAREN genericLiteral (COMMA genericLiteralList)? RPAREN #traversalMethod_hasId_Object_Object
+# | 'hasId' LPAREN traversalPredicate RPAREN #traversalMethod_hasId_P
+# ;
+
+ - name: HasIdStep
+ type:
+ union:
+ - name: predicate
+ type: predicates.TraversalPredicate
+
+ - name: withIds
+ type:
+ record:
+ - name: id
+ type: literals.GenericLiteral
+
+ - name: otherIds
+ type:
+ list: literals.GenericLiteral
+
+# traversalMethod_hasKey
+# : 'hasKey' LPAREN traversalPredicate RPAREN #traversalMethod_hasKey_P
+# | 'hasKey' LPAREN stringLiteral (COMMA stringLiteralList)? RPAREN #traversalMethod_hasKey_String_String
+# ;
+
+ - name: HasKeyStep
+ type:
+ union:
+ - name: predicate
+ type: predicates.TraversalPredicate
+
+ - name: withLabels
+ type:
+ record:
+ - name: label
+ type: string
+
+ - name: otherLabels
+ type:
+ list: string
+
+# traversalMethod_hasLabel
+# : 'hasLabel' LPAREN traversalPredicate RPAREN #traversalMethod_hasLabel_P
+# | 'hasLabel' LPAREN stringLiteral (COMMA stringLiteralList)? RPAREN #traversalMethod_hasLabel_String_String
+# ;
+
+ - name: HasLabelStep
+ type:
+ union:
+ - name: predicate
+ type: predicates.TraversalPredicate
+
+ - name: withLabels
+ type:
+ record:
+ - name: label
+ type: string
+
+ - name: otherLabels
+ type:
+ list: string
+
+# traversalMethod_hasNot
+# : 'hasNot' LPAREN stringLiteral RPAREN
+# ;
+
+ - name: HasNotStep
+ type:
+ record:
+ - name: propertyKey
+ type: string
+
+# traversalMethod_hasValue
+# : 'hasValue' LPAREN genericLiteral (COMMA genericLiteralList)? RPAREN #traversalMethod_hasValue_Object_Object
+# | 'hasValue' LPAREN traversalPredicate RPAREN #traversalMethod_hasValue_P
+# ;
+
+ - name: HasValueStep
+ type:
+ union:
+ - name: predicate
+ type: predicates.TraversalPredicate
+
+ - name: withValues
+ type:
+ - name: value
+ type: literals.GenericLiteral
+
+ - name: otherValues
+ type:
+ list: literals.GenericLiteral
+
+# traversalMethod_id
+# : 'id' LPAREN RPAREN
+# ;
+
+ - name: IdStep
+
+# traversalMethod_identity
+# : 'identity' LPAREN RPAREN
+# ;
+
+ - name: IdentityStep
+
+# traversalMethod_in
+# : 'in' LPAREN stringLiteralList RPAREN
+# ;
+
+ - name: InStep
+ type:
+ record:
+ - name: edgeLabels
+ type:
+ list: string
+
+# traversalMethod_inE
+# : 'inE' LPAREN stringLiteralList RPAREN
+# ;
+
+ - name: InEStep
+ type:
+ record:
+ - name: edgeLabels
+ type:
+ list: string
+
+# traversalMethod_inV
+# : 'inV' LPAREN RPAREN
+# ;
+
+ - name: InVStep
+
+# traversalMethod_index
+# : 'index' LPAREN RPAREN
+# ;
+
+ - name: IndexStep
+
+# traversalMethod_inject
+# : 'inject' LPAREN genericLiteralList RPAREN
+# ;
+
+ - name: InjectStep
+ type:
+ record:
+ - name: injections
+ type:
+ list: literals.GenericLiteral
+
+# traversalMethod_is
+# : 'is' LPAREN genericLiteral RPAREN #traversalMethod_is_Object
+# | 'is' LPAREN traversalPredicate RPAREN #traversalMethod_is_P
+# ;
+
+ - name: IsStep
+ type:
+ union:
+ - name: predicate
+ type: predicates.TraversalPredicate
+
+ - name: value
+ type: literals.GenericLiteral
+
+# traversalMethod_key
+# : 'key' LPAREN RPAREN
+# ;
+
+ - name: KeyStep
+
+# traversalMethod_label
+# : 'label' LPAREN RPAREN
+# ;
+
+ - name: LabelStep
+
+# traversalMethod_limit
+# : 'limit' LPAREN traversalScope COMMA integerLiteral RPAREN #traversalMethod_limit_Scope_long
+# | 'limit' LPAREN integerLiteral RPAREN #traversalMethod_limit_long
+# ;
+
+ - name: LimitStep
+ type:
+ record:
+ - name: scope
+ type:
+ optional: traversal.TraversalScope
+
+ - name: limit
+ type: integer
+
+# traversalMethod_local
+# : 'local' LPAREN nestedTraversal RPAREN
+# ;
+
+ - name: LocalStep
+ type:
+ record:
+ - name: localTraversal
+ type: traversal.NestedTraversal
+
+# traversalMethod_loops
+# : 'loops' LPAREN RPAREN #traversalMethod_loops_Empty
+# | 'loops' LPAREN stringLiteral RPAREN #traversalMethod_loops_String
+# ;
+
+ - name: LoopsStep
+ type:
+ record:
+ - name: loopName
+ type:
+ optional: string
+
+# traversalMethod_map
+# : 'map' LPAREN nestedTraversal RPAREN
+# ;
+
+ - name: MapStep
+ type:
+ record:
+ - name: mapTraversal
+ type: traversal.NestedTraversal
+
+# traversalMethod_match
+# : 'match' LPAREN nestedTraversalList RPAREN
+# ;
+
+ - name: MatchStep
+ type:
+ record:
+ - name: matchTraversals
+ type:
+ list: traversal.NestedTraversal
+
+# traversalMethod_math
+# : 'math' LPAREN stringLiteral RPAREN
+# ;
+
+ - name: MathStep
+ type:
+ record:
+ - name: expression
+ type: string
+
+# traversalMethod_max
+# : 'max' LPAREN RPAREN #traversalMethod_max_Empty
+# | 'max' LPAREN traversalScope RPAREN #traversalMethod_max_Scope
+# ;
+
+ - name: MaxStep
+ type:
+ record:
+ - name: scope
+ type:
+ optional: traversal.TraversalScope
+
+# traversalMethod_mean
+# : 'mean' LPAREN RPAREN #traversalMethod_mean_Empty
+# | 'mean' LPAREN traversalScope RPAREN #traversalMethod_mean_Scope
+# ;
+
+ - name: MeanStep
+ type:
+ record:
+ - name: scope
+ type:
+ optional: traversal.TraversalScope
+
+# traversalMethod_min
+# : 'min' LPAREN RPAREN #traversalMethod_min_Empty
+# | 'min' LPAREN traversalScope RPAREN #traversalMethod_min_Scope
+# ;
+
+ - name: MinStep
+ type:
+ record:
+ - name: scope
+ type:
+ optional: traversal.TraversalScope
+
+# traversalMethod_not
+# : 'not' LPAREN nestedTraversal RPAREN
+# ;
+
+ - name: NotStep
+ type:
+ record:
+ - name: notTraversal
+ type: traversal.NestedTraversal
+
+# traversalMethod_option
+# : 'option' LPAREN traversalPredicate COMMA nestedTraversal RPAREN #traversalMethod_option_Predicate_Traversal
+# | 'option' LPAREN genericLiteral COMMA nestedTraversal RPAREN #traversalMethod_option_Object_Traversal
+# | 'option' LPAREN nestedTraversal RPAREN #traversalMethod_option_Traversal
+# ;
+
+ # TODO: the Java API does not agree with the grammar here
+ - name: OptionStep
+ type:
+ union:
+ - name: predicateTraversal
+ type:
+ record:
+ - name: predicate
+ type: predicates.TraversalPredicate
+
+ - name: traversal
+ type: traversal.NestedTraversal
+
+ - name: objectTraversal
+ type:
+ record:
+ - name: object
+ type: literals.GenericLiteral
+
+ - name: traversal
+ type: traversal.NestedTraversal
+
+ - name: traversal
+ type: traversal.NestedTraversal
+
+# traversalMethod_optional
+# : 'optional' LPAREN nestedTraversal RPAREN
+# ;
+
+ - name: OptionalStep
+ type:
+ record:
+ - name: optionalTraversal
+ type: traversal.NestedTraversal
+
+# traversalMethod_or
+# : 'or' LPAREN nestedTraversalList RPAREN
+# ;
+
+ - name: OrStep
+ type:
+ record:
+ - name: orTraversals
+ type:
+ list: traversal.NestedTraversal
+
+# traversalMethod_order
+# : 'order' LPAREN RPAREN #traversalMethod_order_Empty
+# | 'order' LPAREN traversalScope RPAREN #traversalMethod_order_Scope
+# ;
+
+ - name: OrderStep
+ type:
+ record:
+ - name: scope
+ type:
+ optional: traversal.TraversalScope
+
+# traversalMethod_otherV
+# : 'otherV' LPAREN RPAREN
+# ;
+
+ - name: OtherVStep
+
+# traversalMethod_out
+# : 'out' LPAREN stringLiteralList RPAREN
+# ;
+
+ - name: OutStep
+ type:
+ record:
+ - name: edgeLabels
+ type:
+ list: string
+
+# traversalMethod_outE
+# : 'outE' LPAREN stringLiteralList RPAREN
+# ;
+
+ - name: OutEStep
+ type:
+ record:
+ - name: edgeLabels
+ type:
+ list: string
+
+# traversalMethod_outV
+# : 'outV' LPAREN RPAREN
+# ;
+
+ - name: OutVStep
+
+# traversalMethod_pageRank
+# : 'pageRank' LPAREN RPAREN #traversalMethod_pageRank_Empty
+# | 'pageRank' LPAREN floatLiteral RPAREN #traversalMethod_pageRank_double
+# ;
+
+ - name: PageRankStep
+ type:
+ record:
+ - name: alpha
+ type:
+ optional: float
+
+# traversalMethod_path
+# : 'path' LPAREN RPAREN
+# ;
+
+ - name: PathStep
+
+# traversalMethod_peerPressure
+# : 'peerPressure' LPAREN RPAREN
+# ;
+
+ - name: PeerPressureStep
+
+# traversalMethod_profile
+# : 'profile' LPAREN RPAREN #traversalMethod_profile_Empty
+# | 'profile' LPAREN stringLiteral RPAREN #traversalMethod_profile_String
+# ;
+
+ - name: ProfileStep
+ type:
+ record:
+ - name: sideEffectKey
+ type:
+ optional: string
+
+# traversalMethod_project
+# : 'project' LPAREN stringLiteral (COMMA stringLiteralList)? RPAREN
+# ;
+
+ - name: ProjectStep
+ type:
+ record:
+ - name: projectKey
+ type: string
+
+ - name: otherProjectKeys
+ type:
+ list: string
+
+# traversalMethod_properties
+# : 'properties' LPAREN stringLiteralList RPAREN
+# ;
+
+ - name: PropertiesStep
+ type:
+ record:
+ - name: propertyKeys
+ type:
+ list: string
+
+# traversalMethod_property
+# : 'property' LPAREN traversalCardinality COMMA genericLiteral COMMA genericLiteral (COMMA genericLiteralList)? RPAREN #traversalMethod_property_Cardinality_Object_Object_Object
+# | 'property' LPAREN genericLiteral COMMA genericLiteral (COMMA genericLiteralList)? RPAREN #traversalMethod_property_Object_Object_Object
+# ;
+
+ - name: PropertyStep
+ type:
+ record:
+ - name: cardinality
+ type:
+ optional: traversal.TraversalCardinality
+
+ - name: key
+ type: literals.GenericLiteral
+
+ - name: value
+ type: literals.GenericLiteral
+
+ - name: keyValues
+ type:
+ list: literals.GenericLiteral
+
+# traversalMethod_propertyMap
+# : 'propertyMap' LPAREN stringLiteralList RPAREN
+# ;
+
+ - name: PropertyMapStep
+ type:
+ record:
+ - name: propertyKeys
+ type:
+ list: string
+
+# traversalMethod_range
+# : 'range' LPAREN traversalScope COMMA integerLiteral COMMA integerLiteral RPAREN #traversalMethod_range_Scope_long_long
+# | 'range' LPAREN integerLiteral COMMA integerLiteral RPAREN #traversalMethod_range_long_long
+# ;
+
+ - name: RangeStep
+ type:
+ record:
+ - name: scope
+ type:
+ optional: traversal.TraversalScope
+
+ - name: low
+ type: integer
+
+ - name: high
+ type: integer
+
+# traversalMethod_read
+# : 'read' LPAREN RPAREN
+# ;
+
+ - name: ReadStep
+
+# traversalMethod_repeat
+# : 'repeat' LPAREN stringLiteral COMMA nestedTraversal RPAREN #traversalMethod_repeat_String_Traversal
+# | 'repeat' LPAREN nestedTraversal RPAREN #traversalMethod_repeat_Traversal
+# ;
+
+ - name: RepeatStep
+ type:
+ record:
+ - name: loopName
+ type:
+ optional: string
+
+ - name: repeatTraversals
+ type: traversal.NestedTraversal
+
+# traversalMethod_sack
+# : 'sack' LPAREN traversalBiFunction RPAREN #traversalMethod_sack_BiFunction
+# | 'sack' LPAREN RPAREN #traversalMethod_sack_Empty
+# ;
+
+ - name: SackStep
+ type:
+ record:
+ - name: sackOperator
+ type:
+ optional: traversal.TraversalBiFunction
+
+# traversalMethod_sample
+# : 'sample' LPAREN traversalScope COMMA integerLiteral RPAREN #traversalMethod_sample_Scope_int
+# | 'sample' LPAREN integerLiteral RPAREN #traversalMethod_sample_int
+# ;
+
+ - name: SampleStep
+ type:
+ record:
+ - name: scope
+ type:
+ optional: traversal.TraversalScope
+
+ - name: amountToSample
+ type: integer
+
+# traversalMethod_select
+# : 'select' LPAREN traversalColumn RPAREN #traversalMethod_select_Column
+# | 'select' LPAREN traversalPop COMMA stringLiteral RPAREN #traversalMethod_select_Pop_String
+# | 'select' LPAREN traversalPop COMMA stringLiteral COMMA stringLiteral (COMMA stringLiteralList)? RPAREN #traversalMethod_select_Pop_String_String_String
+# | 'select' LPAREN traversalPop COMMA nestedTraversal RPAREN #traversalMethod_select_Pop_Traversal
+# | 'select' LPAREN stringLiteral RPAREN #traversalMethod_select_String
+# | 'select' LPAREN stringLiteral COMMA stringLiteral (COMMA stringLiteralList)? RPAREN #traversalMethod_select_String_String_String
+# | 'select' LPAREN nestedTraversal RPAREN #traversalMethod_select_Traversal
+# ;
+
+ - name: SelectStep
+ type:
+ union:
+ - name: column
+ type: traversal.TraversalColumn
+
+ - name: key
+ type:
+ record:
+ - name: pop
+ type:
+ optional: traversal.TraversalPop
+
+ - name: selectKey
+ type: string
+
+ - name: keys
+ type:
+ record:
+ - name: pop
+ type:
+ optional: traversal.TraversalPop
+
+ - name: selectKey1
+ type: string
+
+ - name: selectKey2
+ type: string
+
+ - name: otherSelectKeys
+ type:
+ list: string
+
+ - name: traversal
+ type:
+ record:
+ - name: pop
+ type:
+ optional: traversal.TraversalPop
+
+ - name: traversal
+ type: traversal.NestedTraversal
+
+# traversalMethod_shortestPath
+# : 'shortestPath' LPAREN RPAREN
+# ;
+
+ - name: ShortestPathStep
+
+# traversalMethod_sideEffect
+# : 'sideEffect' LPAREN nestedTraversal RPAREN
+# ;
+
+ - name: SideEffectStep
+ type:
+ record:
+ - name: sideEffectTraversal
+ type: traversal.NestedTraversal
+
+# traversalMethod_simplePath
+# : 'simplePath' LPAREN RPAREN
+# ;
+
+ - name: SimplePathStep
+
+# traversalMethod_skip
+# : 'skip' LPAREN traversalScope COMMA integerLiteral RPAREN #traversalMethod_skip_Scope_long
+# | 'skip' LPAREN integerLiteral RPAREN #traversalMethod_skip_long
+# ;
+
+ - name: SkipStep
+ type:
+ record:
+ - name: scope
+ type:
+ optional: traversal.TraversalScope
+
+ - name: skip
+ type: integer
+
+# traversalMethod_store
+# : 'store' LPAREN stringLiteral RPAREN
+# ;
+
+ - name: StoreStep
+ type:
+ record:
+ - name: sideEffectKey
+ type: string
+
+# traversalMethod_subgraph
+# : 'subgraph' LPAREN stringLiteral RPAREN
+# ;
+
+ - name: SubgraphStep
+ type:
+ record:
+ - name: sideEffectKey
+ type: string
+
+# traversalMethod_sum
+# : 'sum' LPAREN RPAREN #traversalMethod_sum_Empty
+# | 'sum' LPAREN traversalScope RPAREN #traversalMethod_sum_Scope
+# ;
+
+ - name: SumStep
+ type:
+ record:
+ - name: scope
+ type:
+ optional: traversal.TraversalScope
+
+# traversalMethod_tail
+# : 'tail' LPAREN RPAREN #traversalMethod_tail_Empty
+# | 'tail' LPAREN traversalScope RPAREN #traversalMethod_tail_Scope
+# | 'tail' LPAREN traversalScope COMMA integerLiteral RPAREN #traversalMethod_tail_Scope_long
+# | 'tail' LPAREN integerLiteral RPAREN #traversalMethod_tail_long
+# ;
+
+ - name: TailStep
+ type:
+ record:
+ - name: scope
+ type:
+ optional: traversal.TraversalScope
+
+ - name: limit
+ type:
+ optional: integer
+
+# traversalMethod_timeLimit
+# : 'timeLimit' LPAREN integerLiteral RPAREN
+# ;
+
+ - name: TimeLimitStep
+ type:
+ record:
+ - name: timeLimit
+ type: integer
+
+# traversalMethod_times
+# : 'times' LPAREN integerLiteral RPAREN
+# ;
+
+ - name: TimesStep
+ type:
+ record:
+ - name: maxLoops
+ type: integer
+
+# traversalMethod_to
+# : 'to' LPAREN traversalDirection (COMMA stringLiteralList)? RPAREN #traversalMethod_to_Direction_String
+# | 'to' LPAREN stringLiteral RPAREN #traversalMethod_to_String
+# | 'to' LPAREN nestedTraversal RPAREN #traversalMethod_to_Traversal
+# ;
+
+ - name: ToStep
+ type:
+ union:
+ - name: withDirection
+ type:
+ record:
+ - name: direction
+ type: traversal.TraversalDirection
+
+ - name: edgeLabels
+ type:
+ list: string
+
+ - name: toStepLabel
+ type: string
+
+ - name: toVertex
+ type: traversal.NestedTraversal
+
+# traversalMethod_toE
+# : 'toE' LPAREN traversalDirection (COMMA stringLiteralList)? RPAREN
+# ;
+
+ - name: ToEStep
+ type:
+ record:
+ - name: direction
+ type: traversal.TraversalDirection
+
+ - name: edgeLabels
+ type:
+ list: string
+
+# traversalMethod_toV
+# : 'toV' LPAREN traversalDirection RPAREN
+# ;
+
+ - name: ToVStep
+ type:
+ record:
+ - name: direction
+ type: traversal.TraversalDirection
+
+# traversalMethod_tree
+# : 'tree' LPAREN RPAREN #traversalMethod_tree_Empty
+# | 'tree' LPAREN stringLiteral RPAREN #traversalMethod_tree_String
+# ;
+
+ - name: TreeStep
+ type:
+ record:
+ - name: sideEffectKey
+ type:
+ optional: string
+
+# traversalMethod_unfold
+# : 'unfold' LPAREN RPAREN
+# ;
+
+ - name: UnfoldStep
+
+# traversalMethod_union
+# : 'union' LPAREN nestedTraversalList RPAREN
+# ;
+
+ - name: UnionStep
+ type:
+ record:
+ - name: unionTraversals
+ type:
+ list: traversal.NestedTraversal
+
+# traversalMethod_until
+# : 'until' LPAREN traversalPredicate RPAREN #traversalMethod_until_Predicate
+# | 'until' LPAREN nestedTraversal RPAREN #traversalMethod_until_Traversal
+# ;
+
+ - name: UntilStep
+ type:
+ union:
+ - name: untilPredicate
+ type: predicates.TraversalPredicate
+
+ - name: untilTraversal
+ type: traversal.NestedTraversal
+
+# traversalMethod_value
+# : 'value' LPAREN RPAREN
+# ;
+
+ - name: ValueStep
+
+# traversalMethod_valueMap
+# : 'valueMap' LPAREN stringLiteralList RPAREN #traversalMethod_valueMap_String
+# | 'valueMap' LPAREN booleanLiteral (COMMA stringLiteralList)? RPAREN #traversalMethod_valueMap_boolean_String
+# ;
+
+ - name: ValueMapStep
+ type:
+ record:
+ - name: includeTokens
+ type:
+ optional: boolean
+
+ - name: propertyKeys
+ type:
+ list: string
+
+# traversalMethod_values
+# : 'values' LPAREN stringLiteralList RPAREN
+# ;
+
+ - name: ValuesStep
+ type:
+ record:
+ - name: propertyKeys
+ type:
+ list: string
+
+# traversalMethod_where
+# : 'where' LPAREN traversalPredicate RPAREN #traversalMethod_where_P
+# | 'where' LPAREN stringLiteral COMMA traversalPredicate RPAREN #traversalMethod_where_String_P
+# | 'where' LPAREN nestedTraversal RPAREN #traversalMethod_where_Traversal
+# ;
+
+ - name: WhereStep
+ type:
+ union:
+ - name: withPredicate
+ type:
+ record:
+ - name: startKey
+ type:
+ optional: string
+
+ - name: predicate
+ type: predicates.TraversalPredicate
+
+ - name: whereTraversal
+ type: traversal.NestedTraversal
+
+# traversalMethod_with
+# : 'with' LPAREN stringLiteral RPAREN #traversalMethod_with_String
+# | 'with' LPAREN stringLiteral COMMA genericLiteral RPAREN #traversalMethod_with_String_Object
+# ;
+
+ - name: WithStep
+ type:
+ record:
+ - name: key
+ type: string
+
+ - name: value
+ type:
+ optional: literals.GenericLiteral
+
+# traversalMethod_write
+# : 'write' LPAREN RPAREN
+# ;
+
+ - name: WriteStep
diff --git a/gremlin-language/src/main/yaml/org/apache/tinkerpop/gremlin/language/model/traversal.yaml b/gremlin-language/src/main/yaml/org/apache/tinkerpop/gremlin/language/model/traversal.yaml
new file mode 100644
index 0000000..94aaa14
--- /dev/null
+++ b/gremlin-language/src/main/yaml/org/apache/tinkerpop/gremlin/language/model/traversal.yaml
@@ -0,0 +1,575 @@
+# /*********************************************
+# PARSER RULES
+# **********************************************/
+
+# /*********************************************
+# ARGUMENT AND TERMINAL RULES
+# **********************************************/
+
+status: experimental
+
+includes:
+ - literals
+ - methods
+ - steps
+
+definitions:
+
+# traversalSource
+# : TRAVERSAL_ROOT (DOT traversalSourceSelfMethod)?
+# | traversalSource DOT traversalSourceSelfMethod
+# ;
+
+ - name: TraversalSource
+ type:
+ list: TraversalSourceSelfMethod
+
+# rootTraversal
+# : traversalSource DOT traversalSourceSpawnMethod (DOT (chainedTraversal | chainedParentOfGraphTraversal))?
+# ;
+
+ - name: RootTraversal
+ type:
+ record:
+ - name: source
+ type: TraversalSource
+
+ - name: spawnMethod
+ type: TraversalSourceSpawnMethod
+
+ - name: rest
+ type:
+ optional:
+ union:
+ - name: chained
+ type: ChainedTraversal
+
+ - name: parent
+ type: ChainedParentOfGraphTraversal
+
+# traversalSourceSelfMethod
+# : traversalSourceSelfMethod_withBulk
+# | traversalSourceSelfMethod_withPath
+# | traversalSourceSelfMethod_withSack
+# | traversalSourceSelfMethod_withSideEffect
+# | traversalSourceSelfMethod_withStrategies
+# | traversalSourceSelfMethod_with
+# ;
+
+ - name: TraversalSourceSelfMethod
+ type:
+ union:
+ - name: withBulk
+ type: WithBulk
+
+ - name: withPath
+ type: WithPath
+
+ - name: withSack
+ type: WithSack
+
+ - name: withSideEffect
+ type: WithSideEffect
+
+ - name: withStrategies
+ type: WithStrategies
+
+ - name: with
+ type: With
+
+# traversalSourceSelfMethod_withBulk
+# : 'withBulk' LPAREN booleanLiteral RPAREN
+# ;
+
+ - name: WithBulk
+ type:
+ record:
+ - name: useBulk
+ type: boolean
+
+# traversalSourceSelfMethod_withPath
+# : 'withPath' LPAREN RPAREN
+# ;
+
+ - name: WithPath
+
+# traversalSourceSelfMethod_withSack
+# : 'withSack' LPAREN genericLiteral (COMMA traversalOperator)? RPAREN
+# ;
+
+ - name: WithSack
+ type:
+ record:
+ - name: initialValue
+ type: literals.StringLiteral
+
+ - name: operator
+ type:
+ optional: TraversalOperator
+
+# traversalSourceSelfMethod_withSideEffect
+# : 'withSideEffect' LPAREN stringLiteral COMMA genericLiteral RPAREN
+# ;
+
+ - name: WithSideEffect
+ type:
+ record:
+ - name: key
+ type: literals.StringLiteral
+
+ - name: initialValue
+ type: literals.GenericLiteral
+
+# traversalSourceSelfMethod_withStrategies
+# : 'withStrategies' LPAREN traversalStrategy (COMMA traversalStrategyList)? RPAREN
+# ;
+
+ - name: WithStrategies
+ type:
+ record:
+ - name: traversalStrategies
+ type:
+ list: TraversalStrategy
+
+# traversalSourceSelfMethod_with
+# : 'with' LPAREN stringLiteral (COMMA genericLiteral)? RPAREN
+# ;
+
+ - name: With
+ type:
+ record:
+ - name: key
+ type: string
+
+ - name: value
+ type:
+ optional: literals.GenericLiteral
+
+# traversalSourceSpawnMethod
+# : traversalSourceSpawnMethod_addE
+# | traversalSourceSpawnMethod_addV
+# | traversalSourceSpawnMethod_E
+# | traversalSourceSpawnMethod_V
+# | traversalSourceSpawnMethod_inject
+# | traversalSourceSpawnMethod_io
+# ;
+
+ - name: TraversalSourceSpawnMethod
+ type:
+ union:
+ - name: addE
+ type: steps.AddEStep
+
+ - name: addV
+ type: steps.AddVStep
+
+ - name: e
+ # TODO: steps.EStep
+
+ - name: v
+ type: steps.VStep
+
+ - name: inject
+ type: steps.InjectStep
+
+ - name: io
+ # TODO: steps.IoStep
+
+# traversalSourceSpawnMethod_addE
+# : 'addE' LPAREN (stringLiteral | nestedTraversal) RPAREN
+# ;
+
+# traversalSourceSpawnMethod_addV
+# // null means use the default vertex label
+# : 'addV' LPAREN (stringLiteral | nullLiteral | nestedTraversal)? RPAREN
+# ;
+#
+# traversalSourceSpawnMethod_E
+# : 'E' LPAREN genericLiteralList RPAREN
+# ;
+#
+# traversalSourceSpawnMethod_V
+# : 'V' LPAREN genericLiteralList RPAREN
+# ;
+#
+# traversalSourceSpawnMethod_inject
+# : 'inject' LPAREN genericLiteralList RPAREN
+# ;
+#
+# traversalSourceSpawnMethod_io
+# : 'io' LPAREN stringLiteral RPAREN
+# ;
+#
+# chainedTraversal
+# : traversalMethod
+# | chainedTraversal DOT (traversalMethod | chainedParentOfGraphTraversal)
+# ;
+
+ - name: ChainedTraversal
+ type:
+ record:
+ - name: first
+ type: steps.TraversalMethod
+
+ - name: rest
+ type:
+ list:
+ union:
+ - name: method
+ type: steps.TraversalMethod
+
+ - name: chainedParent
+ type: ChainedParentOfGraphTraversal
+
+# chainedParentOfGraphTraversal
+# : traversalSelfMethod (DOT chainedParentOfGraphTraversal)?
+# ;
+
+ - name: ChainedParentOfGraphTraversal
+ type:
+ record:
+ - name: first
+ type: methods.TraversalSelfMethod
+
+ - name: rest
+ type:
+ optional: ChainedParentOfGraphTraversal
+
+# nestedTraversal
+# : rootTraversal
+# | (ANON_TRAVERSAL_ROOT DOT)? chainedTraversal
+# ;
+
+ - name: NestedTraversal
+ type:
+ union:
+ - name: root
+ type: RootTraversal
+
+ - name: chained
+ type:
+ record:
+ - name: anonymous
+ type: boolean
+
+ - name: traversal
+ type: ChainedTraversal
+
+# terminatedTraversal
+# : rootTraversal DOT traversalTerminalMethod
+# ;
+
+ # traversalStrategy
+ # // : 'ConnectiveStrategy' - not supported as it is a default strategy and we don't allow removal at this time
+ # // | 'ElementIdStrategy' - not supported as the configuration takes a lambda
+ # // | 'EventStrategy' - not supported as there is no way to send events back to the client
+ # // | 'HaltedTraverserStrategy' - not supported as it is not typically relevant to OLTP
+ # // | 'OptionsStrategy' - not supported as it's internal to with()
+ # : 'new' 'PartitionStrategy' LPAREN traversalStrategyArgs_PartitionStrategy? (COMMA traversalStrategyArgs_PartitionStrategy)* RPAREN
+ # // | 'RequirementStrategy' - not supported as it's internally relevant only
+ # // | 'SackStrategy' - not supported directly as it's internal to withSack()
+ # // | 'SideEffectStrategy' - not supported directly as it's internal to withSideEffect()
+ # | 'new' 'SubgraphStrategy' LPAREN traversalStrategyArgs_SubgraphStrategy? (COMMA traversalStrategyArgs_SubgraphStrategy)* RPAREN
+ # // | 'MatchAlgorithmStrategy' - not supported directly as it's internal to match()
+ # // | 'ProfileStrategy' - not supported directly as it's internal to profile()
+ # // | 'ReferenceElementStrategy' - not supported directly as users really can't/shouldn't change this in our context of a remote Gremlin provider
+ # // | 'AdjacentToIncidentStrategy' - not supported as it is a default strategy and we don't allow removal at this time
+ # // | 'CountStrategy' - not supported as it is a default strategy and we don't allow removal at this time
+ # // | 'EarlyLimitStrategy' - not supported as it is a default strategy and we don't allow removal at this time
+ # // | 'FilterRankingStrategy' - not supported as it is a default strategy and we don't allow removal at this time
+ # // | 'IdentityRemovalStrategy' - not supported as it is a default strategy and we don't allow removal at this time
+ # // | 'IncidentToAdjacentStrategy' - not supported as it is a default strategy and we don't allow removal at this time
+ # // | 'InlineFilterStrategy' - not supported as it is a default strategy and we don't allow removal at this time
+ # // | 'LazyBarrierStrategy' - not supported as it is a default strategy and we don't allow removal at this time
+ # // | 'MatchPredicateStrategy' - not supported as it is a default strategy and we don't allow removal at this time
+ # // | 'OrderLimitStrategy' - not supported as it is a default strategy and we don't allow removal at this time
+ # // | 'PathProcessorStrategy' - not supported as it is a default strategy and we don't allow removal at this time
+ # // | 'PathRetractionStrategy' - not supported as it is a default strategy and we don't allow removal at this time
+ # // | 'RepeatUnrollStrategy' - not supported as it is a default strategy and we don't allow removal at this time
+ # // | 'ComputerVerificationStrategy' - not supported since it's GraphComputer related
+ # | 'new' 'EdgeLabelVerificationStrategy' LPAREN traversalStrategyArgs_EdgeLabelVerificationStrategy? (COMMA traversalStrategyArgs_EdgeLabelVerificationStrategy)* RPAREN
+ # // | 'LambdaRestrictionStrategy' - not supported as we don't support lambdas in any situation
+ # | 'ReadOnlyStrategy'
+ # | 'new' 'ReservedKeysVerificationStrategy' LPAREN traversalStrategyArgs_ReservedKeysVerificationStrategy? (COMMA traversalStrategyArgs_ReservedKeysVerificationStrategy)* RPAREN
+ # // | 'StandardVerificationStrategy' - not supported since this is an interal strategy
+ # ;
+
+ - name: TraversalStrategy
+ type:
+ union:
+ - name: partition
+ type:
+ list: PartitionStrategy
+
+ - name: subgraph
+ type:
+ list: SubgraphStrategy
+
+ - name: edgeLabelVerification
+ type:
+ list: EdgeLabelVerificationStrategy
+
+ - name: readOnly
+
+ - name: reservedKeysVerification
+ type:
+ list: ReservedKeysVerificationStrategy
+
+ # traversalStrategyArgs_PartitionStrategy
+ # : 'includeMetaProperties' COLON booleanLiteral
+ # | 'writePartition' COLON stringLiteral
+ # | 'partitionKey' COLON stringLiteral
+ # | 'readPartitions' COLON stringLiteralList
+ # ;
+
+ - name: PartitionStrategy
+ type:
+ union:
+ - name: includeMetaProperties
+ type: boolean
+
+ - name: writePartition
+ type: string
+
+ - name: partitionKey
+ type: string
+
+ - name: readPartitions
+ type:
+ list: string
+
+ # traversalStrategyArgs_SubgraphStrategy
+ # : 'vertices' COLON nestedTraversal
+ # | 'edges' COLON nestedTraversal
+ # | 'vertexProperties' COLON nestedTraversal
+ # | 'checkAdjacentVertices' COLON booleanLiteral
+ # ;
+
+ - name: SubgraphStrategy
+ type:
+ union:
+ - name: vertices
+ type: NestedTraversal
+
+ - name: edges
+ type: NestedTraversal
+
+ - name: vertexProperties
+ type: NestedTraversal
+
+ - name: checkAdjacentVertixes
+ type: boolean
+
+ # traversalStrategyArgs_EdgeLabelVerificationStrategy
+ # : 'throwException' COLON booleanLiteral
+ # | 'logWarning' COLON booleanLiteral
+ # ;
+
+ - name: EdgeLabelVerificationStrategy
+ type:
+ union:
+ - name: throwException
+ type: boolean
+
+ - name: logWarning
+ type: boolean
+
+ # traversalStrategyArgs_ReservedKeysVerificationStrategy
+ # : 'keys' COLON stringLiteralList
+ # | 'throwException' COLON booleanLiteral
+ # | 'logWarning' COLON booleanLiteral
+ # ;
+
+ - name: ReservedKeysVerificationStrategy
+ type:
+ union:
+ - name: keys
+ type:
+ list: string
+
+ - name: throwException
+ type: boolean
+
+ - name: logWarning
+ type: boolean
+
+ # traversalScope
+ # : 'local' | 'Scope.local'
+ # | 'global' | 'Scope.global'
+ # ;
+
+ - name: TraversalScope
+ type:
+ enum:
+ - local
+ - global
+
+ # traversalToken
+ # : 'id' | 'T.id'
+ # | 'label' | 'T.label'
+ # | 'key' | 'T.key'
+ # | 'value' | 'T.value'
+ # ;
+
+ - name: TraversalToken
+ type:
+ enum:
+ - id
+ - label
+ - key
+ - value
+
+ # traversalOrder
+ # : 'incr' | 'Order.incr'
+ # | 'decr' | 'Order.decr'
+ # | 'asc' | 'Order.asc'
+ # | 'desc' | 'Order.desc'
+ # | 'shuffle' | 'Order.shuffle'
+ # ;
+
+ - name: TraversalOrder
+ type:
+ enum:
+ - incr
+ - decr
+ - asc
+ - desc
+ - shuffle
+
+ # traversalDirection
+ # : 'IN' | 'Direction.IN'
+ # | 'OUT' | 'Direction.OUT'
+ # | 'BOTH' | 'Direction.BOTH'
+ # ;
+
+ - name: TraversalDirection
+ type:
+ enum:
+ - in
+ - out
+ - both
+
+ # traversalCardinality
+ # : 'single' | 'Cardinality.single'
+ # | 'set' | 'Cardinality.set'
+ # | 'list' | 'Cardinality.list'
+ # ;
+
+ - name: TraversalCardinality
+ type:
+ enum:
+ - single
+ - set
+ - list
+
+ # traversalColumn
+ # : 'keys' | 'Column.keys'
+ # | 'values' | 'Column.values'
+ # ;
+
+ - name: TraversalColumn
+ type:
+ enum:
+ - keys
+ - values
+
+ # traversalPop
+ # : 'first' | 'Pop.first'
+ # | 'last' | 'Pop.last'
+ # | 'all' | 'Pop.all'
+ # | 'mixed' | 'Pop.mixed'
+ # ;
+
+ - name: TraversalPop
+ type:
+ enum:
+ - first
+ - last
+ - all
+ - mixed
+
+ # traversalOperator
+ # : 'addAll' | 'Operator.addAll'
+ # | 'and' | 'Operator.and'
+ # | 'assign' | 'Operator.assign'
+ # | 'div' | 'Operator.div'
+ # | 'max' | 'Operator.max'
+ # | 'min' | 'Operator.min'
+ # | 'minus' | 'Operator.minus'
+ # | 'mult' | 'Operator.mult'
+ # | 'or' | 'Operator.or'
+ # | 'sum' | 'Operator.sum'
+ # | 'sumLong' | 'Operator.sumLong'
+ # ;
+
+ - name: TraversalOperator
+ type:
+ enum:
+ - addAll
+ - and
+ - assign
+ - div
+ - max
+ - min
+ - minus
+ - mult
+ - or
+ - sum
+ - sumLong
+
+ # traversalOptionParent
+ # : 'any' | 'Pick.any'
+ # | 'none' | 'Pick.none'
+ # ;
+
+ - name: TraversalOptionParent
+ type:
+ enum:
+ - any
+ - none
+
+ # // Additional special rules that are derived from above
+ # // These are used to restrict broad method signatures that accept lambdas
+ # // to a smaller set.
+ # traversalComparator
+ # : traversalOrder
+ # ;
+
+ - name: TraversalComparator
+ type: TraversalOrder
+
+ # traversalFunction
+ # : traversalToken
+ # | traversalColumn
+ # ;
+
+ - name: TraversalFunction
+ type:
+ union:
+ - name: token
+ type: TraversalToken
+
+ - name: column
+ type: TraversalColumn
+
+ # traversalBiFunction
+ # : traversalOperator
+ # ;
+
+ - name: TraversalBiFunction
+ type: TraversalOperator
+
+# traversalStrategyList
+# : traversalStrategyExpr?
+# ;
+# traversalStrategyExpr
+# : traversalStrategy (COMMA traversalStrategy)*
+# ;
+#
+# nestedTraversalList
+# : nestedTraversalExpr?
+# ;
+#
+# nestedTraversalExpr
+# : nestedTraversal (COMMA nestedTraversal)*
+# ;