gremlin 3.8.1 → 4.0.0-beta.3

package/build/cjs/language/translator/GremlinTranslator.cjs

@@ -0,0 +1,96 @@
+"use strict";
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GremlinTranslator = void 0;
+const antlr4ng_1 = require("antlr4ng");
+const GremlinLexer_js_1 = require("../grammar/GremlinLexer.cjs");
+const GremlinParser_js_1 = require("../grammar/GremlinParser.cjs");
+const Translation_js_1 = require("./Translation.cjs");
+const TranslatorException_js_1 = require("./TranslatorException.cjs");
+const JavascriptTranslateVisitor_js_1 = __importDefault(require("./JavascriptTranslateVisitor.cjs"));
+const Translator_js_1 = require("./Translator.cjs");
+/**
+ * Error listener that throws TranslatorException on syntax errors.
+ */
+class ThrowingErrorListener extends antlr4ng_1.BaseErrorListener {
+    syntaxError(_recognizer, _offendingSymbol, line, column, msg, _e) {
+        throw new TranslatorException_js_1.TranslatorException(`Failed to interpret Gremlin query at line ${line}:${column} - ${msg}`);
+    }
+}
+const errorListener = new ThrowingErrorListener();
+/**
+ * Translates a Gremlin string into a source code representation using ANTLR.
+ * Mirrors the Java GremlinTranslator with SLL → LL fallback parsing.
+ */
+class GremlinTranslator {
+    /**
+     * Translates a Gremlin query string. Defaults to JavaScript output.
+     *
+     * @param query The Gremlin traversal string to translate.
+     * @param graphTraversalSourceName Name of the traversal source variable (default: 'g').
+     * @param translatorOrVisitor A TranslatorKey (e.g. 'JAVASCRIPT'), a custom
+     *   TranslateVisitor instance, or omit for the default JavaScript translator.
+     */
+    static translate(query, graphTraversalSourceName, translatorOrVisitor) {
+        const sourceName = graphTraversalSourceName ?? 'g';
+        let visitor;
+        if (translatorOrVisitor == null) {
+            visitor = new JavascriptTranslateVisitor_js_1.default(sourceName);
+        }
+        else if (typeof translatorOrVisitor === 'string') {
+            visitor = Translator_js_1.Translator[translatorOrVisitor](sourceName);
+        }
+        else {
+            visitor = translatorOrVisitor;
+        }
+        const chars = antlr4ng_1.CharStream.fromString(query);
+        const lexer = new GremlinLexer_js_1.GremlinLexer(chars);
+        lexer.removeErrorListeners();
+        lexer.addErrorListener(errorListener);
+        const tokens = new antlr4ng_1.CommonTokenStream(lexer);
+        const parser = new GremlinParser_js_1.GremlinParser(tokens);
+        // SLL mode is faster; fall back to LL on parse failure (mirrors Java impl)
+        parser.interpreter.predictionMode = antlr4ng_1.PredictionMode.SLL;
+        parser.removeErrorListeners();
+        parser.addErrorListener(errorListener);
+        let queryContext;
+        try {
+            queryContext = parser.queryList();
+        }
+        catch (_ex) {
+            try {
+                tokens.seek(0);
+                lexer.reset();
+                parser.reset();
+                parser.interpreter.predictionMode = antlr4ng_1.PredictionMode.LL;
+                queryContext = parser.queryList();
+            }
+            catch (e) {
+                throw new TranslatorException_js_1.TranslatorException(`Failed to interpret Gremlin query: ${e instanceof Error ? e.message : String(e)}`);
+            }
+        }
+        visitor.visit(queryContext);
+        return new Translation_js_1.Translation(query, visitor.getTranslated(), visitor.getParameters());
+    }
+}
+exports.GremlinTranslator = GremlinTranslator;

package/build/cjs/language/translator/GremlinTranslator.d.cts

@@ -0,0 +1,18 @@
+import { Translation } from './Translation.cjs';
+import TranslateVisitor from './TranslateVisitor.cjs';
+import { TranslatorKey } from './Translator.cjs';
+/**
+ * Translates a Gremlin string into a source code representation using ANTLR.
+ * Mirrors the Java GremlinTranslator with SLL → LL fallback parsing.
+ */
+export declare class GremlinTranslator {
+    /**
+     * Translates a Gremlin query string. Defaults to JavaScript output.
+     *
+     * @param query The Gremlin traversal string to translate.
+     * @param graphTraversalSourceName Name of the traversal source variable (default: 'g').
+     * @param translatorOrVisitor A TranslatorKey (e.g. 'JAVASCRIPT'), a custom
+     *   TranslateVisitor instance, or omit for the default JavaScript translator.
+     */
+    static translate(query: string, graphTraversalSourceName?: string, translatorOrVisitor?: TranslatorKey | TranslateVisitor): Translation;
+}

