Fix schema parsing

Author: keithwhor

lib/parser/function_parser.js

@@ -204,6 +204,17 @@ FunctionParser.definitionFields = {
             )
             : true
         ) &&
+        // (
+        //   'alternateSchemas' in param
+        //   ? (
+        //     (['object'].indexOf(param.type) !== -1) &&
+        //     Array.isArray(param.alternateSchemas) &&
+        //     param.alternateSchemas.filter(schema => {
+        //       return FunctionParser.definitionFields['params'](schema);
+        //     }).length === param.alternateSchemas.length
+        //   )
+        //   : true
+        // ) &&
         types.list.indexOf(param.type) > -1
     }).length === params.length;
   },

lib/parser/nodejs/comment_definition_parser.js

@@ -30,7 +30,7 @@ class CommentDefinitionParser {
       let field = splitLine.shift();
       line = splitLine.join(' ');
       if (!field && previous && (previous.field === 'param' || previous.field === 'returns')) {
-        previous.schema = (previous.schema || []).concat(line);
+        previous.textSchema = (previous.textSchema || []).concat([[line]]);
         return semanticsList;
       } else if (DEFINITION_FIELDS.indexOf(field) === -1) {
         throw new Error(`Invalid Definition Field: "${field}"`);
@@ -50,17 +50,14 @@ class CommentDefinitionParser {
         values: [line.trim()]
       });
     } else if (previous) {
-      let lastSchemaItem = previous.schema && previous.schema[previous.schema.length - 1];
-      let lastSchemaArray = Array.isArray(lastSchemaItem)
-        ? lastSchemaItem
-        : lastSchemaItem
-          ? [lastSchemaItem.trim()]
-          : [];
-      let isEnum = /^{\??enum}/i.test(lastSchemaArray[0]);
+      let lastSchemaItem = previous.textSchema
+        ? previous.textSchema[previous.textSchema.length - 1]
+        : [''];
+      let isEnum = /^{\??enum}/i.test(lastSchemaItem[0].trim());
       // Enums inside schemas need to be collected as a single item
       if (isEnum) {
-        lastSchemaArray = lastSchemaArray.concat(line.trim());
-        previous.schema[previous.schema.length - 1] = lastSchemaArray;
+        lastSchemaItem = lastSchemaItem.concat(line.trim());
+        previous.textSchema[previous.textSchema.length - 1] = lastSchemaItem;
       } else {
         previous.values = previous.values.concat(line.trim());
       }
@@ -125,7 +122,8 @@ class CommentDefinitionParser {
     return values.join(' ').split(/\s+/);
   }
 
-  getParameter (values, schema) {
+  getParameter (values, textSchema = [], depth = 0) {
+
     if (!Array.isArray(values)) {
       values = [values];
     }
@@ -168,7 +166,7 @@ class CommentDefinitionParser {
     }
 
     if (type === 'enum') {
-      let splitValue = values[0].split(' ').slice(1);
+      let splitValue = values[0].trim().split(' ').slice(1);
       param.name = splitValue.shift();
       param.description = splitValue.join(' ');
       param.members = this.parseEnumMembers(values.slice(1));
@@ -178,11 +176,15 @@ class CommentDefinitionParser {
     let splitValue = value.split(' ');
     param.name = splitValue.shift();
     param.description = splitValue.join(' ');
-    if (schema) {
+    if (textSchema.length) {
       if (!['object', 'array'].includes(type)) {
         throw new Error(`Can not provide schema for type: "${type}"`);
       }
-      param.schema = this.parseSchema(schema, type === 'object');
+      let schemas = this.parseSchemas(textSchema, depth, type === 'object');
+      param.schema = schemas.shift();
+      if (schemas.length) {
+        param.alternateSchemas = schemas;
+      }
     }
 
     if (defaultMetafield) {
@@ -197,8 +199,8 @@ class CommentDefinitionParser {
         throw new Error(`Options {?}: Not allowed for type "${param.type}" for parameter "${param.name}"`);
       }
       param.options = {};
-      var opt = options.split(' ');
-      var values;
+      let opt = options.split(' ');
+      let values;
       try {
         values = JSON.parse(options);
       } catch (e) {
@@ -208,7 +210,7 @@ class CommentDefinitionParser {
         if (values.length === 0) {
           throw new Error(`Options {?}: Must provide non-zero options length`);
         }
-        var paramType = (param.type === 'object.keyql.query' || param.type === 'object.keyql.order')
+        let paramType = (param.type === 'object.keyql.query' || param.type === 'object.keyql.order')
           ? 'string'
           : param.type;
         values.forEach(v => {
@@ -221,12 +223,12 @@ class CommentDefinitionParser {
         if (!opt[0] || opt[0].indexOf('.') === -1) {
           throw new Error(`Options {?}: Invalid API call for "${param.name}": "${opt[1]}"`);
         } else {
-          var call = /^(.+?)(?:\((.*)\))?$/gi.exec(opt[0]);
+          let call = /^(.+?)(?:\((.*)\))?$/gi.exec(opt[0]);
           param.options.lib = call[1];
           if (call[2]) {
             param.options.map = (call[2] || '').split(',').reduce((map, p) => {
-              var key = p.split('=')[0];
-              var value = p.split('=').slice(1).join('=');
+              let key = p.split('=')[0];
+              let value = p.split('=').slice(1).join('=');
               if (!key.match(/^[a-z0-9\_]+$/i) || !value.match(/^[a-z0-9\_]+$/i)) {
                 throw new Error(`Options {?}: Invalid API call parameters for "${param.name}": "${call[2]}"`);
               }
@@ -261,17 +263,17 @@ class CommentDefinitionParser {
 
     let field = data.field;
     let values = data.values;
-    let schema = data.schema;
+    let textSchema = data.textSchema;
 
     try {
 
       if (field === 'description') {
         definition.description = values.join('\n');
       } else if (field === 'param') {
         definition.params = definition.params || [];
-        definition.params.push(this.getParameter(values, schema));
+        definition.params.push(this.getParameter(values, textSchema));
       } else if (field === 'returns') {
-        definition.returns = this.getParameter(values, schema);
+        definition.returns = this.getParameter(values, textSchema);
       } else if (field === 'bg') {
         definition.bg = this.getBg(values);
       } else if (field === 'acl') {
@@ -317,71 +319,57 @@ class CommentDefinitionParser {
 
   }
 
-  parseSchema (schema, multipleKeys) {
-    if (schema.length && !Array.isArray(schema[0]) && this.getLineDepth(schema[0])) {
-      throw new Error(`Invalid Schema definition at: "${schema[0]}"`);
+  parseSchemas (textSchema, depth = 0, allowMultipleEntries = false) {
+    let schemas = [];
+    while (textSchema.length) {
+      let line = textSchema[0][0];
+      let params = [];
+      let schema = this._parseSchema(textSchema, params, depth);
+      if (!allowMultipleEntries && schema.length > 1) {
+        throw new Error(`Invalid Schema definition at "${line}": Schema for "array" can only support one top-level key that maps to every element.`);
+      }
+      schemas.push(schema);
     }
-
-    let parsedSchema = this._parseSchema(schema, [], 0);
-
-    if (!multipleKeys && parsedSchema.length > 1) {
-      throw new Error('Schema for "array" can only support one top-level key that maps to every element.');
+    if (!allowMultipleEntries && schemas.length > 1) {
+      throw new Error(`Invalid Schema definition at "${line}": Schema for "array" does not support OR (alternateSchemas).`);
+    } else if (schemas.filter(params => !params.length).length > 0) {
+      throw new Error(`Invalid Schema definition at "${line}": OR (alternateSchemas) requires all schema lengths to be non-zero`);
     }
-
-    return parsedSchema;
-
+    return schemas;
   }
 
-  _parseSchema (schema, params, lastDepth) {
+  _parseSchema (textSchema, params = [], depth = 0) {
 
-    if (!schema.length) {
-      return params;
+    let values = textSchema.shift();
+    let line = values[0];
+    let curDepth = this.getLineDepth(line);
+    if (depth !== curDepth) {
+      throw new Error(`Invalid Schema definition at: "${line}", invalid line depth (expecting ${depth}, found ${curDepth})`);
     }
-
-    let line = schema.shift();
-    let lastParam = params[params.length - 1];
-
-
-    // Just call this.getParameter to collect the enum and continue
-    if (Array.isArray(line)) {
-      let param = this.getParameter(line);
-
-      if (lastParam && (lastParam.type === 'object' || lastParam.type === 'array')) {
-        lastParam.schema = this._parseSchema(schema, [param], lastDepth + 1);
-        return this._parseSchema(schema, params, lastDepth);
+    if (line.trim() === 'OR') {
+      if (!textSchema.length) {
+        throw new Error(`Invalid Schema definition at "${line}": OR (alternateSchemas) can not end a schema definition`);
       }
-
-      params.push(param);
-      return this._parseSchema(schema, params, lastDepth);
-    }
-
-    let depth = this.getLineDepth(line);
-    let param = this.getParameter(line.trim());
-    let step = depth - lastDepth;
-
-    if (!lastParam || step === 0) {
-      params.push(param);
-      return this._parseSchema(schema, params, depth);
-    }
-
-    if (step === 1) {
-      if (lastParam.type !== 'object' && lastParam.type !== 'array') {
-        throw new Error(`Invalid Schema definition at: "${line}", can only define schemas for an object or array`);
+      return params;
+    } else {
+      let subSchemaEnd = textSchema.findIndex(values => {
+        let line = values[0];
+        return this.getLineDepth(line) <= curDepth;
+      });
+      let subSchema;
+      if (subSchemaEnd === -1) {
+        subSchema = textSchema.splice(0, textSchema.length);
+      } else if (subSchemaEnd) {
+        subSchema = textSchema.splice(0, subSchemaEnd);
       }
-      lastParam.schema = this._parseSchema(schema, [param], depth);
-      return this._parseSchema(schema, params, lastDepth);
-    }
-
-    if (step > 1) {
-      throw new Error(`Invalid Schema definition at: "${line}", spacing invalid`);
+      params.push(this.getParameter(values, subSchema, depth + 1));
+      return textSchema.length
+        ? this._parseSchema(textSchema, params, depth)
+        : params;
     }
-
-    schema.unshift(line);
-    return params;
-
   }
 
-  getLineDepth(line) {
+  getLineDepth (line) {
 
     let depth = (line.length - line.replace(/^\s*/, '').length) / 2;
 

lib/types.js

@@ -90,7 +90,6 @@ const _validations = {
     try {
       KeyQL.validateOrderObject(v, options);
     } catch (e) {
-      console.log('VALIDATE?', e);
       return false;
     }
     return true;

tests/files/cases/function_invalid_multiple_schema.js

@@ -0,0 +1,13 @@
+/**
+* Accepts multiple schemas for an object
+* @param {object} fileOrFolder
+* @ {string} name
+* @ {number} size
+* @  OR
+* @ {string} name2
+* @ {number} size2
+* @returns {object}
+*/
+module.exports = async (fileOrFolder) => {
+  return true;
+};

tests/files/cases/function_invalid_multiple_schema_empty.js

@@ -0,0 +1,11 @@
+/**
+* Accepts multiple schemas for an object
+* @param {object} fileOrFolder
+* @ OR
+* @ {string} name
+* @ {number} size
+* @returns {object}
+*/
+module.exports = async (fileOrFolder) => {
+  return true;
+};

tests/files/cases/function_invalid_multiple_schema_empty_late.js

@@ -0,0 +1,11 @@
+/**
+* Accepts multiple schemas for an object
+* @param {object} fileOrFolder
+* @ {string} name
+* @ {number} size
+* @ OR
+* @returns {object}
+*/
+module.exports = async (fileOrFolder) => {
+  return true;
+};

tests/files/cases/function_invalid_multiple_schema_nested.js

@@ -0,0 +1,17 @@
+/**
+* Accepts multiple schemas for an object
+* @param {object} fileOrFolder
+* @ {string} name
+* @ {number} size
+* @ OR
+* @ {string} name2
+* @ {number} size2
+* @ {object} props
+* @   {string} label
+* @ OR
+* @   {number} size
+* @returns {object}
+*/
+module.exports = async (fileOrFolder) => {
+  return true;
+};

tests/files/cases/function_valid_multiple_schema.js

@@ -0,0 +1,13 @@
+/**
+* Accepts multiple schemas for an object
+* @param {object} fileOrFolder
+* @ {string} name
+* @ {number} size
+* @ OR
+* @ {string} name2
+* @ {number} size2
+* @returns {object}
+*/
+module.exports = async (fileOrFolder) => {
+  return true;
+};

tests/files/cases/function_valid_multiple_schema_nested.js

@@ -0,0 +1,17 @@
+/**
+* Accepts multiple schemas for an object
+* @param {object} fileOrFolder
+* @ {string} name
+* @ {number} size
+* @ OR
+* @ {string} name2
+* @ {number} size2
+* @ {object} props
+* @   {string} label
+* @   OR
+* @   {number} size
+* @returns {object}
+*/
+module.exports = async (fileOrFolder) => {
+  return true;
+};

tests/files/cases/function_valid_multiple_schema_nested_returns.js

@@ -0,0 +1,26 @@
+/**
+* Accepts multiple schemas for an object
+* @param {object} fileOrFolder
+* @ {string} name
+* @ {number} size
+* @ OR
+* @ {string} name2
+* @ {number} size2
+* @ {object} props
+* @   {string} label
+* @   OR
+* @   {number} size
+* @returns {object} fileOrFolder
+* @ {string} name
+* @ {number} size
+* @ OR
+* @ {string} name2
+* @ {number} size2
+* @ {object} props
+* @   {string} label
+* @   OR
+* @   {number} size
+*/
+module.exports = async (fileOrFolder) => {
+  return true;
+};