fbp-protocol/src/Documentation.js

var fillRefs, fs, getDescriptions, getSchemas, isAllowedTypeless, mergeAllOf, path, renderCapabilities, renderMessage, renderMessages, renderProperty, schemas,
  hasProp = {}.hasOwnProperty;

fs = require('fs');

path = require('path');

schemas = null;

getSchemas = function() {
  var dir, filename, i, jsonFile, len, name, ref, schema;
  if (!schemas) {
    schemas = {};
    dir = './schema/json/';
    ref = fs.readdirSync(dir);
    for (i = 0, len = ref.length; i < len; i++) {
      jsonFile = ref[i];
      if (jsonFile !== '.' && jsonFile !== '..') {
        name = jsonFile.split('.')[0];
        filename = path.join(dir, jsonFile);
        schema = JSON.parse(fs.readFileSync(filename));
        schemas[name] = schema;
      }
    }
  }
  return schemas;
};

fillRefs = function(obj, baseUrl) {
  var key, newObj, refKey, refObj, refValue, schemaPath, tv4, value;
  tv4 = require('../schema/index.js');
  if (typeof obj !== 'object') {
    return obj;
  } else if ((typeof obj) === 'object' && (obj.length != null)) {
    return obj.map(function(item) {
      return fillRefs(item, baseUrl);
    });
  }
  newObj = {};
  for (key in obj) {
    if (!hasProp.call(obj, key)) continue;
    value = obj[key];
    if (key === '$ref') {
      schemaPath = value;
      if (schemaPath.indexOf('../') !== -1) {
        schemaPath = path.resolve(path.dirname(`${baseUrl}${obj.id}`), value);
      }
      refObj = fillRefs(tv4.getSchema(schemaPath), baseUrl);
      for (refKey in refObj) {
        if (!hasProp.call(refObj, refKey)) continue;
        refValue = refObj[refKey];
        newObj[refKey] = refValue;
      }
    } else {
      newObj[key] = fillRefs(value, baseUrl);
    }
  }
  return newObj;
};

mergeAllOf = function(obj) {
  var i, key, len, mergeObj, newObj, prop, propName, ref, value;
  if (!(typeof obj === "object" && (obj.length == null))) {
    return obj;
  }
  newObj = {};
  for (key in obj) {
    value = obj[key];
    if (key === 'allOf') {
      ref = obj[key];
      for (i = 0, len = ref.length; i < len; i++) {
        mergeObj = ref[i];
        for (propName in mergeObj) {
          prop = mergeObj[propName];
          if (newObj[propName] == null) {
            newObj[propName] = prop;
          }
        }
      }
    } else if (typeof value === "object" && (value.length == null)) {
      newObj[key] = mergeAllOf(value);
    } else {
      newObj[key] = value;
    }
  }
  return newObj;
};

// transforms schemas into format better suited to be added to docs
getDescriptions = function(schemas) {
  var categories, category, desc, event, i, key, len, message, messages, protocol, protocols, ref, ref1, schema, value;
  desc = {};
  protocols = {
    runtime: ['input', 'output'],
    graph: ['input'],
    component: ['input', 'output'],
    network: ['input', 'output'],
    trace: ['input', 'output']
  };
  for (protocol in protocols) {
    categories = protocols[protocol];
    messages = {};
    desc[protocol] = {
      title: schemas[protocol].title,
      description: schemas[protocol].description,
      messages: messages
    };
    for (i = 0, len = categories.length; i < len; i++) {
      category = categories[i];
      ref = schemas[protocol][category];
      for (event in ref) {
        schema = ref[event];
        schema = fillRefs(schema, `/${protocol}/`);
        message = {
          id: schema.id,
          description: schema.description
        };
        if (schema.allOf != null) {
          ref1 = schema.allOf[1].properties.payload;
          //console.log 'sc', schema.allOf[1].properties
          for (key in ref1) {
            value = ref1[key];
            message[key] = value;
          }
        }
        //if event == 'error'
        //  console.log 'm', message
        messages[event] = mergeAllOf(message);
      }
    }
  }
  return desc;
};

isAllowedTypeless = function(name, parent) {
  if (parent.id === '/shared/port_definition' && name === 'default') {
    return true;
  }
  if (parent.id === '/runtime/input/packet' && name === 'payload') {
    return true;
  }
  if (parent.id === 'input/packet' && name === 'payload') {
    return true;
  }
  if (parent.id === '/runtime/output/packet' && name === 'payload') {
    return true;
  }
  if (parent.id === 'output/packet' && name === 'payload') {
    return true;
  }
  if (parent.id === 'output/packetsent' && name === 'payload') {
    return true;
  }
  return false;
};