package/build/cjs/language/translator/GroovyTranslateVisitor.cjs

@@ -0,0 +1,310 @@
+"use strict";
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Context parameters are typed as `any` because the generated grammar files
+// require accepting arbitrary context types at runtime.
+const TranslateVisitor_js_1 = __importDefault(require("./TranslateVisitor.cjs"));
+/**
+ * Converts a Gremlin traversal string into a Groovy source code representation.
+ * Mirrors the Java GroovyTranslateVisitor.
+ */
+class GroovyTranslateVisitor extends TranslateVisitor_js_1.default {
+    constructor(graphTraversalSourceName = 'g') {
+        super(graphTraversalSourceName);
+    }
+    visitIntegerLiteral(ctx) {
+        const integerLiteral = ctx.getText().toLowerCase();
+        const lastChar = integerLiteral[integerLiteral.length - 1];
+        if (!/[a-z]/.test(lastChar)) {
+            this.sb.push(integerLiteral);
+            return;
+        }
+        const num = integerLiteral.slice(0, -1);
+        switch (lastChar) {
+            case 'b':
+                this.sb.push('(byte)');
+                this.sb.push(num);
+                break;
+            case 's':
+                this.sb.push('(short)');
+                this.sb.push(num);
+                break;
+            case 'n':
+                // Groovy BigInteger uses the 'g' suffix
+                this.sb.push(num);
+                this.sb.push('g');
+                break;
+            default:
+                // i and l suffixes and anything else kept as-is
+                this.sb.push(integerLiteral);
+        }
+    }
+    visitFloatLiteral(ctx) {
+        if (ctx.infLiteral() != null) {
+            this.visit(ctx.infLiteral());
+            return;
+        }
+        if (ctx.nanLiteral() != null) {
+            this.visit(ctx.nanLiteral());
+            return;
+        }
+        const floatLiteral = ctx.getText().toLowerCase();
+        const lastChar = floatLiteral[floatLiteral.length - 1];
+        if (!/[a-z]/.test(lastChar)) {
+            this.sb.push(floatLiteral);
+            return;
+        }
+        const num = floatLiteral.slice(0, -1);
+        switch (lastChar) {
+            case 'f':
+            case 'd':
+                // keep f/d suffix as-is
+                this.sb.push(floatLiteral);
+                break;
+            case 'm':
+                // Groovy BigDecimal: if no decimal point use new BigDecimal(NL), else just the number
+                if (!floatLiteral.includes('.')) {
+                    this.sb.push('new BigDecimal(');
+                    this.sb.push(num);
+                    this.sb.push('L)');
+                }
+                else {
+                    this.sb.push(num);
+                }
+                break;
+            default:
+                this.sb.push(floatLiteral);
+        }
+    }
+    visitInfLiteral(ctx) {
+        if (ctx.SignedInfLiteral() != null && ctx.SignedInfLiteral().getText() === '-Infinity') {
+            this.sb.push('Double.NEGATIVE_INFINITY');
+        }
+        else {
+            this.sb.push('Double.POSITIVE_INFINITY');
+        }
+    }
+    visitUuidLiteral(ctx) {
+        if (ctx.stringLiteral() == null) {
+            this.sb.push('UUID.randomUUID()');
+            return;
+        }
+        this.sb.push('UUID.fromString(');
+        this.sb.push(ctx.stringLiteral().getText());
+        this.sb.push(')');
+    }
+    visitCharacterLiteral(ctx) {
+        const text = ctx.getText();
+        const withoutSuffix = text.substring(0, text.length - 1);
+        const inner = TranslateVisitor_js_1.default.removeFirstAndLastCharacters(withoutSuffix);
+        this.sb.push("'");
+        this.sb.push(inner);
+        this.sb.push("' as char");
+    }
+    visitDurationLiteral(ctx) {
+        const seconds = parseInt(ctx.integerLiteral(0).getText(), 10);
+        const nanos = parseInt(ctx.integerLiteral(1).getText(), 10);
+        const isPositive = ctx.booleanLiteral() === null ||
+            ctx.booleanLiteral().getText() === 'true';
+        this.sb.push(`Duration.ofSeconds(${seconds}, ${nanos})`);
+        if (!isPositive) {
+            this.sb.push('.negated()');
+        }
+    }
+    visitBinaryLiteral(ctx) {
+        this.sb.push('ByteBuffer.wrap(Base64.getDecoder().decode(');
+        this.sb.push(ctx.stringLiteral().getText());
+        this.sb.push('))');
+    }
+    visitNullLiteral(ctx) {
+        if (ctx.parent?.constructor?.name === 'GenericMapNullableArgumentContext') {
+            this.sb.push('null as Map');
+        }
+        else {
+            this.sb.push(ctx.getText());
+        }
+    }
+    visitGenericSetLiteral(ctx) {
+        this.sb.push('[');
+        const literals = ctx.genericLiteral();
+        for (let i = 0; i < literals.length; i++) {
+            this.visit(literals[i]);
+            if (i < literals.length - 1)
+                this.sb.push(', ');
+        }
+        this.sb.push('] as Set');
+    }
+    visitStringLiteral(ctx) {
+        // Preserve original quote style and escape Groovy GString interpolation
+        this.sb.push(ctx.getText().replace(/\$/g, () => '\\$'));
+    }
+    visitStringNullableLiteral(ctx) {
+        if (ctx.getText() === 'null') {
+            this.sb.push('null');
+        }
+        else {
+            // Preserve original quote style and escape Groovy GString interpolation
+            this.sb.push(ctx.getText().replace(/\$/g, () => '\\$'));
+        }
+    }
+    visitMapKey(ctx) {
+        if (ctx.LPAREN() != null && ctx.RPAREN() != null) {
+            // Groovy map syntax: expression keys must be parenthesized — preserve the parens
+            this.sb.push('(');
+            this.visit(ctx.getChild(1));
+            this.sb.push(')');
+        }
+        else {
+            this.visit(ctx.getChild(0));
+        }
+    }
+    visitNakedKey(ctx) {
+        // Groovy map/config syntax uses unquoted identifier keys
+        this.sb.push(ctx.getText());
+    }
+    visitKeyword(ctx) {
+        const keyword = ctx.getText();
+        const parentName = ctx.parent?.constructor?.name ?? '';
+        if (parentName === 'MapKeyContext' || parentName === 'ConfigurationContext') {
+            // Groovy uses unquoted keys
+            this.sb.push(keyword);
+        }
+        else {
+            this.sb.push(keyword);
+            this.sb.push(' ');
+        }
+    }
+    visitTraversalStrategy(ctx) {
+        if (ctx.getChildCount() === 1) {
+            // No-arg strategy: output name as-is (no .instance())
+            this.sb.push(ctx.getText());
+        }
+        else {
+            // Ensure 'new' keyword is present
+            if (ctx.getChild(0).getText() !== 'new') {
+                this.sb.push('new ');
+            }
+            this.visitChildren(ctx);
+        }
+    }
+    visitTraversalSourceSpawnMethod_inject(ctx) {
+        this.handleInject(ctx);
+    }
+    visitTraversalMethod_inject(ctx) {
+        this.handleInject(ctx);
+    }
+    visitTraversalMethod_hasLabel_String_String(ctx) {
+        if (ctx.getChildCount() > 4 && ctx.getChild(2).getText() === 'null') {
+            const varArgs = ctx.getChild(4);
+            this.sb.push(ctx.getChild(0).getText());
+            this.sb.push('((String) null, ');
+            for (let i = 0; i < varArgs.getChildCount(); i += 2) {
+                if (varArgs.getChild(i).getText() === 'null') {
+                    this.sb.push('(String) null');
+                }
+                else {
+                    this.visit(varArgs.getChild(i));
+                }
+                if (i < varArgs.getChildCount() - 1) {
+                    this.sb.push(', ');
+                }
+            }
+            this.sb.push(')');
+            return;
+        }
+        this.visitChildren(ctx);
+    }
+    visitTraversalMethod_option_Merge_Map(ctx) {
+        this.sb.push('option(');
+        this.visit(ctx.traversalMerge());
+        this.sb.push(', ');
+        this.tryCastMapNullableArgument(ctx.genericMapNullableArgument());
+        this.sb.push(')');
+    }
+    visitTraversalMethod_mergeV_Map(ctx) {
+        this.sb.push('mergeV(');
+        this.tryCastMapNullableArgument(ctx.genericMapNullableArgument());
+        this.sb.push(')');
+    }
+    visitTraversalSourceSpawnMethod_mergeV_Map(ctx) {
+        this.sb.push('mergeV(');
+        this.tryCastMapNullableArgument(ctx.genericMapNullableArgument());
+        this.sb.push(')');
+    }
+    visitTraversalMethod_mergeE_Map(ctx) {
+        this.sb.push('mergeE(');
+        this.tryCastMapNullableArgument(ctx.genericMapNullableArgument());
+        this.sb.push(')');
+    }
+    visitTraversalSourceSpawnMethod_mergeE_Map(ctx) {
+        this.sb.push('mergeE(');
+        this.tryCastMapNullableArgument(ctx.genericMapNullableArgument());
+        this.sb.push(')');
+    }
+    tryCastMapNullableArgument(ctx) {
+        const nullableLit = ctx?.genericMapNullableLiteral?.();
+        if (nullableLit != null && nullableLit?.nullLiteral?.() != null) {
+            this.sb.push('(Map) null');
+        }
+        else {
+            this.visit(ctx);
+        }
+    }
+    /**
+     * Special handling for inject with second `null` argument like g.inject(1, null).
+     * inject() is ambiguous in Groovy with jdk extension inject(Object, Closure).
+     */
+    handleInject(ctx) {
+        if (ctx.getChildCount() > 3) {
+            const child2 = ctx.getChild(2);
+            if (child2?.constructor?.name === 'GenericLiteralVarargsContext') {
+                const varArgs = child2;
+                if (varArgs.getChildCount() === 1) {
+                    const child0 = varArgs.getChild(0);
+                    if (child0?.constructor?.name === 'GenericLiteralExprContext') {
+                        const injectArgs = child0;
+                        if (injectArgs.getChildCount() > 2 && injectArgs.getChild(2).getText() === 'null') {
+                            this.sb.push(ctx.getChild(0).getText());
+                            this.sb.push('(');
+                            for (let i = 0; i < injectArgs.getChildCount(); i += 2) {
+                                if (i === 2) {
+                                    this.sb.push('(Object) null');
+                                }
+                                else {
+                                    this.visit(injectArgs.getChild(i));
+                                }
+                                if (i < injectArgs.getChildCount() - 1) {
+                                    this.sb.push(', ');
+                                }
+                            }
+                            this.sb.push(')');
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+        this.visitChildren(ctx);
+    }
+}
+exports.default = GroovyTranslateVisitor;

package/build/cjs/language/translator/GroovyTranslateVisitor.d.cts

@@ -0,0 +1,37 @@
+import TranslateVisitor from './TranslateVisitor.cjs';
+/**
+ * Converts a Gremlin traversal string into a Groovy source code representation.
+ * Mirrors the Java GroovyTranslateVisitor.
+ */
+export default class GroovyTranslateVisitor extends TranslateVisitor {
+    constructor(graphTraversalSourceName?: string);
+    visitIntegerLiteral(ctx: any): void;
+    visitFloatLiteral(ctx: any): void;
+    visitInfLiteral(ctx: any): void;
+    visitUuidLiteral(ctx: any): void;
+    visitCharacterLiteral(ctx: any): void;
+    visitDurationLiteral(ctx: any): void;
+    visitBinaryLiteral(ctx: any): void;
+    visitNullLiteral(ctx: any): void;
+    visitGenericSetLiteral(ctx: any): void;
+    visitStringLiteral(ctx: any): void;
+    visitStringNullableLiteral(ctx: any): void;
+    visitMapKey(ctx: any): void;
+    visitNakedKey(ctx: any): void;
+    visitKeyword(ctx: any): void;
+    visitTraversalStrategy(ctx: any): void;
+    visitTraversalSourceSpawnMethod_inject(ctx: any): void;
+    visitTraversalMethod_inject(ctx: any): void;
+    visitTraversalMethod_hasLabel_String_String(ctx: any): void;
+    visitTraversalMethod_option_Merge_Map(ctx: any): void;
+    visitTraversalMethod_mergeV_Map(ctx: any): void;
+    visitTraversalSourceSpawnMethod_mergeV_Map(ctx: any): void;
+    visitTraversalMethod_mergeE_Map(ctx: any): void;
+    visitTraversalSourceSpawnMethod_mergeE_Map(ctx: any): void;
+    private tryCastMapNullableArgument;
+    /**
+     * Special handling for inject with second `null` argument like g.inject(1, null).
+     * inject() is ambiguous in Groovy with jdk extension inject(Object, Closure).
+     */
+    private handleInject;
+}