[WIP] Rewriting Skip Logic

lib/linter.js

@@ -19,18 +19,22 @@ const ensureRule = (context, rule, shouldAssertion) => {
     }
 }
 
-let activeRules = {};
+let activeRules;
+let skipRules;
 
-const init = () => {
+const init = (params = {}) => {
     activeRules = {};
+    skipRules = params.skip || [];
 };
 
 const createNewRules = rules => {
     rules.forEach(rule => createNewRule(rule));
 };
 
 const createNewRule = rule => {
-    if (!rule.enabled) return;
+    if (rule.disabled === true) return;
+    // @DEPRECATED in v0.9.0, use `disabled: true`
+    if (rule.enabled === false) return;
     if (!Array.isArray(rule.object)) rule.object = [rule.object];
     if (rule.alphabetical && rule.alphabetical.properties && !Array.isArray(rule.alphabetical.properties)) {
         rule.alphabetical.properties = [rule.alphabetical.properties];
@@ -39,19 +43,8 @@ const createNewRule = rule => {
     activeRules[rule.name] = rule;
 }
 
-const relevantRules = (skipRulesObject) => {
-    const rules = Object.values(activeRules);
-    const skipRules = Object.values(skipRulesObject || {});
-
-    if (skipRules.length === 0) return rules;
-
-    return rules.filter(rule => skipRules.indexOf(rule.name) === -1);
-}
-
 const lint = (objectName, object, key, options = {}) => {
-    const { skip } = options;
-
-    const rules = relevantRules(skip);
+    const rules = relevantRules(Object.values(activeRules), skipRules);
     const results = [];
 
     const ensure = (rule, func) => {
@@ -213,6 +206,12 @@ const lint = (objectName, object, key, options = {}) => {
     return results;
 }
 
+const relevantRules = (rulesList, skipList) => {
+    console.log({skipList, skipRules})
+    if (skipList.length === 0) return rulesList;
+    return rulesList.filter(rule => skipList.indexOf(rule.name) === -1);
+}
+
 module.exports = {
     createNewRule,
     createNewRules,

lib/loader.js

@@ -36,11 +36,7 @@ const fetchUrl = async (url) => {
     }
 
     if (response.ok) {
-        try {
-            return await response.json();
-        } catch (error) {
-            throw new ReadError('Invalid JSON: ' + error.message);
-        }
+        return await response.text();
     }
     if (response.status === 404) {
         throw new OpenError('Page not found: ' + url);
@@ -85,39 +81,43 @@ const readOrError = async (file, options = {}) => {
     }
 }
 
-const recursivelyLoadRuleFiles = async (file, loadedFiles, options) => {
+const recursivelyLoadRulesets = async (ruleset, loadedRulesets, options) => {
     const { verbose } = options;
 
-    let data;
-    if (file && file.startsWith('http')) {
-        if (verbose > 1) console.log('GET ' + file);
-        data = await fetchUrl(file);
+    let text;
+    // If the ruleset looks like a HTTP URL
+    if (ruleset && ruleset.startsWith('http')) {
+        if (verbose > 1) console.log('GET ' + ruleset);
+        text = await fetchUrl(ruleset);
     }
-    else if (fs.existsSync(file)) {
-        if (verbose > 1) console.log('READ ' + file);
-        data = yaml.safeLoad(fs.readFileSync(file, 'utf8'));
+    else if (fs.existsSync(ruleset)) {
+        if (verbose > 1) console.log('READ ' + ruleset);
+        text = fs.readFileSync(ruleset, 'utf8');
     }
     else {
-        const ruleFile = path.join(__dirname, '../rules/' + file + '.json');
-        if (verbose > 1) console.log('READ ' + ruleFile);
-        data = yaml.safeLoad(fs.readFileSync(ruleFile, 'utf8'));
+        const rulesetFile = path.join(__dirname, '../rules/' + ruleset + '.yaml');
+        if (verbose > 1) console.log('READ ' + rulesetFile);
+        text = fs.readFileSync(rulesetFile, 'utf8');
     }
 
-    loadedFiles.push(file);
+    const data = yaml.safeLoad(text);
+
+    loadedRulesets.push(ruleset);
 
     if (typeof data.require == 'string') {
-        const requiredLoadedFiles = await recursivelyLoadRuleFiles(data.require, loadedFiles, options);
-        loadedFiles = loadedFiles.concat(requiredLoadedFiles);
+        const requiredLoadedFiles = await recursivelyLoadRulesets(data.require, loadedRulesets, options);
+        loadedRulesets = loadedRulesets.concat(requiredLoadedFiles);
     }
 
-    if (verbose > 1) {
-        console.log(`Found ${data.rules.length} rules in ${file}: ${data.rules.map(x => x.name)}`);
+    if (data.rules) {
+        if (verbose > 1) {
+            console.log(`Found ${data.rules.length} rules in ${ruleset}: ${data.rules.map(x => x.name)}`);
+        }
+        // Tell the linter about these new rules
+        linter.createNewRules(data.rules);
     }
 
-    // Tell the linter about these new rules
-    linter.createNewRules(data.rules);
-
-    return loadedFiles;
+    return loadedRulesets;
 }
 
 async function asyncMap(array, callback) {
@@ -128,13 +128,13 @@ async function asyncMap(array, callback) {
     return Promise.all(promises);
 }
 
-const loadRuleFiles = async (loadFiles, options = {}) => {
+const loadRulesets = async (loadFiles, options = {}) => {
     const { verbose } = options;
-    const files = (loadFiles.length > 0 ? loadFiles : ['default']);
-    const result = await asyncMap(files, file => recursivelyLoadRuleFiles(file, [], { verbose }));
-    const flatten = [].concat(...result);
+    const rulesetList = (loadFiles.length > 0 ? loadFiles : ['default']);
+    const allDependancies = await asyncMap(rulesetList, ruleset => recursivelyLoadRulesets(ruleset, [], { verbose }));
+    const flatDependencies = [].concat(...allDependancies);
     // Unique copy of the array
-    return [...(new Set(flatten))];
+    return [...(new Set(flatDependencies))];
 }
 
 const resolveContent = (openapi, options) => {
@@ -172,7 +172,7 @@ const loadSpec = async (source, options = {}) => {
 }
 
 module.exports = {
-    loadRuleFiles,
+    loadRulesets,
     loadSpec,
     readOrError,
     NetworkError,

lint.js

@@ -68,18 +68,18 @@ const command = async (specFile, cmd) => {
     config.init(cmd);
     const jsonSchema = config.get('jsonSchema');
     const verbose = config.get('quiet') ? 0 : (config.get('verbose') ? 2 : 1);
-    const rulesFiles = config.get('lint:rules');
+    const rulesets = config.get('lint:rules');
     const skip = config.get('lint:skip');
 
-    linter.init();
-    await loader.loadRuleFiles(rulesFiles, { verbose });
+    linter.init({ skip });
+    await loader.loadRulesets(rulesets, { verbose });
 
     const spec = await loader.readOrError(
         specFile,
         buildLoaderOptions(jsonSchema, verbose),
     );
 
-    validator.validate(spec, buildValidatorOptions(skip, verbose), (err, _options) => {
+    validator.validate(spec, buildValidatorOptions(verbose), (err, _options) => {
         const { context, lintResults } = _options;
 
         if (err) {