Timo Kissing tkissing

A global npm command serve-it that takes a "virtual url path" with an optional port and an optional path (defaulting to cwd). The command starts up an http server (optionally: https) and adds the required configuration to serve the files in that folder (recursively). If the server is already running, it just reconfigures the server at runtime.

Examples:

serve-it foo:8081 // serves current working directory at http://localhost:8081/foo
serve-it --save bar ./bar/src // serves ./bar/src at http://localhost:$PORT/bar with $PORT being default port from ~/.serve-it/config.json or 8080 if not configured; persists to ~/.serve-it/config.json

An optional --save adds the configuration to ~/.serve-it/config.json Anytime the runtime configuration changes, it is also written to ~/.serve-it/.runtime.json - allowing to restore the last configuration after a crash using a command like serve-it --restore

	function startInterval(func, freq) {
	var id = setInterval(func, freq);
	return function() {
	if (id) {
	clearInterval(id);
	id = null;
	return true;
	}
	return false;
	}

	// using AMD syntax here to avoid confusion about scope and file boundaries,
	// but the concept translates 1:1 to CommonJS (node/io) modules

	define('badSingleton', function(require, exports, module) {
	var dependency = require('dependency');

	var privateState;

	module.exports = {
	foo: function() {

	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="utf-8">
	<title>Hello World</title>
	</head>
	<body>
	Hello World
	</body>
	</html>

	function A() {
	function privateA() {}
	function privateB() {}

	function publicA() {
	// now this.publicB() here, just publicB() - safes typing and even if someone overrides publicB we still use the implementation from here
	// of course that latter might not be desired, in which case you'd write this.publicB() here
	return publicB() ? privateA() : privateB();
	}
	this.publicA = publicA;

	// consider the following code

	function getInfoDef() {
	var result = {something: 'static'};
	var def = $.Deferred();

	$.ajax('/some-url').then(function(data) {
	result.also = data.dynamic;
	def.resolve(result);
	}).fail(def.reject.bind(def));

	// Problem:
	// - We have 2 operations that can and should run in parallel
	// - Both operations may finish in arbitrary order
	// - one operation is mandatory, the other is optional
	// - the result promise is to be resolved with a merge of the intermediate ones, with optional overriding mandatory
	// Question:
	// Can this be done
	// - in a more readable manner than the "result = new Promise..." code block
	// - with less code than the "result = new Promise..." code block

	function ithrow() {
	throw Error("Can't do that");
	}

	p1 = new Promise(function(resolve) {
	resolve(ithrow())
	});

	p1.then(console.log.bind(console, 'p1'), console.warn.bind(console, 'p1'));

	nslookup rtcgw.citrixonline.com
	tracert rtcgw.citrixonline.com

	/jslint browser:true, eqeq:true, forin:true, sloppy: true/
	(function (window, document) {
	var differences = {},
	exceptions = ['addEventListener', 'document', 'location', 'navigator', 'window'],
	globals = [],
	ignoreList = (window.prompt('Ignore filter (comma sep)?', '$,jQuery,ko') \|\| '').split(','),
	iframe = document.createElement('iframe'),
	i;

	for (i in window) {