Plato - lib/processor.js

const p    = require('path');
const slug = require('slug');
const util = require('util');

slug.defaults.mode = 'rfc3986';
slug.defaults.modes.rfc3986 = {
  replacement: '_',
  symbols: true,
  remove: /\.|dollar/g,
  lower: false,
  charmap: slug.charmap,
  multicharmap: slug.multicharmap
};

/**
 * Iterate and process each response based on its root data type.
 *
 * @param {Array} responses: an array of responses
 * @param {Array} definitions: will be populated with definition object
 */
function generateDefinitions(responses, definitions) {
  responses.forEach(function(response) {
    if (Array.isArray(response)) {
      exports.processArray(response, definitions);
    } else {
      exports.processObject(response, definitions);
    }
  });
}

/**
 * Process a single response object by traversing its properties, each one will
 * be processed based on its data type.
 *
 * @param {Object} response: response object
 * @param {Object} definitions: the definition generated from the response will
 * be added to this definitions object
 */
function processObject(response, definitions) {
  if (!response._class) {
    response._class = p.basename(response.__sourcePath, p.extname(response.__sourcePath));
    console.warn('Setting placeholder _class %s -  value is a classless object', response._class);
  }

var definitionId = slug(response._class);
  console.log('Constructing definition %s...'.green, definitionId);

var definition = {
    type: 'object',
    properties: {},
    id: definitionId
  };

Object.keys(response).forEach(function (key) {
    if (['__sourcePath', '_class'].indexOf(key) !== -1) {
      return;
    }
    value = response[key];
    console.log('Processing property %s'.grey, key);
    var opts = {};
    if (value === null) {
      exports._processNullProperty(key, value, definition, definitions, opts);
    } else if (typeof value === 'string') {
      exports._processStringProperty(key, value, definition, definitions, opts);
    } else if (typeof value === 'number') {
      exports._processNumberProperty(key, value, definition, definitions, opts);
    } else if (typeof value === 'boolean') {
      exports._processBooleanProperty(key, value, definition, definitions, opts);
    } else if (Array.isArray(value)) {
      opts.parentDefinitionId = definitionId;
      exports._processArrayProperty(key, value, definition, definitions, opts);
    } else if (typeof value === 'object') {
      exports._processObjectProperty(key, value, definition, definitions, opts);
    } else {
      exports._processUnknownProperty(key, value, definition, definitions, opts);
    }
  });

delete definition.id;
  if (definitions[definitionId]) {
    console.warn('Definition %s already exists and properties will be merged'.yellow, definitionId);
    Object.keys(definition.properties).forEach(function (key) {
      if (!definitions[definitionId].properties[key]) {
        console.warn('Merging property %s'.gray, key);
        definitions[definitionId].properties[key] = definition.properties[key];
      }
    });
  } else {
    definitions[definitionId] = definition;
  }
}

/**
 * Process a single response array by iterating its properties, each one will
 * be processed based on its data type.
 *
 * @param {Array} response: response array
 * @param {Object} definitions: the definition generated from the response will
 * be added to this definitions object
 */
function processArray(response, definitions) {
  var placeholderClass = p.basename(response.__sourcePath, p.extname(response.__sourcePath));
  var definitionId = slug(placeholderClass);
  if (response.length > 0) {
    console.log('Constructing definition %s...'.green, definitionId);

function _processStringProperty(key, value, definition, definitions, opts) {
  definition.properties[key] = {
    type: 'string'
  };
}

function _processNullProperty(key, value, definition, definitions, opts) {
  definition.properties[key] = {
    type: 'string'
  };
}

function _processNumberProperty(key, value, definition, definitions, opts) {
  definition.properties[key] = {
    type: 'integer'
  };
}

function _processBooleanProperty(key, value, definition, definitions, opts) {
  definition.properties[key] = {
    type: 'boolean'
  };
}

function _processUnknownProperty(key, value, definition, definitions, opts) {
  console.error('Unsupported property type %s'.red, typeof value);
}

exports.generateDefinitions     = generateDefinitions;
exports.processArray            = processArray;
exports.processObject           = processObject;
exports._processObjectProperty  = _processObjectProperty;
exports._processStringProperty  = _processStringProperty;
exports._processNullProperty    = _processNullProperty;
exports._processNumberProperty  = _processNumberProperty;
exports._processArrayProperty   = _processArrayProperty;
exports._processBooleanProperty = _processBooleanProperty;
exports._processUnknownProperty = _processUnknownProperty;

lib/processor.js

Maintainability

Lines of code

Difficulty

Estimated Errors

Function weight

By Complexity

By SLOC