All files / src/spectral/utils spectral-validator.js

98.21% Statements 55/56
83.33% Branches 20/24
100% Functions 5/5
98.21% Lines 55/56

Press n or j to go to the next uncovered block, b, p or k for the previous block.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 12828x 28x 28x 28x 28x 28x 28x     28x   28x 92x   92x 92x 1084x 1084x 1084x 1084x 1084x   1084x     216x     868x 867x   134x 733x   725x 8x   6x 2x   2x     1x 1x                 92x       28x 92x   1x 1x       91x           91x 91x 91x     91x 91x     91x       91x 91x 91x                   91x   91x     91x 91x 546x       546x 546x               91x 91x           28x        
const MessageCarrier = require('../../plugins/utils/messageCarrier');
const config = require('../../cli-validator/utils/processConfiguration');
const { Spectral } = require('@stoplight/spectral');
const { isOpenApiv2, isOpenApiv3 } = require('@stoplight/spectral');
const { mergeRules } = require('@stoplight/spectral/dist/rulesets');
const fs = require('fs');
const path = require('path');
// default spectral ruleset file
const defaultSpectralRulesetURI =
  __dirname + '/../rulesets/.defaultsForSpectral.yaml';
 
const parseResults = function(results, debug) {
  const messages = new MessageCarrier();
 
  Eif (results) {
    for (const validationResult of results) {
      Eif (validationResult) {
        const code = validationResult['code'];
        const severity = validationResult['severity'];
        const message = validationResult['message'];
        const path = validationResult['path'];
 
        if (code === 'parser') {
          // Spectral doesn't allow disabling parser rules, so don't include them
          // in the output (for now)
          continue;
        }
 
        if (typeof severity === 'number' && code && message && path) {
          if (severity === 0) {
            // error
            messages.addMessage(path, message, 'error', code);
          } else if (severity === 1) {
            // warning
            messages.addMessage(path, message, 'warning', code);
          } else if (severity === 2) {
            // info
            messages.addMessage(path, message, 'info', code);
          } else Eif (severity === 3) {
            // hint
            messages.addMessage(path, message, 'hint', code);
          }
        } else {
          Eif (debug) {
            console.log(
              'There was an error while parsing the spectral results: ',
              JSON.stringify(validationResult)
            );
          }
        }
      }
    }
  }
  return messages;
};
 
// setup: registers the oas2/oas3 formats, and attempts to load the ruleset file
const setup = async function(spectral, rulesetFileOverride, configObject) {
  if (!spectral) {
    const message =
      'Error (spectral-validator): An instance of spectral has not been initialized.';
    return Promise.reject(message);
  }
 
  // load the spectral ruleset, either a user's or the default ruleset
  const spectralRulesetURI = await config.getSpectralRuleset(
    rulesetFileOverride,
    defaultSpectralRulesetURI
  );
 
  // Add IBM default ruleset to static assets to allow extends to reference it
  const staticAssets = require('@stoplight/spectral/rulesets/assets/assets.json');
  setupStaticAssets(staticAssets, defaultSpectralRulesetURI);
  Spectral.registerStaticAssets(staticAssets);
 
  // Register formats
  spectral.registerFormat('oas2', isOpenApiv2);
  spectral.registerFormat('oas3', isOpenApiv3);
 
  // Load either the user-defined ruleset or our default ruleset
  await spectral.loadRuleset(spectralRulesetURI);
 
  // Combine default/user ruleset with the validaterc spectral rules
  // The validaterc rules will take precendence in the case of duplicate rules
  const userRules = Object.assign({}, spectral.rules); // Clone rules
  try {
    return await spectral.setRules(
      mergeRules(userRules, configObject.spectral.rules)
    );
  } catch (err) {
    return Promise.reject(err);
  }
};
 
function setupStaticAssets(staticAssets, defaultSpectralRulesetURI) {
  // register ruleset
  staticAssets['ibm:oas'] = addDataToSpectralConfig(defaultSpectralRulesetURI);
 
  const parentDirectory = path.parse(defaultSpectralRulesetURI).dir;
 
  // register custom functions
  const customFunctionsDirURI = path.join(parentDirectory, 'ibm-oas');
  fs.readdirSync(customFunctionsDirURI).forEach(function(customFunctionFile) {
    const customFunctionURI = path.join(
      customFunctionsDirURI,
      customFunctionFile
    );
    const customFunctionRelativeURI = path.join('ibm-oas', customFunctionFile);
    staticAssets[customFunctionRelativeURI] = fs.readFileSync(
      customFunctionURI,
      'utf8'
    );
  });
}
 
function addDataToSpectralConfig(defaultSpectralRulesetURI) {
  const content = fs.readFileSync(defaultSpectralRulesetURI, 'utf8');
  return content.replace(
    '\\./schemas',
    path.join(__dirname, '../rulesets/schemas')
  );
}
 
module.exports = {
  parseResults,
  setup
};