feat: add support for abstract references

Ref #9

Author: char0n

apidom/packages/apidom-parser-adapter-openapi3/src/parser/visitors/generics.js

@@ -0,0 +1,133 @@
+'use strict';
+
+const { last } = require('ramda');
+const { addSourceMap } = require('../source-map');
+const { visit } = require('../visitor');
+
+const ArrayVisitor = () => {
+  const stack = [];
+
+  return {
+    element: null,
+
+    object(objectNode) {
+      const arrayElement = last(stack);
+      const objectVisitor = ObjectVisitor();
+      const state = { namespace: this.namespace, sourceMap: this.sourceMap };
+
+      visit(objectNode, objectVisitor, { state });
+
+      const { element: objectElement } = objectVisitor;
+
+      arrayElement.push(this.sourceMap ? addSourceMap(objectNode, objectElement) : objectElement);
+
+      return false;
+    },
+
+    string(stringNode) {
+      const arrayElement = last(stack);
+      const stringElement = new this.namespace.elements.String(stringNode.value);
+
+      arrayElement.push(this.sourceMap ? addSourceMap(stringNode, stringElement) : stringElement);
+    },
+
+    number(numberNode) {
+      const arrayElement = last(stack);
+      const numberElement = new this.namespace.elements.Number(Number(numberNode.value));
+
+      arrayElement.push(this.sourceMap ? addSourceMap(numberNode, numberElement) : numberElement);
+    },
+
+    true(trueNode) {
+      const arrayElement = last(stack);
+      const booleanElement = new this.namespace.elements.Boolean(trueNode.value);
+
+      arrayElement.push(this.sourceMap ? addSourceMap(trueNode, booleanElement) : booleanElement);
+    },
+
+    false(falseNode) {
+      const arrayElement = last(stack);
+      const booleanElement = new this.namespace.elements.Boolean(falseNode.value);
+
+      arrayElement.push(this.sourceMap ? addSourceMap(falseNode, booleanElement) : booleanElement);
+    },
+
+    null(nullNode) {
+      const arrayElement = last(stack);
+      const nullElement = new this.namespace.elements.Null(nullNode.value);
+
+      arrayElement.push(this.sourceMap ? addSourceMap(nullNode, nullElement) : nullElement);
+    },
+
+    array: {
+      enter() {
+        stack.push(new this.namespace.elements.Array());
+      },
+      leave() {
+        this.element = stack.pop();
+      }
+    }
+  };
+};
+
+const ObjectVisitor = () => {
+  const stack =  [];
+
+  return {
+    element: null,
+
+    property(propertyNode) {
+      const objElement = last(stack);
+      const { MemberElement } = this.namespace.elements.Element.prototype;
+      let keyElement;
+      let valueElement;
+
+      // object property key handling
+      keyElement = new this.namespace.elements.String(propertyNode.key.value);
+
+      // object property value handling
+      if (propertyNode.value.type === 'object') {
+        const objectVisitor = ObjectVisitor();
+        const state = { namespace: this.namespace, sourceMap: this.sourceMap };
+
+        visit(propertyNode.value, objectVisitor, { state });
+
+        ({ element: valueElement } = objectVisitor);
+      } else if (propertyNode.value.type === 'array') {
+        const arrayVisitor = ArrayVisitor();
+        const state = { namespace: this.namespace, sourceMap: this.sourceMap };
+
+        visit(propertyNode.value, arrayVisitor, { state });
+
+        ({ element: valueElement } = arrayVisitor);
+      } else if (propertyNode.key.value === '$ref') { // $ref property key special handling
+        valueElement = new this.namespace.elements.Ref(propertyNode.value.value);
+        valueElement.path = propertyNode.value.value;
+      } else {
+        valueElement = this.namespace.toElement(propertyNode.value.value);
+      }
+
+      objElement.content.push(
+        new MemberElement(
+          this.sourceMap ? addSourceMap(propertyNode.key, keyElement) : keyElement,
+          this.sourceMap ? addSourceMap(propertyNode.value, valueElement): valueElement,
+        )
+      );
+
+      return false;
+    },
+    object: {
+      enter() {
+        stack.push(new this.namespace.elements.Object());
+      },
+      leave() {
+        this.element = stack.pop();
+      }
+    }
+  };
+};
+
+module.exports = {
+  ObjectVisitor,
+  ArrayVisitor,
+};

apidom/packages/apidom-parser-adapter-openapi3/src/parser/visitors/schema.js

@@ -1,18 +1,25 @@
 'use strict';
 
-const { AST: { JsonNode } } = require('json-ast');
-
+const { addSourceMap } = require('../source-map');
 const { visit } = require('../visitor');
+const { ObjectVisitor } = require('./generics');
 
 const SchemaVisitor = () => ({
   element: null,
-  schema: null,
 
   object(objectNode) {
     const { MemberElement } = this.namespace.elements.Element.prototype;
+    const schemaKeyElement = new this.namespace.elements.String(this.schemaKeyNode.value);
+    const state = { namespace: this.namespace, sourceMap: this.sourceMap };
+    const objectVisitor = ObjectVisitor();
+
+    visit(objectNode, objectVisitor, { state });
+    const schemaElement = new this.namespace.elements.Schema(objectVisitor.element.content)
 
-    this.schema = new this.namespace.elements.Schema(JsonNode.toJSON(objectNode));
-    this.element = new MemberElement(this.schemaName, this.schema);
+    this.element = new MemberElement(
+      this.sourceMap ? addSourceMap(this.schemaKeyNode, schemaKeyElement) : schemaKeyElement,
+      this.sourceMap ? addSourceMap(objectNode, schemaElement) : schemaElement,
+    );
 
     return false;
   }

apidom/packages/apidom-parser-adapter-openapi3/src/parser/visitors/schemas.js

@@ -9,14 +9,14 @@ const SchemasVisitor = () => ({
 
   property(propertyNode) {
     const state = { namespace: this.namespace, sourceMap: this.sourceMap };
-    const schemaVisitor = SchemaVisitor();
     const schemasElement = parseSchemas(
       { namespace: this.namespace, sourceMap: this.sourceMap },
       propertyNode,
     );
 
     propertyNode.value.properties.forEach(schemaNode => {
-      visit(schemaNode, schemaVisitor, { state: { ...state, schemaName: schemaNode.key.value } });
+      const schemaVisitor = SchemaVisitor();
+      visit(schemaNode, schemaVisitor, { state: { ...state, schemaKeyNode: schemaNode.key } });
 
       schemasElement.value.content.push(schemaVisitor.element);
     });