gremlin 3.5.1 → 3.5.4

package/lib/process/traversal.js

@@ -20,9 +20,9 @@
 /**
  * @author Jorge Bay Gondra
  */
+
 'use strict';
 
-const utils = require('../utils');
 const itemDone = Object.freeze({ value: null, done: true });
 const asyncIteratorSymbol = Symbol.asyncIterator || Symbol('@@asyncIterator');
 
@@ -63,19 +63,21 @@ class Traversal {
       }
       return result;
     });
-  };
+  }
 
   /**
    * Determines if there are any more items to iterate from the traversal.
    * @returns {Promise.<boolean>}
    */
-   hasNext() {
-     return this._applyStrategies().then(() => {
-       return this.traversers && this.traversers.length > 0 &&
-              this._traversersIteratorIndex < this.traversers.length &&
-              this.traversers[this._traversersIteratorIndex].bulk > 0;
-     });
-   }
+  hasNext() {
+    return this._applyStrategies().then(
+      () =>
+        this.traversers &&
+        this.traversers.length > 0 &&
+        this._traversersIteratorIndex < this.traversers.length &&
+        this.traversers[this._traversersIteratorIndex].bulk > 0,
+    );
+  }
 
   /**
    * Iterates all Traverser instances in the traversal.
@@ -86,6 +88,7 @@ class Traversal {
     return this._applyStrategies().then(() => {
       let it;
       while ((it = this._getNext()) && !it.done) {
+        //
       }
     });
   }
@@ -105,7 +108,7 @@ class Traversal {
    */
   _getNext() {
     while (this.traversers && this._traversersIteratorIndex < this.traversers.length) {
-      let traverser = this.traversers[this._traversersIteratorIndex];
+      const traverser = this.traversers[this._traversersIteratorIndex];
       if (traverser.bulk > 0) {
         traverser.bulk--;
         return { value: traverser.object, done: false };
@@ -120,14 +123,14 @@ class Traversal {
       // Apply strategies only once
       return this._traversalStrategiesPromise;
     }
-    return this._traversalStrategiesPromise = this.traversalStrategies.applyStrategies(this);
+    return (this._traversalStrategiesPromise = this.traversalStrategies.applyStrategies(this));
   }
 
   /**
    * Returns step instructions during JSON serialization
    * @returns {Array}
    */
-  toJSON(){
+  toJSON() {
     return this.bytecode.stepInstructions;
   }
 
@@ -137,106 +140,103 @@ class Traversal {
    */
   toString() {
     return this.bytecode.toString();
-  };
+  }
 }
 
-
 class IO {
+  static get graphml() {
+    return 'graphml';
+  }
 
- static get graphml() {
-   return "graphml"
- }
-
- static get graphson() {
-   return "graphson"
- }
+  static get graphson() {
+    return 'graphson';
+  }
 
- static get gryo() {
-   return "gryo"
- }
+  static get gryo() {
+    return 'gryo';
+  }
 
- static get reader() {
-   return "~tinkerpop.io.reader"
- }
+  static get reader() {
+    return '~tinkerpop.io.reader';
+  }
 
- static get registry() {
-   return "~tinkerpop.io.registry"
- }
+  static get registry() {
+    return '~tinkerpop.io.registry';
+  }
 
- static get writer() {
-   return "~tinkerpop.io.writer"
- }
+  static get writer() {
+    return '~tinkerpop.io.writer';
+  }
 }
 
+// eslint-disable-next-line no-unused-vars
 class ConnectedComponent {
+  static get component() {
+    return 'gremlin.connectedComponentVertexProgram.component';
+  }
 
- static get component() {
-   return "gremlin.connectedComponentVertexProgram.component"
- }
-
- static get edges() {
-   return "~tinkerpop.connectedComponent.edges"
- }
+  static get edges() {
+    return '~tinkerpop.connectedComponent.edges';
+  }
 
- static get propertyName() {
-   return "~tinkerpop.connectedComponent.propertyName"
- }
+  static get propertyName() {
+    return '~tinkerpop.connectedComponent.propertyName';
+  }
 }
 
+// eslint-disable-next-line no-unused-vars
 class ShortestPath {
+  static get distance() {
+    return '~tinkerpop.shortestPath.distance';
+  }
 
- static get distance() {
-   return "~tinkerpop.shortestPath.distance"
- }
-
- static get edges() {
-   return "~tinkerpop.shortestPath.edges"
- }
+  static get edges() {
+    return '~tinkerpop.shortestPath.edges';
+  }
 
- static get includeEdges() {
-   return "~tinkerpop.shortestPath.includeEdges"
- }
+  static get includeEdges() {
+    return '~tinkerpop.shortestPath.includeEdges';
+  }
 
- static get maxDistance() {
-   return "~tinkerpop.shortestPath.maxDistance"
- }
+  static get maxDistance() {
+    return '~tinkerpop.shortestPath.maxDistance';
+  }
 
- static get target() {
-   return "~tinkerpop.shortestPath.target"
- }
+  static get target() {
+    return '~tinkerpop.shortestPath.target';
+  }
 }
 
+// eslint-disable-next-line no-unused-vars
 class PageRank {
+  static get edges() {
+    return '~tinkerpop.pageRank.edges';
+  }
 
- static get edges() {
-   return "~tinkerpop.pageRank.edges"
- }
-
- static get propertyName() {
-   return "~tinkerpop.pageRank.propertyName"
- }
+  static get propertyName() {
+    return '~tinkerpop.pageRank.propertyName';
+  }
 
- static get times() {
-   return "~tinkerpop.pageRank.times"
- }
+  static get times() {
+    return '~tinkerpop.pageRank.times';
+  }
 }
 
+// eslint-disable-next-line no-unused-vars
 class PeerPressure {
+  static get edges() {
+    return '~tinkerpop.peerPressure.edges';
+  }
 
- static get edges() {
-   return "~tinkerpop.peerPressure.edges"
- }
-
- static get propertyName() {
-   return "~tinkerpop.peerPressure.propertyName"
- }
+  static get propertyName() {
+    return '~tinkerpop.peerPressure.propertyName';
+  }
 
- static get times() {
-   return "~tinkerpop.peerPressure.times"
- }
+  static get times() {
+    return '~tinkerpop.peerPressure.times';
+  }
 }
 
-
 class P {
   /**
    * Represents an operation.
@@ -253,16 +253,16 @@ class P {
    * @returns {string}
    */
   toString() {
-    function formatValue(value){
+    function formatValue(value) {
       if (Array.isArray(value)) {
-        let acc = [];
+        const acc = [];
         for (const item of value) {
           acc.push(formatValue(item));
         }
         return acc;
       }
-      if (value && typeof value === "string"){
-        return "'" + value + "'";
+      if (value && typeof value === 'string') {
+        return `'${value}'`;
       }
       return value;
     }
@@ -283,21 +283,18 @@ class P {
 
   static within(...args) {
     if (args.length === 1 && Array.isArray(args[0])) {
-      return new P("within", args[0], null);
-    } else {
-      return new P("within", args, null);
+      return new P('within', args[0], null);
     }
+    return new P('within', args, null);
   }
 
   static without(...args) {
     if (args.length === 1 && Array.isArray(args[0])) {
-      return new P("without", args[0], null);
-    } else {
-      return new P("without", args, null);
+      return new P('without', args[0], null);
     }
+    return new P('without', args, null);
   }
 
-
   /** @param {...Object} args */
   static between(...args) {
     return createP('between', args);
@@ -352,12 +349,11 @@ class P {
   static test(...args) {
     return createP('test', args);
   }
-
 }
 
 function createP(operator, args) {
   args.unshift(null, operator);
-  return new (Function.prototype.bind.apply(P, args));
+  return new (Function.prototype.bind.apply(P, args))();
 }
 
 class TextP {
@@ -376,9 +372,9 @@ class TextP {
    * @returns {string}
    */
   toString() {
-    function formatValue(value){
-      if (value && typeof value === "string"){
-        return "'" + value + "'";
+    function formatValue(value) {
+      if (value && typeof value === 'string') {
+        return `'${value}'`;
       }
       return value;
     }
@@ -426,12 +422,11 @@ class TextP {
   static startingWith(...args) {
     return createTextP('startingWith', args);
   }
-
 }
 
 function createTextP(operator, args) {
   args.unshift(null, operator);
-  return new (Function.prototype.bind.apply(TextP, args));
+  return new (Function.prototype.bind.apply(TextP, args))();
 }
 
 class Traverser {
@@ -441,26 +436,24 @@ class Traverser {
   }
 }
 
-class TraversalSideEffects {
-
-}
+class TraversalSideEffects {}
 
 const withOptions = {
-  tokens: "~tinkerpop.valueMap.tokens",
+  tokens: '~tinkerpop.valueMap.tokens',
   none: 0,
   ids: 1,
   labels: 2,
   keys: 4,
   values: 8,
   all: 15,
-  indexer: "~tinkerpop.index.indexer",
+  indexer: '~tinkerpop.index.indexer',
   list: 0,
-  map: 1
+  map: 1,
 };
 
 function toEnum(typeName, keys) {
   const result = {};
-  keys.split(' ').forEach(k => {
+  keys.split(' ').forEach((k) => {
     let jsKey = k;
     if (jsKey === jsKey.toUpperCase()) {
       jsKey = jsKey.toLowerCase();
@@ -501,5 +494,5 @@ module.exports = {
   pick: toEnum('Pick', 'any none'),
   pop: toEnum('Pop', 'all first last mixed'),
   scope: toEnum('Scope', 'global local'),
-  t: toEnum('T', 'id key label value')
+  t: toEnum('T', 'id key label value'),
 };

package/lib/structure/graph.js

@@ -57,7 +57,7 @@ class Element {
    * @returns {boolean}
    */
   equals(other) {
-    return (other instanceof Element) && this.id === other.id;
+    return other instanceof Element && this.id === other.id;
   }
 }
 
@@ -119,7 +119,7 @@ class Property {
   }
 
   equals(other) {
-    return (other instanceof Property) && this.key === other.key && this.value === other.value;
+    return other instanceof Property && this.key === other.key && this.value === other.value;
   }
 }
 
@@ -136,7 +136,7 @@ class Path {
   }
 
   toString() {
-    return `path[${(this.objects || []).join(", ")}]`;
+    return `path[${(this.objects || []).join(', ')}]`;
   }
 
   equals(other) {
@@ -162,7 +162,7 @@ function areEqual(obj1, obj2) {
       return false;
     }
     for (let i = 0; i < obj1.length; i++) {
-      if (!areEqual(obj1[i], obj2[i])){
+      if (!areEqual(obj1[i], obj2[i])) {
         return false;
       }
     }
@@ -186,5 +186,5 @@ module.exports = {
   Path,
   Property,
   Vertex,
-  VertexProperty
+  VertexProperty,
 };

package/lib/structure/io/binary/GraphBinary.js

@@ -0,0 +1,109 @@
+/*
+ *  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.
+ */
+
+/**
+ * GraphBinary 1.0 support implementation.
+ *
+ * The officially expected entrypoint is GraphBinaryReader/GraphBinaryWriter pair of classes,
+ * examine lib/driver/** for use cases.
+ *
+ * See AnySerializer.serialize() for the mechanism of serializer selection for a given JavaScript value,
+ * also consider AnySerializer.serialize() unit tests for real examples.
+ * See NumberSerializationStrategy to understand how it deals with JavaScript numbers' serialization.
+ *
+ * Consider AnySerializer.serialize()/deserialize() unit tests to see what is not implemented,
+ * what is ignored, what is not expected to be (de)serialized, etc.
+ *
+ * TODO: it has the following open topics:
+ * - [] Should we do anything for application/vnd.graphbinary-v1.0-stringd mime type support?
+ * Core Data Types support:
+ * - [] 0x22: BigDecimal
+ * - [] 0x2b: Tree
+ * - [] 0x2c: Metrics
+ * - [] 0x2d: TraversalMetrics
+ * - [] 0x00: Custom
+ * Extended Types support:
+ * - [] 0x80: Char
+ * - [] 0x81: Duration
+ * - [] 0x82: InetAddress
+ * - [] 0x83: Instant
+ * - [] 0x84: LocalDate
+ * - [] 0x85: LocalDateTime
+ * - [] 0x86: LocalTime
+ * - [] 0x87: MonthDay
+ * - [] 0x88: OffsetDateTime
+ * - [] 0x89: OffsetTime
+ * - [] 0x8a: Period
+ * - [] 0x8b: Year
+ * - [] 0x8c: YearMonth
+ * - [] 0x8d: ZonedDateTime
+ * - [] 0x8e: ZoneOffset
+ *
+ * @author Igor Ostapenko
+ */
+/*eslint-disable*/
+'use strict';
+
+const ioc = {};
+
+ioc.DataType = require('./internals/DataType');
+ioc.utils = require('./internals/utils');
+
+ioc.serializers = {};
+
+ioc.intSerializer               = new (require('./internals/IntSerializer'))(ioc);
+ioc.longSerializer              = new (require('./internals/LongSerializer'))(ioc);
+ioc.longSerializerNg            = new (require('./internals/LongSerializerNg'))(ioc);
+ioc.stringSerializer            = new (require('./internals/StringSerializer'))(ioc, ioc.DataType.STRING);
+ioc.dateSerializer              = new (require('./internals/DateSerializer'))(ioc, ioc.DataType.DATE);
+ioc.timestampSerializer         = new (require('./internals/DateSerializer'))(ioc, ioc.DataType.TIMESTAMP);
+ioc.classSerializer             = new (require('./internals/StringSerializer'))(ioc, ioc.DataType.CLASS);
+ioc.doubleSerializer            = new (require('./internals/DoubleSerializer'))(ioc);
+ioc.floatSerializer             = new (require('./internals/FloatSerializer'))(ioc);
+ioc.listSerializer              = new (require('./internals/ArraySerializer'))(ioc, ioc.DataType.LIST);
+ioc.mapSerializer               = new (require('./internals/MapSerializer'))(ioc);
+ioc.setSerializer               = new (require('./internals/ArraySerializer'))(ioc, ioc.DataType.SET);
+ioc.uuidSerializer              = new (require('./internals/UuidSerializer'))(ioc);
+ioc.edgeSerializer              = new (require('./internals/EdgeSerializer'))(ioc);
+ioc.pathSerializer              = new (require('./internals/PathSerializer'))(ioc);
+ioc.propertySerializer          = new (require('./internals/PropertySerializer'))(ioc);
+ioc.vertexSerializer            = new (require('./internals/VertexSerializer'))(ioc);
+ioc.vertexPropertySerializer    = new (require('./internals/VertexPropertySerializer'))(ioc);
+ioc.bytecodeSerializer          = new (require('./internals/BytecodeSerializer'))(ioc);
+ioc.pSerializer                 = new (require('./internals/PSerializer'))(ioc);
+ioc.traverserSerializer         = new (require('./internals/TraverserSerializer'))(ioc);
+ioc.enumSerializer              = new (require('./internals/EnumSerializer'))(ioc);
+ioc.lambdaSerializer            = new (require('./internals/LambdaSerializer'))(ioc);
+ioc.bigIntegerSerializer        = new (require('./internals/BigIntegerSerializer'))(ioc);
+ioc.byteSerializer              = new (require('./internals/ByteSerializer'))(ioc);
+ioc.byteBufferSerializer        = new (require('./internals/ByteBufferSerializer'))(ioc);
+ioc.shortSerializer             = new (require('./internals/ShortSerializer'))(ioc);
+ioc.booleanSerializer           = new (require('./internals/BooleanSerializer'))(ioc);
+ioc.textPSerializer             = new (require('./internals/TextPSerializer'))(ioc);
+ioc.traversalStrategySerializer = new (require('./internals/TraversalStrategySerializer'))(ioc);
+ioc.bulkSetSerializer           = new (require('./internals/BulkSetSerializer'))(ioc);
+ioc.unspecifiedNullSerializer   = new (require('./internals/UnspecifiedNullSerializer'))(ioc);
+
+ioc.numberSerializationStrategy = new (require('./internals/NumberSerializationStrategy'))(ioc);
+ioc.anySerializer               = new (require('./internals/AnySerializer'))(ioc);
+
+ioc.graphBinaryReader           = new (require('./internals/GraphBinaryReader.js'))(ioc);
+ioc.graphBinaryWriter           = new (require('./internals/GraphBinaryWriter'))(ioc);
+
+module.exports = ioc;

package/lib/structure/io/binary/internals/AnySerializer.js

@@ -0,0 +1,95 @@
+/*
+ *  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.
+ */
+
+/**
+ * @author Igor Ostapenko
+ */
+'use strict';
+
+module.exports = class AnySerializer {
+  constructor(ioc) {
+    this.ioc = ioc;
+
+    // specifically ordered, the first canBeUsedFor=true wins
+    this.serializers = [
+      ioc.unspecifiedNullSerializer,
+
+      ioc.numberSerializationStrategy,
+
+      ioc.booleanSerializer,
+      ioc.dateSerializer,
+      ioc.bytecodeSerializer,
+      ioc.pSerializer,
+      ioc.traverserSerializer,
+      ioc.enumSerializer,
+      ioc.listSerializer,
+      ioc.uuidSerializer,
+      ioc.edgeSerializer,
+      ioc.pathSerializer,
+      ioc.propertySerializer,
+      ioc.vertexSerializer,
+      ioc.vertexPropertySerializer,
+      ioc.stringSerializer,
+      ioc.textPSerializer,
+      ioc.traversalStrategySerializer,
+
+      ioc.byteBufferSerializer, // Buffer instance
+      ioc.lambdaSerializer, // any function
+      ioc.mapSerializer, // Map or any Object
+    ];
+  }
+
+  getSerializerCanBeUsedFor(item) {
+    for (let i = 0; i < this.serializers.length; i++) {
+      if (this.serializers[i].canBeUsedFor(item)) {
+        return this.serializers[i];
+      }
+    }
+
+    throw new Error(
+      `No serializer found to support item where typeof(item)='${typeof item}' and String(item)='${String(item)}'.`,
+    );
+  }
+
+  serialize(item, fullyQualifiedFormat = true) {
+    return this.getSerializerCanBeUsedFor(item).serialize(item, fullyQualifiedFormat);
+  }
+
+  deserialize(buffer) {
+    // obviously, fullyQualifiedFormat always is true
+    try {
+      if (buffer === undefined || buffer === null || !(buffer instanceof Buffer)) {
+        throw new Error('buffer is missing');
+      }
+      if (buffer.length < 1) {
+        throw new Error('buffer is empty');
+      }
+
+      const type_code = buffer.readUInt8();
+      const serializer = this.ioc.serializers[type_code];
+      if (!serializer) {
+        throw new Error('unknown {type_code}');
+      }
+
+      return serializer.deserialize(buffer);
+    } catch (err) {
+      throw this.ioc.utils.des_error({ serializer: this, args: arguments, err });
+    }
+  }
+};