renderProperty = function(name, def, parent) {
  var classes, description, example, isOptional, ref, ref1, ref2, ref3, ref4, ref5, type;
  if (!def.description) {
    throw new Error(`Property ${name} is missing .description`);
  }
  if (!isAllowedTypeless(name, parent)) {
    if (!def.type) {
      throw new Error(`Property ${name} is missing .type`);
    }
  }
  if (!parent) {
    throw new Error(`Parent schema not specified for ${name}`);
  }
  if (parent.type === 'array') {
    if (!((ref = parent.items) != null ? (ref1 = ref.required) != null ? ref1.length : void 0 : void 0)) {
      throw new Error(`.required array not specified for ${name} of ${parent.id} (array)`);
    }
  } else {
    if (((ref2 = parent.required) != null ? ref2.length : void 0) == null) {
      console.log(JSON.stringify(parent, null, 2));
      throw new Error(`.required array not specified for ${name} of ${parent.id}`);
    }
  }
  isOptional = (parent.type === 'array' && ((ref3 = parent.required) != null ? ref3.indexOf(name) : void 0) === -1) || ((ref4 = parent.items) != null ? (ref5 = ref4.required) != null ? ref5.indexOf(name) : void 0 : void 0) === -1;
  classes = "property";
  if (isOptional) {
    classes += " optional";
  }
  name = `<label class='${classes} name'>${name}</label>`;
  type = `<label class='${classes} type'>${def.type || 'any'}</label>`;
  description = `<label class='${classes} description'>${def.description}</label>`;
  example = "";
  if (def.example != null) {
    example = `<code class='${classes} example'>${JSON.stringify(def.example)}</code>`;
  }
  return name + type + description + example;
};

renderMessage = function(messageType, message, protocolName) {
  var anchorUrl, itemProp, itemPropName, itemSubProp, itemSubPropName, items, line, lines, messageId, messageProp, messagePropName, p, ref, ref1, ref2, ref3, subProp, subPropName;
  lines = [];
  p = function(line) {
    return lines.push(line);
  };
  messageId = `${protocolName}-${messageType}`;
  anchorUrl = '#' + messageId;
  p(`<h3 id='${messageId}' class='message name'><a href='${anchorUrl}'>${messageType}</a></h3>`);
  p(`<p>${message.description}</p>`);
  p("<ul class='message properties'>");
  ref = message.properties;
  for (messagePropName in ref) {
    messageProp = ref[messagePropName];
    line = `<li>${renderProperty(messagePropName, messageProp, message)}</li>`;
    items = messageProp.items;
    if (messageProp.type === 'object' && (messageProp.properties != null)) {
      p(line);
      p("<ul class='properties'>");
      ref1 = messageProp.properties;
      for (subPropName in ref1) {
        subProp = ref1[subPropName];
        p(`<li>${renderProperty(subPropName, subProp, messageProp)}</li>`);
      }
      p("</ul>");
    } else if ((items != null ? items.type : void 0) === 'object') {
      line += "Each item contains:";
      p(line);
      p("<ul class='properties'>");
      ref2 = items.properties;
      for (itemPropName in ref2) {
        itemProp = ref2[itemPropName];
        if (itemProp.type === 'object') {
          p(`<li>${renderProperty(itemPropName, itemProp, messageProp)}</li>`);
          p("<ul class='properties'>");
          ref3 = itemProp.properties;
          for (itemSubPropName in ref3) {
            itemSubProp = ref3[itemSubPropName];
            p(`<li>${renderProperty(itemSubPropName, itemSubProp, itemProp)}</li>`);
          }
          p("</ul>");
        } else {
          p(`<li>${renderProperty(itemPropName, itemProp, messageProp)}</li>`);
        }
      }
      p("</ul>");
    } else {
      p(line);
    }
  }
  p("</ul>");
  return lines;
};

renderCapabilities = function() {
  var enumDescription, i, j, k, len, len1, len2, lines, messageUrl, name, p, ref, ref1, ref2, schema, tv4;
  tv4 = require('../schema/index.js');
  schema = tv4.getSchema('/shared/capabilities');
  lines = [];
  p = function(line) {
    return lines.push(line);
  };
  p("<section class='capabilities'>");
  ref = schema.items._enumDescriptions;
  for (i = 0, len = ref.length; i < len; i++) {
    enumDescription = ref[i];
    p(`<h4 class='capability name'>${enumDescription.name}</h4>`);
    p(`<p>${enumDescription.description}</p>`);
    p("<h5 class='capability messages header'>input messages</h5>");
    p("<ul class='capability messages'>");
    ref1 = enumDescription.inputs;
    for (j = 0, len1 = ref1.length; j < len1; j++) {
      name = ref1[j];
      messageUrl = "#" + name.replace(':', '-');
      p(`<li><a href='${messageUrl}'>${name}</a></li>`);
    }
    p("</ul>");
    p("<h5 class='capability messages header'>output messages</h5>");
    p("<ul class='capability messages'>");
    ref2 = enumDescription.outputs;
    for (k = 0, len2 = ref2.length; k < len2; k++) {
      name = ref2[k];
      messageUrl = "#" + name.replace(':', '-');
      p(`<li><a href='${messageUrl}'>${name}</a></li>`);
    }
    p("</ul>");
  }
  p("</section>");
  return lines.join('\n');
};

renderMessages = function() {
  var descriptions, lines, m, message, messageType, p, protocol, protocolProps, ref;
  schemas = getSchemas();
  descriptions = getDescriptions(schemas);
  lines = [];
  p = function(line) {
    return lines.push(line);
  };
  for (protocol in descriptions) {
    protocolProps = descriptions[protocol];
    p(`<h2 class='protocol name'>${protocolProps.title}</h2>`);
    p(`<p class='protocol description'>${protocolProps.description}</p>`);
    ref = protocolProps.messages;
    for (messageType in ref) {
      message = ref[messageType];
      m = renderMessage(messageType, message, protocol);
      lines = lines.concat(m);
    }
  }
  return lines.join('\n');
};

module.exports = {
  renderMessages: renderMessages,
  renderCapabilities: renderCapabilities,
  getSchemas: getSchemas
};