Works with standard input.

Author: zachleat

README.md

@@ -55,9 +55,6 @@ glyphhanger ./test.html --json
 # show results only for one or more font-family names
 glyphhanger ./test.html --family='Open Sans, Roboto'
 
-# use much faster jsdom mode instead of headless Chrome
-glyphhanger ./test.html --jsdom
-
 # Show version
 glyphhanger --version
 
@@ -212,14 +209,22 @@ Limit results to text inside of elements that match a CSS selector
 glyphhanger ./test.html --cssSelector="pre, #header, .popUp". If paired with `--onlyVisible`, it will only return elements that are both visible and match the selector
 ```
 
-### Advanced: use `jsdom` Mode ⚠️
+### Advanced: `jsdom` Mode ⚠️
 
 JSDOM mode can be useful running against static pages that don’t use a lot of JavaScript generated content. While JSDOM mode can handle some JavaScript generated content, Puppeteer mode should be the safest method for most use cases.
 
 JSDOM mode will also be much faster when running against files on a local filesystem rather than URL targets.
 
 Read more about [the difference between JSDOM and a full headless browser](https://github.com/jsdom/jsdom/wiki/jsdom-vs.-PhantomJS) (like the default mode that glyphhanger uses: Puppeteer/headless Chrome).
 
+```sh
+# use faster jsdom mode instead of headless Chrome
+glyphhanger ./test.html --jsdom
+
+# jsdom mode works with standard input too
+echo "this is a test" | glyphhanger ./test.html --jsdom
+```
+
 ## Troubleshooting
 
 * `glyphhanger` uses Puppeteer, the headless Chrome browser. Check out the [Puppeteer Troubleshooting documentation](https://github.com/GoogleChrome/puppeteer/blob/master/docs/troubleshooting.md#chrome-headless-doesnt-launch).

cmd.js

@@ -1,10 +1,12 @@
 #!/usr/bin/env node
-var argv = require( "minimist" )( process.argv.slice(2) );
-var GlyphHanger = require( "./src/GlyphHanger" );
-var GlyphHangerWhitelist = require( "./src/GlyphHangerWhitelist" );
-var GlyphHangerSubset = require( "./src/GlyphHangerSubset" );
-var GlyphHangerFontFace = require( "./src/GlyphHangerFontFace" );
-var MultipleSpiderPigs = require( "./src/MultipleUrlSpiderPig" );
+const argv = require( "minimist" )( process.argv.slice(2) );
+const chalk = require("chalk");
+const getStdin = require("get-stdin");
+const GlyphHanger = require( "./src/GlyphHanger" );
+const GlyphHangerWhitelist = require( "./src/GlyphHangerWhitelist" );
+const GlyphHangerSubset = require( "./src/GlyphHangerSubset" );
+const GlyphHangerFontFace = require( "./src/GlyphHangerFontFace" );
+const MultipleSpiderPigs = require( "./src/MultipleUrlSpiderPig" );
 const debug = require( "debug" )( "glyphhanger:cli" );
 
 var whitelist = new GlyphHangerWhitelist( argv.w || argv.whitelist, {
@@ -68,34 +70,42 @@ if( argv.subset ) {
 // glyphhanger --subset=*.ttf --family='My Serif' -css			(subset group of fonts to results for specific family and a font-face block)
 // glyphhanger --subset=*.ttf --output=dist/								(change the output directory for subset files)
 
-if( argv.version ) {
-	var pkg = require( "./package.json" );
-	console.log( pkg.version );
-} else if( argv.help ) {
-	gh.outputHelp();
-} else if( argv._ && argv._.length ) {
-	(async function() {
-		// Spider
-		if( argv.spider || argv[ 'spider-limit' ] || argv[ 'spider-limit' ] === 0 ) {
-			let sp = new MultipleSpiderPigs();
-			sp.setLimit(argv[ 'spider-limit' ]);
-			await sp.fetchUrls(argv._);
-
-			let urls = sp.getUrlsWithLimit();
-			await sp.finish();
-			debug( "Urls (after limit): %o", urls );
+(async function() {
+	let standardInput = (await getStdin()).trim();
+	gh.setStandardInput(standardInput);
 
-			await gh.fetchUrls( urls );
-		} else {
-			await gh.fetchUrls( argv._ );
+	if( argv.version ) {
+		var pkg = require( "./package.json" );
+		console.log( pkg.version );
+	} else if( argv.help ) {
+		gh.outputHelp();
+	} else if( argv._ && argv._.length || standardInput ) {
+		// Spider
+		try {
+			if( argv.spider || argv[ 'spider-limit' ] || argv[ 'spider-limit' ] === 0 ) {
+				let sp = new MultipleSpiderPigs();
+				sp.setLimit(argv[ 'spider-limit' ]);
+				await sp.fetchUrls( argv._ );
+
+				let urls = sp.getUrlsWithLimit();
+				await sp.finish();
+				debug( "Urls (after limit): %o", urls );
+
+				await gh.fetchUrls( urls );
+			} else {
+				await gh.fetchUrls( argv._ );
+			}
+		} catch(e) {
+			console.log(chalk.red("GlyphHanger Fetch Error: "), e);
+			process.exitCode = 1;
 		}
 
 		gh.output();
 		try {
 			fontface.setUnicodeRange( gh.getUnicodeRange() );
 			fontface.writeCSSFiles();
 		} catch(e) {
-			console.log("GlyphHangerFontFace Error: ", e);
+			console.log(chalk.red("GlyphHangerFontFace Error: "), e);
 			process.exitCode = 1;
 		}
 
@@ -104,53 +114,53 @@ if( argv.version ) {
 				subset.subsetAll( gh.getUnicodeRange() );
 			}
 		} catch(e) {
-			console.log("GlyphHangerSubset Error: ", e);
+			console.log(chalk.red("GlyphHangerSubset Error: "), e);
 			process.exitCode = 1;
 		}
 
 		try {
 			fontface.output();
 		} catch(e) {
-			console.log("GlyphHangerFontFace Error: ", e);
+			console.log(chalk.red("GlyphHangerFontFace Error: "), e);
 			process.exitCode = 1;
 		}
-	})();
-} else { // not using URLs
-	if( argv.subset ) {
-		gh.output();
+	} else { // not using URLs
+		if( argv.subset ) {
+			gh.output();
+
+			try {
+				// --subset with or without --whitelist
+				subset.subsetAll( !whitelist.isEmpty() ? whitelist.getWhitelistAsUnicodes() : whitelist.getUniversalRangeAsUnicodes() );
+			} catch(e) {
+				process.exitCode = 1;
+				console.log(chalk.red("GlyphHangerSubset Error: "), e);
+			}
 
-		try {
-			// --subset with or without --whitelist
-			subset.subsetAll( !whitelist.isEmpty() ? whitelist.getWhitelistAsUnicodes() : whitelist.getUniversalRangeAsUnicodes() );
-		} catch(e) {
-			process.exitCode = 1;
-			console.log("GlyphHangerSubset Error: ", e);
-		}
+			try {
+				if(!whitelist.isEmpty()) {
+					fontface.setUnicodeRange( whitelist.getWhitelistAsUnicodes());
+				}
+				fontface.writeCSSFiles();
+				fontface.output();
+			} catch(e) {
+				process.exitCode = 1;
+				console.log(chalk.red("GlyphHangerFontFace Error: "), e);
+			}
+		} else if( !whitelist.isEmpty() ) {
+			// not subsetting, just output the code points (can convert whitelist string to code points)
+			gh.outputUnicodes();
 
-		try {
-			if(!whitelist.isEmpty()) {
+			try {
 				fontface.setUnicodeRange( whitelist.getWhitelistAsUnicodes());
+				fontface.writeCSSFiles();
+				fontface.output();
+			} catch(e) {
+				process.exitCode = 1;
+				console.log(chalk.red("GlyphHangerFontFace Error: "), e);
 			}
-			fontface.writeCSSFiles();
-			fontface.output();
-		} catch(e) {
-			process.exitCode = 1;
-			console.log("GlyphHangerFontFace Error: ", e);
+		} else {
+			gh.outputHelp();
 		}
-	} else if( !whitelist.isEmpty() ) {
-		// not subsetting, just output the code points (can convert whitelist string to code points)
-		gh.outputUnicodes();
 
-		try {
-			fontface.setUnicodeRange( whitelist.getWhitelistAsUnicodes());
-			fontface.writeCSSFiles();
-			fontface.output();
-		} catch(e) {
-			process.exitCode = 1;
-			console.log("GlyphHangerFontFace Error: ", e);
-		}
-	} else {
-		gh.outputHelp();
 	}
-
-}
+})();

package.json

@@ -31,6 +31,7 @@
     "debug": "^3.1.0",
     "filesize": "^3.5.11",
     "fs-extra": "^5.0.0",
+    "get-stdin": "^6.0.0",
     "glob": "^7.1.2",
     "minimist": "^1.2.0",
     "parse-filepath": "^1.0.2",

src/GlyphHanger.js

@@ -115,11 +115,15 @@ class GlyphHanger {
 		};
 	}
 
+	setStandardInput(standardInput) {
+		this.standardInput = standardInput;
+		this.env.setStandardInput(this.standardInput);
+	}
+
 	async _fetchUrl( url ) {
 		debug( "requesting: %o", url );
 
 		let page = await this.env.getPage(url);
-
 		if(!page) {
 			return false;
 		}
@@ -132,23 +136,34 @@ class GlyphHanger {
 
 	async fetchUrls( urls ) {
 		let failCount = 0;
-		for( let url of urls ) {
-			debug("WebServer.isValidUrl(%o)", url);
-
-			let urlStr = url;
-			if(this.env.requiresWebServer()) {
-				if(!WebServer.isValidUrl(url) || url.indexOf('http://localhost:') === 0 ) {
-					if( !this.staticServer ) {
-						debug("Creating static server");
-						this.staticServer = await WebServer.getStaticServer();
+		if( !urls.length && this.standardInput ) {
+			if( !this.env.isJSDOM() ) {
+				throw new Error("Standard input mode requires using --jsdom");
+			}
+			let result = await this._fetchUrl();
+			if( result === false ) {
+				failCount++;
+			}
+		} else {
+			for( let url of urls ) {
+				debug("WebServer.isValidUrl(%o)", url);
+
+				let urlStr = url;
+				if(this.env.requiresWebServer()) {
+					if(!WebServer.isValidUrl(url) || url.indexOf('http://localhost:') === 0 ) {
+						if( !this.staticServer ) {
+							debug("Creating static server");
+							this.staticServer = await WebServer.getStaticServer();
+						}
 					}
-				}
 
-				urlStr = WebServer.getUrl(url);
-			}
+					urlStr = WebServer.getUrl(url);
+				}
 
-			if( (await this._fetchUrl(urlStr)) === false ) {
-				failCount++;
+				let result = await this._fetchUrl(urlStr);
+				if( result === false ) {
+					failCount++;
+				}
 			}
 		}
 

src/GlyphHangerEnvironment.js

@@ -4,6 +4,7 @@ const fs = require( "fs-extra" );
 const jsdom = require("jsdom");
 const { JSDOM } = jsdom;
 const puppeteer = require("puppeteer");
+const getStdin = require('get-stdin');
 const WebServer = require("./WebServer");
 const debugNodes = require("debug")("glyphhanger:nodes");
 
@@ -28,17 +29,32 @@ class JSDOMEnvironment {
 		return false;
 	}
 
-	async getPage(url) {
-		let isValidUrl = WebServer.isValidUrl(url);
-		let method = isValidUrl ? "fromURL" : "fromFile";
+	async getPage(url, standardInput) {
 		let options = {
 			runScripts: "dangerously",
 			// do we want to load subresources? leaving off for now
-			// resources: "usable"
-		};
-		if( !isValidUrl ) {
+			// resources: "usable",
+
 			// https://github.com/jsdom/jsdom/issues/2304
-			options.url = "http://localhost/";
+			url: "http://localhost/"
+		};
+
+		if( standardInput ) {
+			if( url ) {
+				console.log( chalk.yellow("A URL argument was passed but it was ignored. Using stdin instead.") );
+			}
+			if(standardInput.charAt(0) !== "<") {
+				standardInput = `<!doctype html><html><title></title><body>${standardInput}</body></html>`;
+			}
+
+			return new JSDOM(standardInput, options);
+		}
+
+		let isValidUrl = WebServer.isValidUrl(url);
+		let method = isValidUrl ? "fromURL" : "fromFile";
+		if( isValidUrl ) {
+			// see https://github.com/jsdom/jsdom/issues/2304 above
+			delete options.url;
 		}
 
 		let domPromise = JSDOM[method](url, options);
@@ -177,12 +193,20 @@ class GlyphHangerEnvironment {
 		return this._env;
 	}
 
+	isJSDOM() {
+		return this.envStr === "jsdom";
+	}
+
+	setStandardInput(value) {
+		this.standardInput = value;
+	}
+
 	requiresWebServer() {
 		return this.env.requiresWebServer();
 	}
 
 	async getPage(url) {
-		return this.env.getPage(url);
+		return this.env.getPage(url, this.standardInput);
 	}
 
 	async getResults(page, options) {

test/cmdTest.js

@@ -268,4 +268,22 @@ describe( "CLI (css)", function() {
 
 		assert.equal( output.toString().trim(), "U+20,U+61,U+63,U+65,U+67-69,U+6D-70,U+73,U+74" );
 	});
+
+	it( "System input and --jsdom", function () {
+		this.timeout( 10000 );
+		let output = childProcess.execSync(`echo "<b>ih</b>" | node cmd.js --jsdom --string`, {
+			cwd: path.resolve(__dirname, "..")
+		});
+
+		assert.equal( output.toString().trim(), "hi" );
+	});
+
+	it( "System input and --jsdom (not HTML, gets transformed to HTML for JSDOM)", function () {
+		this.timeout( 10000 );
+		let output = childProcess.execSync(`echo "ih" | node cmd.js --jsdom --string`, {
+			cwd: path.resolve(__dirname, "..")
+		});
+
+		assert.equal( output.toString().trim(), "hi" );
+	});
 });