feat: support for stdin and piping

lib/loader.js

@@ -6,6 +6,7 @@ const path = require('path');
 const rules = require('./rules.js');
 const resolver = require('oas-resolver');
 const yaml = require('js-yaml');
+const readline = require('readline');
 
 class ExtendableError extends Error {
     constructor(message) {
@@ -27,6 +28,21 @@ function readFileAsync(filename, encoding) {
     });
 }
 
+function readFileStdinAsync() {
+    return new Promise((resolve, reject) => {
+        const rl = readline.createInterface({
+            input: process.stdin
+        });
+        let lines = [];
+        rl.on('line', (line) => {
+            lines.push(line);
+        });
+        rl.on('close', () => {
+            resolve(lines.join('\n'));
+        });
+    });
+}
+
 const fetchUrl = async (url) => {
     let response;
     try {
@@ -45,18 +61,24 @@ const fetchUrl = async (url) => {
 };
 
 
+// file can be null, meaning stdin
 function readSpecFile(file, options) {
     if (options.verbose > 1) {
-        console.log('GET ' + file);
+        file ? console.error('GET ' + file) : console.error('GET <stdin>');
     }
-    if (file && file.startsWith('http')) {
+    if (!file) {
+        // standard input
+        return readFileStdinAsync();
+    } else if (file && file.startsWith('http')) {
+        // remote file
         return fetch(file).then(res => {
             if (res.status !== 200) {
                 throw new Error(`Received status code ${res.status}`);
             }
             return res.text();
         })
     } else {
+        // local file
         // TODO error handlers?
         return readFileAsync(file, 'utf8');
     }
@@ -83,16 +105,16 @@ const recursivelyLoadRulesets = async (ruleset, loadedRulesets, options) => {
     let text;
     // If the ruleset looks like a HTTP URL
     if (ruleset && ruleset.startsWith('http')) {
-        if (verbose > 1) console.log('GET ' + ruleset);
+        if (verbose > 1) console.error('GET ' + ruleset);
         text = await fetchUrl(ruleset);
     }
     else if (fs.existsSync(ruleset)) {
-        if (verbose > 1) console.log('READ ' + ruleset);
+        if (verbose > 1) console.error('READ ' + ruleset);
         text = fs.readFileSync(ruleset, 'utf8');
     }
     else {
         const rulesetFile = path.join(__dirname, '../rules/' + ruleset + '.yaml');
-        if (verbose > 1) console.log('READ ' + rulesetFile);
+        if (verbose > 1) console.error('READ ' + rulesetFile);
         text = fs.readFileSync(rulesetFile, 'utf8');
     }
 

package.json

@@ -51,6 +51,7 @@
     "babel-preset-es2015": "^6.24.1",
     "coveralls": "^3.0.0",
     "jest": "^24.1.0",
+    "mock-stdin": "^0.3.1",
     "nock": "^10.0.0"
   }
 }

resolve.js

@@ -21,19 +21,20 @@ const command = async (file, cmd) => {
     return new Promise((resolve, reject) => {
         if (output) {
             fs.writeFile(output, content, 'utf8', err => {
-                if (err && verbose) {
-                    console.error('Failed to write file: ' + err.message);
-                    return reject();
+                if (err) {
+                    if (verbose) console.error('Failed to write file: ' + err.message);
+                    reject();
+                } else {
+                    if (verbose) console.error('Resolved to ' + output);
+                    resolve();
                 }
-
-                if (verbose) console.log('Resolved to ' + output);
             });
-
-            return resolve();
+        } else {
+            process.stdout.write(content, () => {
+                // Do not exit until the output is flushed (e.g. pipes)
+                resolve();
+            });
         }
-
-        console.log(content);
-        return resolve();
     });
 };
 

speccy.js

@@ -26,8 +26,8 @@ program
     .option('-c, --config [configFile]', 'config file (containing JSON/YAML). See README for potential values.');
 
 program
-    .command('lint <file-or-url>')
-    .description('ensure specs are not just valid OpenAPI, but lint against specified rules')
+    .command('lint [file-or-url]')
+    .description('ensure specs are not just valid OpenAPI, but lint against specified rules. If no argument is passed, then standard input will be used (please note that in this case the provided spec must be fully resolved)')
     .option('-q, --quiet', 'reduce verbosity')
     .option('-r, --rules [ruleFile]', 'provide multiple rules files', collect, [])
     .option('-s, --skip [ruleName]', 'provide multiple rules to skip', collect, [])

test/integration/lint.test.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const fs = require('fs');
+const mockStdin = require('mock-stdin');
 const lint = require('../../lint.js');
 
 const commandConfig = {
@@ -9,7 +11,7 @@ const commandConfig = {
 };
 
 beforeEach(() => {
-    jest.resetAllMocks();
+    jest.restoreAllMocks();
 });
 
 describe('Lint command', () => {
@@ -73,4 +75,74 @@ describe('Lint command', () => {
             });
         });
     });
+
+    describe('properly support stdin and pipes', () => {
+        let stdin = null;
+
+        beforeEach(() => {
+            stdin = mockStdin.stdin();
+        });
+
+        afterEach(() => {
+            stdin.restore();
+        });
+
+        test('expect errors on lint of empty input', () => {
+            process.nextTick(function mockResponse() {
+                stdin.end();
+            });
+
+            expect.assertions(4);
+            const logSpy = jest.spyOn(console, 'log');
+            const warnSpy = jest.spyOn(console, 'warn');
+            const errorSpy = jest.spyOn(console, 'error');
+
+            // pass null as spec, it will be read from stdin
+            return lint.command(null, commandConfig).catch(() => {
+                expect(logSpy).toBeCalledTimes(0);
+                expect(warnSpy).toBeCalledTimes(0);
+                expect(errorSpy).toBeCalledTimes(2);
+                expect(errorSpy).toHaveBeenCalledWith('\x1b[31mSpecification schema is invalid.\x1b[0m');
+            });
+        });
+
+        test('expect errors on lint of invalid input', () => {
+            const spec = fs.readFileSync('./test/fixtures/integration/invalid-key.yaml', 'utf8');
+            process.nextTick(function mockResponse() {
+                stdin.send(spec, 'utf8').end();
+            });
+
+            expect.assertions(4);
+            const logSpy = jest.spyOn(console, 'log');
+            const warnSpy = jest.spyOn(console, 'warn');
+            const errorSpy = jest.spyOn(console, 'error');
+
+            return lint.command('./test/fixtures/integration/invalid-key.yaml', commandConfig).catch(() => {
+                expect(logSpy).toBeCalledTimes(0);
+                expect(warnSpy).toBeCalledTimes(0);
+                expect(errorSpy).toBeCalledTimes(2);
+                expect(errorSpy).toHaveBeenCalledWith('\x1b[31mSpecification schema is invalid.\x1b[0m');
+            });
+        });
+
+        test('expect no errors on lint of valid input', () => {
+            const spec = fs.readFileSync('./test/fixtures/loader/openapi.yaml', 'utf8');
+            process.nextTick(function mockResponse() {
+                stdin.send(spec, 'utf8').end();
+            });
+
+            expect.assertions(4);
+            const logSpy = jest.spyOn(console, 'log');
+            const warnSpy = jest.spyOn(console, 'warn');
+            const errorSpy = jest.spyOn(console, 'error');
+
+            // pass null as spec, it will be read from stdin
+            return lint.command(null, commandConfig).then(() => {
+                expect(logSpy).toBeCalledTimes(1);
+                expect(logSpy.mock.calls[0][0]).toEqual('\x1b[32mSpecification is valid, with 0 lint errors\x1b[0m');
+                expect(warnSpy).toBeCalledTimes(0);
+                expect(errorSpy).toBeCalledTimes(0);
+            });
+        });
+    });
 });