diff --git a/.gitignore b/.gitignore index dc571b7..c4334ab 100644 --- a/.gitignore +++ b/.gitignore @@ -1,6 +1,5 @@ private-key.pem server-cert.pem -MarketplaceChat.app.zip -MarketplaceChat.app/ scratch/ _site/ +node_modules/ diff --git a/Makefile b/Makefile index 61d0efe..ae2f5ce 100644 --- a/Makefile +++ b/Makefile @@ -1,21 +1,8 @@ -APP_NAME=MarketplaceChat.app -LIB_SOURCES=\ - route.js \ - marketplace.js \ - spy.js \ - dom-driver.js \ - jquery-driver.js \ - routing-table-widget.js \ - routing-table-widget.css \ - wake-detector.js \ - websocket-driver.js -APP_SOURCES=\ - examples/chat/index.html \ - examples/chat/index.js \ - examples/chat/style.css -RESOURCES=$(wildcard examples/chat/app-resources/*) +all: + npm run build -all: $(APP_NAME).zip +deps: + npm install . keys: private-key.pem server-cert.pem @@ -31,23 +18,3 @@ server-cert.pem: private-key.pem clean-keys: rm -f private-key.pem server-cert.pem - -$(APP_NAME).zip: $(APP_NAME) - zip -r $@ $< - -$(APP_NAME): $(APP_SOURCES) $(LIB_SOURCES) - echo RESOURCES $(RESOURCES) - rm -rf $@ - mkdir -p $@/Contents/MacOS - mkdir -p $@/Contents/Resources - cp examples/chat/app-resources/Info.plist $@/Contents - cp examples/chat/app-resources/boot.sh $@/Contents/MacOS - cp examples/chat/app-resources/app.icns $@/Contents/Resources - cp -r third-party $@/Contents/Resources - cp $(LIB_SOURCES) $@/Contents/Resources - mkdir -p $@/Contents/Resources/examples/chat - cp $(APP_SOURCES) $@/Contents/Resources/examples/chat - chmod a+x $@/Contents/MacOS/boot.sh - -clean: - rm -rf $(APP_NAME) $(APP_NAME).zip diff --git a/README.md b/README.md index 7b63978..8c3933f 100644 --- a/README.md +++ b/README.md @@ -14,7 +14,7 @@ To install the Racket server: To run the Racket server: - - `racket server.rkt` from the base directory of this repository. + racket -l minimart/examples/broker The Racket server listens for tunnelled Network Calculus events via websocket on ports 8000 (HTTP) and 8443 (HTTPS, if you have a diff --git a/dist/README.md b/dist/README.md new file mode 100644 index 0000000..b1239b6 --- /dev/null +++ b/dist/README.md @@ -0,0 +1 @@ +Directory for build products, checked in to the repo for ease-of-use. diff --git a/dist/minimart.js b/dist/minimart.js new file mode 100644 index 0000000..f9acac8 --- /dev/null +++ b/dist/minimart.js @@ -0,0 +1,2650 @@ +!function(e){if("object"==typeof exports)module.exports=e();else if("function"==typeof define&&define.amd)define(e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.Minimart=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o ."+self.fragmentClass, 1); + World.spawn({ + handleEvent: function (e) { + if (e.type === "routes") { + var level = e.gestalt.getLevel(1, 0); // find participant peers + if (!e.gestalt.isEmpty() && level.isEmpty()) { + World.shutdownWorld(); + } + } + } + }, [monitoring]); + })); +}; + +DOMFragment.prototype.handleEvent = function (e) { + if (e.type === "routes" && e.gestalt.isEmpty()) { + for (var i = 0; i < this.nodes.length; i++) { + var n = this.nodes[i]; + n.parentNode.removeChild(n); + } + World.exit(); + } +}; + +DOMFragment.prototype.interpretSpec = function (spec) { + // Fragment specs are roughly JSON-equivalents of SXML. + // spec ::== ["tag", {"attr": "value", ...}, spec, spec, ...] + // | ["tag", spec, spec, ...] + // | "cdata" + if (typeof(spec) === "string" || typeof(spec) === "number") { + return document.createTextNode(spec); + } else if ($.isArray(spec)) { + var tagName = spec[0]; + var hasAttrs = $.isPlainObject(spec[1]); + var attrs = hasAttrs ? spec[1] : {}; + var kidIndex = hasAttrs ? 2 : 1; + + // Wow! Such XSS! Many hacks! So vulnerability! Amaze! + var n = document.createElement(tagName); + for (var attr in attrs) { + if (attrs.hasOwnProperty(attr)) { + n.setAttribute(attr, attrs[attr]); + } + } + for (var i = kidIndex; i < spec.length; i++) { + n.appendChild(this.interpretSpec(spec[i])); + } + return n; + } +}; + +DOMFragment.prototype.buildNodes = function () { + var self = this; + var nodes = []; + $(self.selector).each(function (index, domNode) { + var n = self.interpretSpec(self.fragmentSpec); + n.classList.add(self.fragmentClass); + domNode.appendChild(n); + nodes.push(n); + }); + return nodes; +}; + +/////////////////////////////////////////////////////////////////////////// + +module.exports.spawnDOMDriver = spawnDOMDriver; + +},{"./minimart.js":4}],2:[function(_dereq_,module,exports){ +// JQuery event driver +var Minimart = _dereq_("./minimart.js"); +var World = Minimart.World; +var sub = Minimart.sub; +var pub = Minimart.pub; +var __ = Minimart.__; +var _$ = Minimart._$; + +function spawnJQueryDriver(baseSelector, metaLevel) { + metaLevel = metaLevel || 0; + var d = new Minimart.DemandMatcher(["jQuery", _$, _$, __], metaLevel, + {demandSideIsSubscription: true}); + d.onDemandIncrease = function (captures) { + var selector = captures[0]; + var eventName = captures[1]; + World.spawn(new JQueryEventRouter(baseSelector, selector, eventName, metaLevel), + [pub(["jQuery", selector, eventName, __], metaLevel), + pub(["jQuery", selector, eventName, __], metaLevel, 1)]); + }; + World.spawn(d); +} + +function JQueryEventRouter(baseSelector, selector, eventName, metaLevel) { + var self = this; + this.baseSelector = baseSelector || null; + this.selector = selector; + this.eventName = eventName; + this.metaLevel = metaLevel || 0; + this.preventDefault = (this.eventName.charAt(0) !== "+"); + this.handler = + World.wrap(function (e) { + World.send(["jQuery", self.selector, self.eventName, e], self.metaLevel); + if (self.preventDefault) e.preventDefault(); + return !self.preventDefault; + }); + this.computeNodes().on(this.preventDefault ? this.eventName : this.eventName.substring(1), + this.handler); +} + +JQueryEventRouter.prototype.handleEvent = function (e) { + if (e.type === "routes" && e.gestalt.isEmpty()) { + this.computeNodes().off(this.eventName, this.handler); + World.exit(); + } +}; + +JQueryEventRouter.prototype.computeNodes = function () { + if (this.baseSelector) { + return $(this.baseSelector).children(this.selector).addBack(this.selector); + } else { + return $(this.selector); + } +}; + +/////////////////////////////////////////////////////////////////////////// + +module.exports.spawnJQueryDriver = spawnJQueryDriver; + +},{"./minimart.js":4}],3:[function(_dereq_,module,exports){ +module.exports = _dereq_("./minimart.js"); + +module.exports.DOM = _dereq_("./dom-driver.js"); +module.exports.JQuery = _dereq_("./jquery-driver.js"); +module.exports.RoutingTableWidget = _dereq_("./routing-table-widget.js"); +module.exports.WebSocket = _dereq_("./websocket-driver.js"); + +module.exports.Spy = _dereq_("./spy.js").Spy; +module.exports.WakeDetector = _dereq_("./wake-detector.js").WakeDetector; + +},{"./dom-driver.js":1,"./jquery-driver.js":2,"./minimart.js":4,"./routing-table-widget.js":6,"./spy.js":7,"./wake-detector.js":8,"./websocket-driver.js":9}],4:[function(_dereq_,module,exports){ +var Route = _dereq_("./route.js"); + +/////////////////////////////////////////////////////////////////////////// + +// TODO: trigger-guards as per minimart + +/*---------------------------------------------------------------------------*/ +/* Events and Actions */ + +var __ = Route.__; +var _$ = Route._$; + +function sub(pattern, metaLevel, level) { + return Route.simpleGestalt(false, pattern, metaLevel, level); +} + +function pub(pattern, metaLevel, level) { + return Route.simpleGestalt(true, pattern, metaLevel, level); +} + +function spawn(behavior, initialGestalts) { + return { type: "spawn", + behavior: behavior, + initialGestalt: Route.gestaltUnion(initialGestalts || []) }; +} + +function updateRoutes(gestalts) { + return { type: "routes", gestalt: Route.gestaltUnion(gestalts) }; +} + +function pendingRoutingUpdate(aggregate, affectedSubgestalt, knownTarget) { + return { type: "pendingRoutingUpdate", + aggregate: aggregate, + affectedSubgestalt: affectedSubgestalt, + knownTarget: knownTarget }; +} + +function sendMessage(m, metaLevel, isFeedback) { + return { type: "message", + metaLevel: (metaLevel === undefined) ? 0 : metaLevel, + message: m, + isFeedback: (isFeedback === undefined) ? false : isFeedback }; +} + +function shutdownWorld() { + return { type: "shutdownWorld" }; +} + +/*---------------------------------------------------------------------------*/ +/* Configurations */ + +function World(bootFn) { + this.alive = true; + this.eventQueue = []; + this.runnablePids = {}; + this.partialGestalt = Route.emptyGestalt; // Only gestalt from local processes + this.fullGestalt = Route.emptyGestalt ;; // partialGestalt unioned with downwardGestalt + this.processTable = {}; + this.tombstones = {}; + this.downwardGestalt = Route.emptyGestalt; + this.processActions = []; + this.asChild(-1, bootFn, true); +} + +/* Class state / methods */ + +World.nextPid = 0; + +World.stack = []; + +World.current = function () { + return World.stack[World.stack.length - 1][0]; +}; + +World.activePid = function () { + return World.stack[World.stack.length - 1][1]; +}; + +World.send = function (m, metaLevel, isFeedback) { + World.current().enqueueAction(World.activePid(), sendMessage(m, metaLevel, isFeedback)); +}; + +World.updateRoutes = function (gestalts) { + World.current().enqueueAction(World.activePid(), updateRoutes(gestalts)); +}; + +World.spawn = function (behavior, initialGestalts) { + World.current().enqueueAction(World.activePid(), spawn(behavior, initialGestalts)); +}; + +World.exit = function (exn) { + World.current().kill(World.activePid(), exn); +}; + +World.shutdownWorld = function () { + World.current().enqueueAction(World.activePid(), shutdownWorld()); +}; + +World.withWorldStack = function (stack, f) { + var oldStack = World.stack; + World.stack = stack; + var result = null; + try { + result = f(); + } catch (e) { + World.stack = oldStack; + throw e; + } + World.stack = oldStack; + return result; +}; + +World.wrap = function (f) { + var savedStack = World.stack.slice(); + return function () { + var actuals = arguments; + return World.withWorldStack(savedStack, function () { + var result = World.current().asChild(World.activePid(), function () { + return f.apply(null, actuals); + }); + for (var i = World.stack.length - 1; i >= 0; i--) { + World.stack[i][0].markPidRunnable(World.stack[i][1]); + } + return result; + }); + }; +}; + +/* Instance methods */ + +World.prototype.enqueueAction = function (pid, action) { + this.processActions.push([pid, action]); +}; + +// The code is written to maintain the runnablePids set carefully, to +// ensure we can locally decide whether we're inert or not without +// having to search the whole deep process tree. +World.prototype.isInert = function () { + return this.eventQueue.length === 0 + && this.processActions.length === 0 + && Route.is_emptySet(this.runnablePids); +}; + +World.prototype.markPidRunnable = function (pid) { + this.runnablePids[pid] = [pid]; +}; + +World.prototype.step = function () { + this.dispatchEvents(); + this.performActions(); + this.stepChildren(); + return this.alive && !this.isInert(); +}; + +World.prototype.asChild = function (pid, f, omitLivenessCheck) { + if (!(pid in this.processTable) && !omitLivenessCheck) { + console.warn("World.asChild eliding invocation of dead process", pid); + return; + } + + World.stack.push([this, pid]); + var result = null; + try { + result = f(); + } catch (e) { + this.kill(pid, e); + } + if (World.stack.pop()[0] !== this) { + throw new Error("Internal error: World stack imbalance"); + } + return result; +}; + +World.prototype.kill = function (pid, exn) { + if (exn && exn.stack) { + console.log("Process exited", pid, exn, exn.stack); + } else { + console.log("Process exited", pid, exn); + } + var p = this.processTable[pid]; + if (p && p.behavior.trapexit) { + this.asChild(pid, function () { return p.behavior.trapexit(exn); }); + } + delete this.processTable[pid]; + if (p) { + if (exn) { + p.exitReason = exn; + this.tombstones[pid] = p; + } + this.applyAndIssueRoutingUpdate(p.gestalt, Route.emptyGestalt); + } +}; + +World.prototype.stepChildren = function () { + var pids = this.runnablePids; + this.runnablePids = {}; + for (var pid in pids) { + var p = this.processTable[pid]; + if (p && p.behavior.step /* exists, haven't called it yet */) { + var childBusy = this.asChild(pid | 0, function () { return p.behavior.step() }); + if (childBusy) this.markPidRunnable(pid); + } + } +}; + +World.prototype.performActions = function () { + var queue = this.processActions; + this.processActions = []; + var item; + while ((item = queue.shift()) && this.alive) { + this.performAction(item[0], item[1]); + } +}; + +World.prototype.dispatchEvents = function () { + var queue = this.eventQueue; + this.eventQueue = []; + var item; + while ((item = queue.shift())) { + this.dispatchEvent(item); + } +}; + +World.prototype.performAction = function (pid, action) { + switch (action.type) { + case "spawn": + var pid = World.nextPid++; + var newGestalt = action.initialGestalt.label(pid); + this.processTable[pid] = { gestalt: newGestalt, behavior: action.behavior }; + if (action.behavior.boot) { + this.asChild(pid, function () { action.behavior.boot() }); + this.markPidRunnable(pid); + } + this.applyAndIssueRoutingUpdate(Route.emptyGestalt, newGestalt, pid); + break; + case "routes": + if (pid in this.processTable) { + // it may not be: this might be the routing update from a + // kill of the process + var oldGestalt = this.processTable[pid].gestalt; + var newGestalt = action.gestalt.label(pid|0); + // ^ pid|0: convert pid from string (table key!) to integer + this.processTable[pid].gestalt = newGestalt; + this.applyAndIssueRoutingUpdate(oldGestalt, newGestalt, pid); + } + break; + case "message": + if (action.metaLevel === 0) { + this.eventQueue.push(action); + } else { + World.send(action.message, action.metaLevel - 1, action.isFeedback); + } + break; + case "shutdownWorld": + this.alive = false; // force us to stop doing things immediately + World.exit(); + break; + default: + var exn = new Error("Action type " + action.type + " not understood"); + exn.action = action; + throw exn; + } +}; + +World.prototype.updateFullGestalt = function () { + this.fullGestalt = this.partialGestalt.union(this.downwardGestalt); +}; + +World.prototype.issueLocalRoutingUpdate = function (affectedSubgestalt, knownTarget) { + this.eventQueue.push(pendingRoutingUpdate(this.fullGestalt, + affectedSubgestalt, + knownTarget)); +}; + +World.prototype.applyAndIssueRoutingUpdate = function (oldg, newg, knownTarget) { + knownTarget = typeof knownTarget === 'undefined' ? null : knownTarget; + this.partialGestalt = this.partialGestalt.erasePath(oldg).union(newg); + this.updateFullGestalt(); + this.issueLocalRoutingUpdate(oldg.union(newg), knownTarget); + World.updateRoutes([this.partialGestalt.drop()]); +}; + +World.prototype.dispatchEvent = function (e) { + switch (e.type) { + case "pendingRoutingUpdate": + var pids = e.affectedSubgestalt.match(e.aggregate); + if (e.knownTarget !== null) pids.unshift(e.knownTarget); + for (var i = 0; i < pids.length; i++) { + var pid = pids[i]; + if (pid === "out") console.warn("Would have delivered a routing update to environment"); + var p = this.processTable[pid]; + if (p) { + var g = e.aggregate.filter(p.gestalt); + this.asChild(pid, function () { p.behavior.handleEvent(updateRoutes([g])) }); + this.markPidRunnable(pid); + } + } + break; + + case "message": + var pids = this.partialGestalt.matchValue(e.message, e.metaLevel, e.isFeedback); + for (var i = 0; i < pids.length; i++) { + var pid = pids[i]; + var p = this.processTable[pid]; + this.asChild(pid, function () { p.behavior.handleEvent(e) }); + this.markPidRunnable(pid); + } + break; + + default: + var exn = new Error("Event type " + e.type + " not dispatchable"); + exn.event = e; + throw exn; + } +}; + +World.prototype.handleEvent = function (e) { + switch (e.type) { + case "routes": + var oldDownward = this.downwardGestalt; + this.downwardGestalt = e.gestalt.label("out").lift(); + this.updateFullGestalt(); + this.issueLocalRoutingUpdate(oldDownward.union(this.downwardGestalt), null); + break; + case "message": + this.eventQueue.push(sendMessage(e.message, e.metaLevel + 1, e.isFeedback)); + break; + default: + var exn = new Error("Event type " + e.type + " not understood"); + exn.event = e; + throw exn; + } +}; + +/* Debugging, management, and monitoring */ + +World.prototype.processTree = function () { + var kids = []; + for (var pid in this.processTable) { + var p = this.processTable[pid]; + if (p.behavior instanceof World) { + kids.push([pid, p.behavior.processTree()]); + } else { + kids.push([pid, p]); + } + } + for (var pid in this.tombstones) { + kids.push([pid, this.tombstones[pid]]); + } + kids.sort(); + return kids; +}; + +World.prototype.textProcessTree = function (ownPid) { + var lines = []; + + function dumpProcess(prefix, pid, p) { + if (p instanceof Array) { + lines.push(prefix + '--+ ' + pid); + for (var i = 0; i < p.length; i++) { + dumpProcess(prefix + ' |', p[i][0], p[i][1]); + } + lines.push(prefix); + } else { + var label = p.behavior.name || p.behavior.constructor.name || ''; + var tombstoneString = p.exitReason ? ' (EXITED: ' + p.exitReason + ') ' : ''; + lines.push(prefix + '-- ' + pid + ': ' + label + + tombstoneString + + JSON.stringify(p.behavior, function (k, v) { + return k === 'name' ? undefined : v; + })); + } + } + + dumpProcess('', ownPid || '', this.processTree()); + return lines.join('\n'); +}; + +World.prototype.clearTombstones = function () { + this.tombstones = {}; + for (var pid in this.processTable) { + var p = this.processTable[pid]; + if (p.behavior instanceof World) { + p.behavior.clearTombstones(); + } + } +}; + +/*---------------------------------------------------------------------------*/ +/* Utilities: matching demand for some service */ + +function DemandMatcher(projection, metaLevel, options) { + options = $.extend({ + demandLevel: 0, + supplyLevel: 0, + demandSideIsSubscription: false + }, options); + this.pattern = Route.projectionToPattern(projection); + this.projectionSpec = Route.compileProjection(projection); + this.metaLevel = metaLevel | 0; + this.demandLevel = options.demandLevel; + this.supplyLevel = options.supplyLevel; + this.demandSideIsSubscription = options.demandSideIsSubscription; + this.onDemandIncrease = function (captures) { + console.error("Unhandled increase in demand for route", captures); + }; + this.onSupplyDecrease = function (captures) { + console.error("Unhandled decrease in supply for route", captures); + }; + this.currentDemand = {}; + this.currentSupply = {}; +} + +DemandMatcher.prototype.boot = function () { + var observerLevel = 1 + Math.max(this.demandLevel, this.supplyLevel); + World.updateRoutes([sub(this.pattern, this.metaLevel, observerLevel), + pub(this.pattern, this.metaLevel, observerLevel)]); +}; + +DemandMatcher.prototype.handleEvent = function (e) { + if (e.type === "routes") { + this.handleGestalt(e.gestalt); + } +}; + +DemandMatcher.prototype.handleGestalt = function (gestalt) { + var newDemandMatcher = gestalt.project(this.projectionSpec, + !this.demandSideIsSubscription, + this.metaLevel, + this.demandLevel); + var newSupplyMatcher = gestalt.project(this.projectionSpec, + this.demandSideIsSubscription, + this.metaLevel, + this.supplyLevel); + var newDemand = Route.arrayToSet(Route.matcherKeys(newDemandMatcher)); + var newSupply = Route.arrayToSet(Route.matcherKeys(newSupplyMatcher)); + var demandDelta = Route.setSubtract(newDemand, this.currentDemand); + var supplyDelta = Route.setSubtract(this.currentSupply, newSupply); + var demandIncr = Route.setSubtract(demandDelta, newSupply); + var supplyDecr = Route.setIntersect(supplyDelta, newDemand); + this.currentDemand = newDemand; + this.currentSupply = newSupply; + for (var k in demandIncr) this.onDemandIncrease(demandIncr[k]); + for (var k in supplyDecr) this.onSupplyDecrease(supplyDecr[k]); +}; + +/*---------------------------------------------------------------------------*/ +/* Utilities: deduplicator */ + +function Deduplicator(ttl_ms) { + this.ttl_ms = ttl_ms || 10000; + this.queue = []; + this.map = {}; + this.timerId = null; +} + +Deduplicator.prototype.accept = function (m) { + var s = JSON.stringify(m); + if (s in this.map) return false; + var entry = [(+new Date()) + this.ttl_ms, s, m]; + this.map[s] = entry; + this.queue.push(entry); + + if (this.timerId === null) { + var self = this; + this.timerId = setInterval(function () { self.expireMessages(); }, + this.ttl_ms > 1000 ? 1000 : this.ttl_ms); + } + return true; +}; + +Deduplicator.prototype.expireMessages = function () { + var now = +new Date(); + while (this.queue.length > 0 && this.queue[0][0] <= now) { + var entry = this.queue.shift(); + delete this.map[entry[1]]; + } + if (this.queue.length === 0) { + clearInterval(this.timerId); + this.timerId = null; + } +}; + +/*---------------------------------------------------------------------------*/ +/* Ground interface */ + +function Ground(bootFn) { + var self = this; + this.stepperId = null; + World.withWorldStack([[this, -1]], function () { + self.world = new World(bootFn); + }); +} + +Ground.prototype.step = function () { + var self = this; + return World.withWorldStack([[this, -1]], function () { + return self.world.step(); + }); +}; + +Ground.prototype.checkPid = function (pid) { + if (pid !== -1) console.error("Weird pid in Ground markPidRunnable", pid); +}; + +Ground.prototype.markPidRunnable = function (pid) { + this.checkPid(pid); + this.startStepping(); +}; + +Ground.prototype.startStepping = function () { + var self = this; + if (this.stepperId) return; + if (this.step()) { + this.stepperId = setTimeout(function () { + self.stepperId = null; + self.startStepping(); + }, 0); + } +}; + +Ground.prototype.stopStepping = function () { + if (this.stepperId) { + clearTimeout(this.stepperId); + this.stepperId = null; + } +}; + +Ground.prototype.enqueueAction = function (pid, action) { + this.checkPid(pid); + if (action.type === 'routes') { + if (!action.gestalt.isEmpty()) { + console.error("You have subscribed to a nonexistent event source.", + action.gestalt.pretty()); + } + } else { + console.error("You have sent a message into the outer void.", action); + } +}; + +/////////////////////////////////////////////////////////////////////////// + +module.exports.__ = __; +module.exports._$ = _$; + +module.exports.sub = sub; +module.exports.pub = pub; +module.exports.spawn = spawn; +module.exports.updateRoutes = updateRoutes; +module.exports.sendMessage = sendMessage; +module.exports.shutdownWorld = shutdownWorld; + +module.exports.World = World; +module.exports.DemandMatcher = DemandMatcher; +module.exports.Deduplicator = Deduplicator; +module.exports.Ground = Ground; +module.exports.Route = Route; + +},{"./route.js":5}],5:[function(_dereq_,module,exports){ +var __ = "__"; /* wildcard marker */ + +var SOA = "__["; // start of array +var EOA = "__]"; // end of array + +function die(message) { + throw new Error(message); +} + +function $Embedded(matcher) { + this.matcher = matcher; +} + +function embeddedMatcher(matcher) { + return new $Embedded(matcher); +} + +// The pattern argument defaults to wildcard, __. +function $Capture(pattern) { + this.pattern = (typeof pattern === 'undefined' ? __ : pattern); +} + +// Abbreviation: _$(x) <==> new $Capture(x) +function _$(pattern) { + return new $Capture(pattern); +} + +function isCapture(x) { return x instanceof $Capture || x === _$; } +function capturePattern(x) { return x instanceof $Capture ? x.pattern : __; } + +var SOC = "__{{"; // start of capture +var EOC = "__}}"; // end of capture + +function $Success(value) { + this.value = value; +} + +function $WildcardSequence(matcher) { + this.matcher = matcher; +} + +function $Dict() { + this.length = 0; + this.entries = {}; +} + +$Dict.prototype.get = function (key) { + return this.entries[key] || emptyMatcher; +}; + +$Dict.prototype.set = function (key, val) { + if (!(key in this.entries)) this.length++; + this.entries[key] = val; +}; + +$Dict.prototype.clear = function (key) { + if (key in this.entries) this.length--; + delete this.entries[key]; +}; + +$Dict.prototype.isEmpty = function () { + return this.length === 0; +}; + +$Dict.prototype.copy = function () { + var other = new $Dict(); + other.length = this.length; + for (var key in this.entries) { + if (this.entries.hasOwnProperty(key)) { + other.entries[key] = this.entries[key]; + } + } + return other; +}; + +$Dict.prototype.emptyGuard = function () { + if (this.isEmpty()) return emptyMatcher; + return this; +}; + +$Dict.prototype.has = function (key) { + return key in this.entries; +}; + +$Dict.prototype.sortedKeys = function () { + var ks = []; + for (var k in this.entries) ks.push(k); + ks.sort(); + return ks; +} + +function is_emptyMatcher(m) { + return (m === emptyMatcher); +} + +/////////////////////////////////////////////////////////////////////////// +// Constructors + +var emptyMatcher = null; + +function rsuccess(v) { + return (v === emptyMatcher) ? emptyMatcher : new $Success(v); +} + +function rseq(e, r) { + if (r === emptyMatcher) return emptyMatcher; + var s = new $Dict(); + s.set(e, r); + return s; +} + +function rwild(r) { + return rseq(__, r); +} + +function rwildseq(r) { + return (r === emptyMatcher) ? emptyMatcher : new $WildcardSequence(r); +} + +/////////////////////////////////////////////////////////////////////////// + +function compilePattern(v, p) { + if (!p) die("compilePattern: missing pattern"); + return walk(p, rseq(EOA, rsuccess(v))); + + function walk(p, acc) { + if (p === __) return rwild(acc); + + if (Array.isArray(p)) { + acc = rseq(EOA, acc); + for (var i = p.length - 1; i >= 0; i--) { + acc = walk(p[i], acc); + } + return rseq(SOA, acc); + } + + if (p instanceof $Embedded) { + return appendMatcher(p.matcher, function (v) { return acc; }); + } else { + return rseq(JSON.stringify(p), acc); + } + } +} + +function shallowCopyArray(s) { + return s.slice(); +} + +function rupdateInplace(r, key, k) { + if (is_emptyMatcher(k)) { + r.clear(key); + } else { + r.set(key, k); + } +} + +function matcherEquals(a, b) { + if (a === null) { + return (b === null); + } + if (b === null) return false; + + if (a instanceof $WildcardSequence) { + if (!(b instanceof $WildcardSequence)) return false; + a = a.matcher; + b = b.matcher; + } else if (b instanceof $WildcardSequence) return false; + + if (a instanceof $Success) { + if (!(b instanceof $Success)) return false; + return valuesEqual(a.value, b.value); + } + if (b instanceof $Success) return false; + + for (var key in a.entries) { + if (!b.has(key)) return false; + if (!matcherEquals(a.entries[key], b.entries[key])) return false; + } + return true; +} + +function is_keyOpen(k) { + return k === SOA; +} + +function is_keyClose(k) { + return k === EOA; +} + +function is_keyNormal(k) { + return !(is_keyOpen(k) || is_keyClose(k)); +} + +/////////////////////////////////////////////////////////////////////////// +// Enough of sets to get by with + +function arrayToSet(xs) { + var s = {}; + for (var i = 0; i < xs.length; i++) { + s[JSON.stringify(xs[i])] = xs[i]; + } + return s; +} + +function setToArray(s) { + var r = []; + for (var k in s) r.push(s[k]); + return r; +} + +function setUnion(s1, s2) { + var s = {}; + setUnionInplace(s, s1); + setUnionInplace(s, s2); + return s; +} + +function is_emptySet(s) { + for (var k in s) { + if (s.hasOwnProperty(k)) + return false; + } + return true; +} + +function setSubtract(s1, s2) { + var s = {}; + for (var key in s1) { + if (s1.hasOwnProperty(key) && !s2.hasOwnProperty(key)) { + s[key] = s1[key]; + } + } + return s; +} + +function setIntersect(s1, s2) { + var s = {}; + for (var key in s1) { + if (s1.hasOwnProperty(key) && s2.hasOwnProperty(key)) { + s[key] = s1[key]; + } + } + return s; +} + +function setUnionInplace(acc, s) { + for (var key in s) { + if (s.hasOwnProperty(key)) { + acc[key] = s[key]; + } + } +} + +function setEqual(s1, s2) { + for (var key in s1) { + if (s1.hasOwnProperty(key)) { + if (s1[key] !== s2[key]) return false; + } + } + for (var key in s2) { + if (s2.hasOwnProperty(key)) { + if (s1[key] !== s2[key]) return false; + } + } + return true; +} + +/////////////////////////////////////////////////////////////////////////// + +var unionSuccesses = function (v1, v2) { + if (v1 === true) return v2; + if (v2 === true) return v1; + return setUnion(v1, v2); +}; + +var intersectSuccesses = function (v1, v2) { + return v1; +}; + +var erasePathSuccesses = function (v1, v2) { + var r = setSubtract(v1, v2); + if (is_emptySet(r)) return null; + return r; +}; + +var matchMatcherSuccesses = function (v1, v2, acc) { + setUnionInplace(acc, v2); +}; + +var projectSuccess = function (v) { + return v; +}; + +var valuesEqual = function (a, b) { + return setEqual(a, b); +}; + +/////////////////////////////////////////////////////////////////////////// + +function expandWildseq(r) { + return union(rwild(rwildseq(r)), rseq(EOA, r)); +} + +function union(o1, o2) { + return merge(o1, o2); + + function merge(o1, o2) { + if (is_emptyMatcher(o1)) return o2; + if (is_emptyMatcher(o2)) return o1; + return walk(o1, o2); + } + + function walk(r1, r2) { + if (r1 instanceof $WildcardSequence) { + if (r2 instanceof $WildcardSequence) { + return rwildseq(walk(r1.matcher, r2.matcher)); + } + r1 = expandWildseq(r1.matcher); + } else if (r2 instanceof $WildcardSequence) { + r2 = expandWildseq(r2.matcher); + } + + if (r1 instanceof $Success && r2 instanceof $Success) { + return rsuccess(unionSuccesses(r1.value, r2.value)); + } + + var w = merge(r1.get(__), r2.get(__)); + if (is_emptyMatcher(w)) { + var smaller = r1.length < r2.length ? r1 : r2; + var larger = r1.length < r2.length ? r2 : r1; + var target = larger.copy(); + for (var key in smaller.entries) { + var k = merge(smaller.get(key), larger.get(key)); + rupdateInplace(target, key, k); + } + return target.emptyGuard(); + } else { + function examineKey(rA, key, rB) { + if ((key !== __) && !target.has(key)) { + var k = merge(rA.get(key), rB.get(key)); + if (is_keyOpen(key)) { + rupdateInplace(target, key, merge(rwildseq(w), k)); + } else if (is_keyClose(key)) { + if (w instanceof $WildcardSequence) { + rupdateInplace(target, key, merge(w.matcher, k)); + } else { + rupdateInplace(target, key, k); + } + } else { + rupdateInplace(target, key, merge(w, k)); + } + } + } + var target = rwild(w).copy(); + for (var key in r1.entries) { examineKey(r1, key, r2); } + for (var key in r2.entries) { examineKey(r2, key, r1); } + return target; + } + } +} + +function unionN() { + var acc = emptyMatcher; + for (var i = 0; i < arguments.length; i++) { + acc = union(acc, arguments[i]); + } + return acc; +} + +function intersect(o1, o2) { + if (is_emptyMatcher(o1)) return emptyMatcher; + if (is_emptyMatcher(o2)) return emptyMatcher; + return walk(o1, o2); + + function walkFlipped(r2, r1) { return walk(r1, r2); } + + function walk(r1, r2) { + // INVARIANT: r1 is a part of the original o1, and + // likewise for r2. This is so that the first arg to + // intersectSuccesses always comes from r1, and the second + // from r2. + if (is_emptyMatcher(r1)) return emptyMatcher; + if (is_emptyMatcher(r2)) return emptyMatcher; + + if (r1 instanceof $WildcardSequence) { + if (r2 instanceof $WildcardSequence) { + return rwildseq(walk(r1.matcher, r2.matcher)); + } + r1 = expandWildseq(r1.matcher); + } else if (r2 instanceof $WildcardSequence) { + r2 = expandWildseq(r2.matcher); + } + + if (r1 instanceof $Success && r2 instanceof $Success) { + return rsuccess(intersectSuccesses(r1.value, r2.value)); + } + + var w1 = r1.get(__); + var w2 = r2.get(__); + var w = walk(w1, w2); + + var target = new $Dict(); + + function examineKey(key) { + if ((key !== __) && !target.has(key)) { + var k1 = r1.get(key); + var k2 = r2.get(key); + if (is_emptyMatcher(k1)) { + if (is_emptyMatcher(k2)) { + rupdateInplace(target, key, emptyMatcher); + } else { + rupdateInplace(target, key, walkWild(walk, w1, key, k2)); + } + } else { + if (is_emptyMatcher(k2)) { + rupdateInplace(target, key, walkWild(walkFlipped, w2, key, k1)); + } else { + rupdateInplace(target, key, walk(k1, k2)); + } + } + } + } + + if (is_emptyMatcher(w1)) { + if (is_emptyMatcher(w2)) { + for (var key in (r1.length < r2.length ? r1 : r2).entries) examineKey(key); + } else { + for (var key in r1.entries) examineKey(key); + } + } else { + if (is_emptyMatcher(w2)) { + for (var key in r2.entries) examineKey(key); + } else { + rupdateInplace(target, __, w); + for (var key in r1.entries) examineKey(key); + for (var key in r2.entries) examineKey(key); + } + } + return target.emptyGuard(); + } + + function walkWild(walker, w, key, k) { + if (is_emptyMatcher(w)) return emptyMatcher; + if (is_keyOpen(key)) return walker(rwildseq(w), k); + if (is_keyClose(key)) { + if (w instanceof $WildcardSequence) return walker(w.matcher, k); + return emptyMatcher; + } + return walker(w, k); + } +} + +// Removes r2's mappings from r1. Assumes r2 has previously been +// union'd into r1. The erasePathSuccesses function should return +// null to signal "no remaining success values". +function erasePath(o1, o2) { + return walk(o1, o2); + + function walk(r1, r2) { + if (is_emptyMatcher(r1)) { + return emptyMatcher; + } else { + if (is_emptyMatcher(r2)) { + return r1; + } + } + + if (r1 instanceof $WildcardSequence) { + if (r2 instanceof $WildcardSequence) { + return rwildseq(walk(r1.matcher, r2.matcher)); + } + r1 = expandWildseq(r1.matcher); + } else if (r2 instanceof $WildcardSequence) { + r2 = expandWildseq(r2.matcher); + } + + if (r1 instanceof $Success && r2 instanceof $Success) { + return rsuccess(erasePathSuccesses(r1.value, r2.value)); + } + + var w1 = r1.get(__); + var w2 = r2.get(__); + var w = walk(w1, w2); + var target; + + function examineKey(key) { + if (key !== __) { + var k1 = r1.get(key); + var k2 = r2.get(key); + var updatedK; + if (is_emptyMatcher(k2)) { + updatedK = walkWild(key, k1, w2); + } else { + updatedK = walk(k1, k2); + } + // Here we ensure a "minimal" remainder in cases + // where after an erasure, a particular key's + // continuation is the same as the wildcard's + // continuation. TODO: the matcherEquals check may + // be expensive. If so, how can it be made + // cheaper? + if (is_keyOpen(key)) { + rupdateInplace(target, key, + ((updatedK instanceof $WildcardSequence) && + matcherEquals(updatedK.matcher, w)) + ? emptyMatcher + : updatedK); + } else if (is_keyClose(key)) { + // We take care of this case later, after the + // target is fully constructed/rebuilt. + rupdateInplace(target, key, updatedK); + } else { + rupdateInplace(target, key, + (matcherEquals(updatedK, w) ? emptyMatcher : updatedK)); + } + } + } + + if (is_emptyMatcher(w2)) { + target = r1.copy(); + for (var key in r2.entries) examineKey(key); + } else { + target = new $Dict(); + rupdateInplace(target, __, w); + for (var key in r1.entries) examineKey(key); + for (var key in r2.entries) examineKey(key); + } + + // Here, the target is complete. If it has only two keys, + // one wild and one is_keyClose, and wild's continuation + // is a $WildcardSequence and the other continuation is + // identical to the sequence's continuation, then replace + // the whole thing with a nested $WildcardSequence. + // (We know w === target.get(__) from before.) + // + // TODO: I suspect actually this applies even if there are + // more than two keys, so long as all their continuations + // are identical and there's at least one is_keyClose + // alongside a wild. + if (target.length === 2) { + var finalW = target.get(__); + if (finalW instanceof $WildcardSequence) { + for (var key in target.entries) { + if ((key !== __) && is_keyClose(key)) { + var k = target.get(key); + if (matcherEquals(k, finalW.matcher)) { + return finalW; + } + } + } + } + } + + return target.emptyGuard(); + } + + function walkWild(key, k, w) { + if (is_emptyMatcher(w)) return k; + if (is_keyOpen(key)) return walk(k, rwildseq(w)); + if (is_keyClose(key)) { + if (w instanceof $WildcardSequence) return walk(k, w.matcher); + return k; + } + return walk(k, w); + } +} + +// Returns null on failed match, otherwise the appropriate success +// value contained in the matcher r. +function matchValue(r, v) { + var failureResult = null; + + var vs = [v]; + var stack = [[]]; + + while (!is_emptyMatcher(r)) { + if (r instanceof $WildcardSequence) { + if (stack.length === 0) return failureResult; + vs = stack.pop(); + r = r.matcher; + continue; + } + + if (r instanceof $Success) { + if (vs.length === 0 && stack.length === 0) return r.value; + return failureResult; + } + + if (vs.length === 0) { + if (stack.length === 0) return failureResult; + vs = stack.pop(); + r = r.get(EOA); + continue; + } + + var v = vs.shift(); + + if (typeof v === 'string' && v.substring(0, 2) === '__') { + die("Cannot match special string starting with __"); + } + + if (Array.isArray(v)) { + if (SOA in r.entries) { + r = r.get(SOA); + stack.push(vs); + vs = shallowCopyArray(v); + } else { + r = r.get(__); + } + } else { + var key; + try { + key = JSON.stringify(v); + } catch (exn) { + // For example, v might be cyclic, as in DOM events. + key = null; + } + if (key in r.entries) { + r = r.get(key); + } else { + r = r.get(__); + } + } + } + + return failureResult; +} + +// TODO: better name for this +function matchMatcher(o1, o2, seed) { + var acc = typeof seed === 'undefined' ? {} : seed; // will be modified in place + walk(o1, o2); + return acc; + + function walkFlipped(r2, r1) { return walk(r1, r2); } + + function walk(r1, r2) { + if (is_emptyMatcher(r1) || is_emptyMatcher(r2)) return; + + if (r1 instanceof $WildcardSequence) { + if (r2 instanceof $WildcardSequence) { + walk(r1.matcher, r2.matcher); + return; + } + r1 = expandWildseq(r1.matcher); + } else if (r2 instanceof $WildcardSequence) { + r2 = expandWildseq(r2.matcher); + } + + if (r1 instanceof $Success && r2 instanceof $Success) { + matchMatcherSuccesses(r1.value, r2.value, acc); + return; + } + + var w1 = r1.get(__); + var w2 = r2.get(__); + walk(w1, w2); + + function examineKey(key) { + if (key !== __) { + var k1 = r1.get(key); + var k2 = r2.get(key); + if (is_emptyMatcher(k1)) { + if (is_emptyMatcher(k2)) { + return; + } else { + walkWild(walk, w1, key, k2); + } + } else { + if (is_emptyMatcher(k2)) { + walkWild(walkFlipped, w2, key, k1); + } else { + walk(k1, k2); + } + } + } + } + + // Optimize similarly to intersect(). + if (is_emptyMatcher(w1)) { + if (is_emptyMatcher(w2)) { + for (var key in (r1.length < r2.length ? r1 : r2).entries) examineKey(key); + } else { + for (var key in r1.entries) examineKey(key); + } + } else { + if (is_emptyMatcher(w2)) { + for (var key in r2.entries) examineKey(key); + } else { + for (var key in r1.entries) examineKey(key); + for (var key in r2.entries) examineKey(key); + } + } + } + + function walkWild(walker, w, key, k) { + if (is_emptyMatcher(w)) return; + if (is_keyOpen(key)) { + walker(rwildseq(w), k); + return; + } + if (is_keyClose(key)) { + if (w instanceof $WildcardSequence) walker(w.matcher, k); + return; + } + walker(w, k); + } +} + +function appendMatcher(m, mTailFn) { + return walk(m); + + function walk(m) { + if (is_emptyMatcher(m)) return emptyMatcher; + if (m instanceof $WildcardSequence) return rwildseq(walk(m.matcher)); + if (m instanceof $Success) die("Ill-formed matcher"); + + var target = new $Dict(); + for (var key in m.entries) { + var k = m.get(key); + if (is_keyClose(key) && (k instanceof $Success)) { + target = union(target, mTailFn(k.value)); + } else { + rupdateInplace(target, key, walk(k)); + } + } + return target.emptyGuard(); + } +} + +function relabel(m, f) { + return walk(m); + + function walk(m) { + if (is_emptyMatcher(m)) return emptyMatcher; + if (m instanceof $WildcardSequence) return rwildseq(walk(m.matcher)); + if (m instanceof $Success) return rsuccess(f(m.value)); + + var target = new $Dict(); + for (var key in m.entries) { + rupdateInplace(target, key, walk(m.get(key))); + } + return target.emptyGuard(); + } +} + +function compileProjection(/* projection, projection, ... */) { + var acc = []; + for (var i = 0; i < arguments.length; i++) { + walk(arguments[i]); + } + acc.push(EOA); + return acc; + + function walk(p) { + if (isCapture(p)) { + acc.push(SOC); + walk(capturePattern(p)); + acc.push(EOC); + return; + } + + if (Array.isArray(p)) { + acc.push(SOA); + for (var i = 0; i < p.length; i++) { + walk(p[i]); + } + acc.push(EOA); + return; + } + + if (p instanceof $Embedded) { + die("Cannot embed matcher in projection"); + } else { + if (p === __) { + acc.push(p); + } else { + acc.push(JSON.stringify(p)); + } + } + } +} + +function projectionToPattern(p) { + return walk(p); + + function walk(p) { + if (isCapture(p)) return walk(capturePattern(p)); + + if (Array.isArray(p)) { + var result = []; + for (var i = 0; i < p.length; i++) { + result.push(walk(p[i])); + } + return result; + } + + if (p instanceof $Embedded) { + return p.matcher; + } else { + return p; + } + } +} + +function project(m, spec) { + return walk(false, m, 0); + + function walk(isCapturing, m, specIndex) { + if (specIndex >= spec.length) { + if (isCapturing) die("Bad specification: unclosed capture"); + if (m instanceof $Success) { + return rseq(EOA, rsuccess(projectSuccess(m.value))); + } else { + return emptyMatcher; + } + } + + if (is_emptyMatcher(m)) return emptyMatcher; + + var item = spec[specIndex]; + var nextIndex = specIndex + 1; + + if (item === EOC) { + if (!isCapturing) die("Bad specification: unepxected EOC"); + return walk(false, m, nextIndex); + } + + if (item === SOC) { + if (isCapturing) die("Bad specification: nested capture"); + return walk(true, m, nextIndex); + } + + if (item === __) { + if (m instanceof $WildcardSequence) { + if (isCapturing) { + return rwild(walk(isCapturing, m, nextIndex)); + } else { + return walk(isCapturing, m, nextIndex); + } + } + + if (m instanceof $Success) { + return emptyMatcher; + } + + var target; + if (isCapturing) { + target = new $Dict(); + rupdateInplace(target, __, walk(isCapturing, m.get(__), nextIndex)); + for (var key in m.entries) { + if (key !== __) { + var mk = m.get(key); + if (is_keyOpen(key)) { + function cont(mk2) { return walk(isCapturing, mk2, nextIndex); } + rupdateInplace(target, key, captureNested(mk, cont)); + } else if (is_keyClose(key)) { + // do nothing + } else { + rupdateInplace(target, key, walk(isCapturing, mk, nextIndex)); + } + } + } + } else { + target = walk(isCapturing, m.get(__), nextIndex); + for (var key in m.entries) { + if (key !== __) { + var mk = m.get(key); + if (is_keyOpen(key)) { + function cont(mk2) { return walk(isCapturing, mk2, nextIndex); } + target = union(target, skipNested(mk, cont)); + } else if (is_keyClose(key)) { + // do nothing + } else { + target = union(target, walk(isCapturing, mk, nextIndex)); + } + } + } + } + return target; + } + + var result; + if (m instanceof $WildcardSequence) { + if (is_keyOpen(item)) { + result = walk(isCapturing, rwildseq(m), nextIndex); + } else if (is_keyClose(item)) { + result = walk(isCapturing, m.matcher, nextIndex); + } else { + result = walk(isCapturing, m, nextIndex); + } + } else if (m instanceof $Success) { + result = emptyMatcher; + } else { + if (is_keyOpen(item)) { + result = walk(isCapturing, rwildseq(m.get(__)), nextIndex); + } else if (is_keyClose(item)) { + result = emptyMatcher; + } else { + result = walk(isCapturing, m.get(__), nextIndex); + } + result = union(result, walk(isCapturing, m.get(item), nextIndex)); + } + if (isCapturing) { + result = rseq(item, result); + } + return result; + } + + function captureNested(m, cont) { + if (m instanceof $WildcardSequence) { + return rwildseq(cont(m.matcher)); + } + + if (is_emptyMatcher(m) || (m instanceof $Success)) { + return emptyMatcher; + } + + var target = new $Dict(); + rupdateInplace(target, __, captureNested(m.get(__), cont)); + for (var key in m.entries) { + if (key !== __) { + var mk = m.get(key); + if (is_keyOpen(key)) { + function cont2(mk2) { return captureNested(mk2, cont); } + rupdateInplace(target, key, captureNested(mk, cont2)); + } else if (is_keyClose(key)) { + rupdateInplace(target, key, cont(mk)); + } else { + rupdateInplace(target, key, captureNested(mk, cont)); + } + } + } + return target.emptyGuard(); + } + + function skipNested(m, cont) { + if (m instanceof $WildcardSequence) { + return cont(m.matcher); + } + + if (is_emptyMatcher(m) || (m instanceof $Success)) { + return emptyMatcher; + } + + var target = skipNested(m.get(__), cont); + for (var key in m.entries) { + if (key !== __) { + var mk = m.get(key); + if (is_keyOpen(key)) { + function cont2(mk2) { return skipNested(mk2, cont); } + target = union(target, skipNested(mk, cont2)); + } else if (is_keyClose(key)) { + target = union(target, cont(mk)); + } else { + target = union(target, skipNested(mk, cont)); + } + } + } + return target; + } +} + +function matcherKeys(m) { + if (is_emptyMatcher(m)) return []; + return walkSeq(m, function (vss, vsk) { return vss; }); + + function walk(m, k) { + if (m instanceof $WildcardSequence) return null; + if (m instanceof $Success) return []; + if (m.has(__)) return null; + var acc = []; + for (var key in m.entries) { + var mk = m.get(key); + var piece; + if (is_keyOpen(key)) { + function seqK(vss, vsk) { + var acc = []; + for (var i = 0; i < vss.length; i++) { + var vs = vss[i]; + acc = acc.concat(k(transformSeqs(vs, key), vsk)); + } + return acc; + } + piece = walkSeq(mk, seqK); + } else if (is_keyClose(key)) { + die("matcherKeys: internal error: unexpected key-close"); + } else { + piece = k(JSON.parse(key), mk); + } + if (piece == null) return null; + acc = acc.concat(piece); + } + return acc; + } + + function walkSeq(m, k) { + if (m instanceof $WildcardSequence) return null; + if (m instanceof $Success) return k([], emptyMatcher); // TODO: ?? + if (m.has(__)) return null; + var acc = []; + for (var key in m.entries) { + var mk = m.get(key); + var piece; + if (is_keyClose(key)) { + piece = k([[]], mk); + } else { + function outerK(v, vk) { + return walkSeq(vk, innerK); + function innerK(vss, vsk) { + var acc = []; + for (var i = 0; i < vss.length; i++) { + var vs = shallowCopyArray(vss[i]); + vs.unshift(v); + acc.push(vs); + } + return k(acc, vsk); + } + } + piece = walk(rseq(key, mk), outerK); + } + if (piece == null) return null; + acc = acc.concat(piece); + } + return acc; + } + + function transformSeqs(vs, opener) { + if (opener === SOA) return vs; + die("Internal error: unknown opener " + opener); + } +} + +function prettyMatcher(m, initialIndent) { + var acc = []; + walk(initialIndent || 0, m); + return acc.join(''); + + function walk(i, m) { + if (is_emptyMatcher(m)) { + acc.push("::: no further matches possible"); + return; + } + if (m instanceof $WildcardSequence) { + acc.push("...>"); + walk(i + 4, m.matcher); + return; + } + if (m instanceof $Success) { + var vs = JSON.stringify(typeof m.value === 'object' + ? setToArray(m.value) + : m.value); + acc.push("{" + vs + "}"); + return; + } + + if (m.length === 0) { + acc.push(" ::: empty hash!"); + return; + } + + var needSep = false; + var keys = m.sortedKeys(); + for (var keyi = 0; keyi < keys.length; keyi++) { + var key = keys[keyi]; + var k = m.entries[key]; + if (needSep) { + acc.push("\n"); + acc.push(indentStr(i)); + } else { + needSep = true; + } + acc.push(" "); + if (key === __) key = '★'; + if (key === SOA) key = '<'; + if (key === EOA) key = '>'; + acc.push(key); + walk(i + key.length + 1, k); + } + } + + function indentStr(i) { + return new Array(i + 1).join(' '); // eww + } +} + +function serializeMatcher(m, serializeSuccess) { + return walk(m); + function walk(m) { + if (is_emptyMatcher(m)) return []; + if (m instanceof $WildcardSequence) { + return ["...)", walk(m.matcher)]; + } + if (m instanceof $Success) { + return ["", serializeSuccess(m.value)]; + } + var acc = []; + for (var key in m.entries) { + var k = m.entries[key]; + if (key === __) key = ["__"]; + else if (key === SOA) key = ["("]; + else if (key === EOA) key = [")"]; + else key = JSON.parse(key); + acc.push([key, walk(k)]); + } + return acc; + } +} + +function deserializeMatcher(r, deserializeSuccess) { + return walk(r); + function walk(r) { + if (r.length === 0) return emptyMatcher; + if (r[0] === "...)") return rwildseq(walk(r[1])); + if (r[0] === "") return rsuccess(deserializeSuccess(r[1])); + var acc = new $Dict(); + for (var i = 0; i < r.length; i++) { + var rkey = r[i][0]; + var rk = r[i][1]; + var key; + if (Array.isArray(rkey)) { + switch (rkey[0]) { + case "__": key = __; break; + case "(": key = SOA; break; + case ")": key = EOA; break; + default: die("Invalid serialized special key: " + rkey[0]); + } + } else { + key = JSON.stringify(rkey); + } + rupdateInplace(acc, key, walk(rk)); + } + return acc; + } +} + +/////////////////////////////////////////////////////////////////////////// +// Gestalts. +// TODO: support Infinity as a level number + +function GestaltLevel(subs, advs) { + this.subscriptions = subs; + this.advertisements = advs; +} + +GestaltLevel.prototype.isEmpty = function () { + return is_emptyMatcher(this.subscriptions) && is_emptyMatcher(this.advertisements); +}; + +GestaltLevel.prototype.equals = function (other) { + return matcherEquals(this.subscriptions, other.subscriptions) + && matcherEquals(this.advertisements, other.advertisements); +}; + +GestaltLevel.prototype.pretty = function () { + var acc = []; + if (!is_emptyMatcher(this.subscriptions)) { + acc.push(" - subs:"); + acc.push(prettyMatcher(this.subscriptions, 9)); + acc.push("\n"); + } + if (!is_emptyMatcher(this.advertisements)) { + acc.push(" - advs:"); + acc.push(prettyMatcher(this.advertisements, 9)); + acc.push("\n"); + } + return acc.join(''); +}; + +function straightGestaltLevelOp(op) { + return function (p1, p2) { + return new GestaltLevel(op(p1.subscriptions, p2.subscriptions), + op(p1.advertisements, p2.advertisements)); + }; +}; + +var emptyLevel = new GestaltLevel(emptyMatcher, emptyMatcher); +var emptyMetaLevel = []; + +function Gestalt(metaLevels) { + this.metaLevels = metaLevels; +} + +Gestalt.prototype.getMetaLevel = function (n) { + return this.metaLevels[n] || emptyMetaLevel; +}; + +Gestalt.prototype.getLevel = function (metaLevel, level) { + return this.getMetaLevel(metaLevel)[level] || emptyLevel; +}; + +Gestalt.prototype.metaLevelCount = function () { return this.metaLevels.length; }; +Gestalt.prototype.levelCount = function (n) { return this.getMetaLevel(n).length; }; + +Gestalt.prototype.matchValue = function (body, metaLevel, isFeedback) { + var levels = this.getMetaLevel(metaLevel); + var pids = {}; + for (var i = 0; i < levels.length; i++) { + var matcher = (isFeedback ? levels[i].advertisements : levels[i].subscriptions); + setUnionInplace(pids, matchValue(matcher, body)); + } + return setToArray(pids); +}; + +Gestalt.prototype.project = function (spec, getAdvertisements, metaLevel, level) { + var l = this.getLevel(metaLevel | 0, level | 0); + var matcher = (getAdvertisements ? l.advertisements : l.subscriptions); + return project(matcher, spec); +}; + +Gestalt.prototype.drop = function () { + var mls = shallowCopyArray(this.metaLevels); + mls.shift(); + return new Gestalt(mls); +}; + +Gestalt.prototype.lift = function () { + var mls = shallowCopyArray(this.metaLevels); + mls.unshift(emptyMetaLevel); + return new Gestalt(mls); +}; + +Gestalt.prototype.equals = function (other) { + if (this.metaLevels.length !== other.metaLevels.length) return false; + for (var i = 0; i < this.metaLevels.length; i++) { + var ls1 = this.metaLevels[i]; + var ls2 = other.metaLevels[i]; + if (ls1.length !== ls2.length) return false; + for (var j = 0; j < ls1.length; j++) { + var p1 = ls1[j]; + var p2 = ls2[j]; + if (!p1.equals(p2)) return false; + } + } + return true; +}; + +function simpleGestalt(isAdv, pat, metaLevel, level) { + metaLevel = metaLevel || 0; + level = level || 0; + var matcher = compilePattern(true, pat); + var l = new GestaltLevel(isAdv ? emptyMatcher : matcher, + isAdv ? matcher : emptyMatcher); + var levels = [l]; + while (level--) { levels.unshift(emptyLevel); } + var metaLevels = [levels]; + while (metaLevel--) { metaLevels.unshift(emptyMetaLevel); } + return new Gestalt(metaLevels); +} + +var emptyGestalt = new Gestalt([]); + +// Not quite what it says on the tin - the true fullGestalt +// wouldn't be parameterized on the number of levels and +// metalevels, but instead would be full at *all* levels and +// metalevels. Our representation leaks through into the interface +// here :-/ +function fullGestalt(nMetalevels, nLevels) { + var matcher = compilePattern(true, __); + var l = new GestaltLevel(matcher, matcher); + var levels = []; + while (nLevels--) { levels.push(l); } + var metaLevels = []; + while (nMetalevels--) { metaLevels.push(levels); } + return new Gestalt(metaLevels); +} + +Gestalt.prototype.isEmpty = function () { + for (var i = 0; i < this.metaLevels.length; i++) { + var levels = this.metaLevels[i]; + for (var j = 0; j < levels.length; j++) { + if (!levels[j].isEmpty()) return false; + } + } + return true; +}; + +function maybePushLevel(levels, i, level) { + if (!level.isEmpty()) { + while (levels.length < i) levels.push(emptyLevel); + levels.push(level); + } +} + +function maybePushMetaLevel(metaLevels, i, metaLevel) { + if (metaLevel.length > 0) { + while (metaLevels.length < i) metaLevels.push(emptyMetaLevel); + metaLevels.push(metaLevel); + } +} + +Gestalt.prototype.mapZip = function (other, lengthCombiner, f) { + var metaLevels = []; + var mls1 = this.metaLevels; + var mls2 = other.metaLevels; + var nm = lengthCombiner(mls1.length, mls2.length); + for (var i = 0; i < nm; i++) { + var levels = []; + var ls1 = mls1[i] || emptyMetaLevel; + var ls2 = mls2[i] || emptyMetaLevel; + var nl = lengthCombiner(ls1.length, ls2.length); + for (var j = 0; j < nl; j++) { + var p1 = ls1[j] || emptyLevel; + var p2 = ls2[j] || emptyLevel; + var p = f(p1, p2); + maybePushLevel(levels, j, p); + } + maybePushMetaLevel(metaLevels, i, levels); + } + return new Gestalt(metaLevels); +}; + +Gestalt.prototype.union1 = function (other) { + return this.mapZip(other, Math.max, straightGestaltLevelOp(union)); +}; + +function gestaltUnion(gs) { + if (gs.length === 0) return emptyGestalt; + var acc = gs[0]; + for (var i = 1; i < gs.length; i++) { + acc = acc.union1(gs[i]); + } + return acc; +} + +Gestalt.prototype.union = function () { + return arguments.length > 0 ? this.union1(gestaltUnion(arguments)) : this; +}; + +// Accumulates matchers from higher-numbered levels into +// lower-numbered levels. +function telescopeLevels(levels) { + var result = shallowCopyArray(levels); + for (var i = result.length - 2; i >= 0; i--) { + result[i] = + new GestaltLevel(union(result[i].subscriptions, result[i+1].subscriptions), + union(result[i].advertisements, result[i+1].advertisements)); + } + return result; +}; + +Gestalt.prototype.telescoped = function () { + var mls = []; + for (var i = 0; i < this.metaLevels.length; i++) { + mls.push(telescopeLevels(this.metaLevels[i])); + } + return new Gestalt(mls); +}; + +Gestalt.prototype.filter = function (perspective) { + var metaLevels = []; + var mls1 = this.metaLevels; + var mls2 = perspective.metaLevels; + var nm = Math.min(mls1.length, mls2.length); + for (var i = 0; i < nm; i++) { + var levels = []; + var ls1 = mls1[i] || emptyMetaLevel; + var ls2 = mls2[i] || emptyMetaLevel; + var nl = Math.min(ls1.length, ls2.length - 1); + for (var j = 0; j < nl; j++) { + var p1 = ls1[j] || emptyLevel; + var subs = emptyMatcher; + var advs = emptyMatcher; + for (var k = j + 1; k < ls2.length; k++) { + var p2 = ls2[k] || emptyLevel; + subs = union(subs, intersect(p1.subscriptions, p2.advertisements)); + advs = union(advs, intersect(p1.advertisements, p2.subscriptions)); + } + maybePushLevel(levels, j, new GestaltLevel(subs, advs)); + } + maybePushMetaLevel(metaLevels, i, levels); + } + return new Gestalt(metaLevels); +}; + +Gestalt.prototype.match = function (perspective) { + var pids = {}; + var nm = Math.min(this.metaLevels.length, perspective.metaLevels.length); + for (var i = 0; i < nm; i++) { + var ls1 = this.metaLevels[i] || emptyMetaLevel; + var ls2 = perspective.metaLevels[i] || emptyMetaLevel; + var nl = Math.min(ls1.length, ls2.length - 1); + for (var j = 0; j < nl; j++) { + var p1 = ls1[j] || emptyLevel; + for (var k = j + 1; k < ls2.length; k++) { + var p2 = ls2[k] || emptyLevel; + matchMatcher(p1.subscriptions, p2.advertisements, pids); + matchMatcher(p1.advertisements, p2.subscriptions, pids); + } + } + } + return setToArray(pids); +}; + +Gestalt.prototype.erasePath = function (path) { + return this.mapZip(path, Math.max, straightGestaltLevelOp(erasePath)); +}; + +function mapLevels(inputMetaLevels, f, emptyCheck, inputEmptyLevel, outputEmptyLevel) { + var outputMetaLevels = []; + for (var i = 0; i < inputMetaLevels.length; i++) { + var ls = inputMetaLevels[i]; + var levels = []; + for (var j = 0; j < ls.length; j++) { + var p = f(ls[j] || inputEmptyLevel, i, j); + if (!emptyCheck(p, i, j)) { + while (levels.length < j) levels.push(outputEmptyLevel); + levels.push(p); + } + } + if (levels.length > 0) { + while (outputMetaLevels.length < i) outputMetaLevels.push(emptyMetaLevel); + outputMetaLevels.push(levels); + } + } + return outputMetaLevels; +}; + +Gestalt.prototype.transform = function (f) { + return new Gestalt(mapLevels(this.metaLevels, function (p, ml, l) { + return new GestaltLevel(f(p.subscriptions, ml, l, false), + f(p.advertisements, ml, l, true)); + }, function (p) { + return p.isEmpty(); + }, emptyLevel, emptyLevel)); +}; + +Gestalt.prototype.stripLabel = function () { + return this.transform(function (m) { return relabel(m, function (v) { return true; }); }); +}; + +Gestalt.prototype.label = function (pid) { + var pids = arrayToSet([pid]); + return this.transform(function (m) { return relabel(m, function (v) { return pids; }); }); +}; + +Gestalt.prototype.pretty = function () { + var acc = []; + if (this.isEmpty()) { + acc.push("EMPTY GESTALT\n"); + } else { + for (var i = 0; i < this.metaLevels.length; i++) { + var ls = this.metaLevels[i]; + for (var j = 0; j < ls.length; j++) { + var p = ls[j]; + if (!p.isEmpty()) { + acc.push("GESTALT metalevel " + i + " level " + j + ":\n"); + acc.push(p.pretty()); + } + } + } + } + return acc.join(''); +}; + +Gestalt.prototype.serialize = function (serializeSuccess) { + if (typeof serializeSuccess === 'undefined') { + serializeSuccess = function (v) { return v === true ? true : setToArray(v); }; + } + return ["gestalt", mapLevels(this.metaLevels, function (p) { + return [serializeMatcher(p.subscriptions, serializeSuccess), + serializeMatcher(p.advertisements, serializeSuccess)]; + }, function (pr) { + return pr.length === 2 && pr[0].length === 0 && pr[1].length === 0; + }, emptyLevel, [[],[]])]; +}; + +function deserializeGestalt(r, deserializeSuccess) { + if (typeof deserializeSuccess === 'undefined') { + deserializeSuccess = function (v) { return v === true ? true : arrayToSet(v); }; + } + if (r[0] !== "gestalt") die("Invalid gestalt serialization: " + r); + return new Gestalt(mapLevels(r[1], function (pr) { + return new GestaltLevel(deserializeMatcher(pr[0], deserializeSuccess), + deserializeMatcher(pr[1], deserializeSuccess)); + }, function (p) { + return p.isEmpty(); + }, [[],[]], emptyLevel)); +} + +/////////////////////////////////////////////////////////////////////////// + +module.exports.__ = __; +module.exports.arrayToSet = arrayToSet; +module.exports.setToArray = setToArray; +module.exports.setUnion = setUnion; +module.exports.setSubtract = setSubtract; +module.exports.setIntersect = setIntersect; +module.exports.setEqual = setEqual; +module.exports.is_emptySet = is_emptySet; +module.exports.$Capture = $Capture; +module.exports._$ = _$; +module.exports.is_emptyMatcher = is_emptyMatcher; +module.exports.emptyMatcher = emptyMatcher; +module.exports.embeddedMatcher = embeddedMatcher; +module.exports.compilePattern = compilePattern; +module.exports.union = unionN; +module.exports.intersect = intersect; +module.exports.erasePath = erasePath; +module.exports.matchValue = matchValue; +module.exports.matchMatcher = matchMatcher; +module.exports.appendMatcher = appendMatcher; +module.exports.relabel = relabel; +module.exports.compileProjection = compileProjection; +module.exports.projectionToPattern = projectionToPattern; +module.exports.project = project; +module.exports.matcherKeys = matcherKeys; +module.exports.matcherEquals = matcherEquals; +module.exports.prettyMatcher = prettyMatcher; +module.exports.serializeMatcher = serializeMatcher; +module.exports.deserializeMatcher = deserializeMatcher; + +module.exports.GestaltLevel = GestaltLevel; +module.exports.Gestalt = Gestalt; +module.exports.simpleGestalt = simpleGestalt; +module.exports.emptyGestalt = emptyGestalt; +module.exports.fullGestalt = fullGestalt; +module.exports.gestaltUnion = gestaltUnion; +module.exports.deserializeGestalt = deserializeGestalt; + +},{}],6:[function(_dereq_,module,exports){ +var Minimart = _dereq_("./minimart.js"); +var Route = Minimart.Route; +var World = Minimart.World; +var sub = Minimart.sub; +var pub = Minimart.pub; +var __ = Minimart.__; +var _$ = Minimart._$; + +function spawnRoutingTableWidget(selector, fragmentClass, observationLevel) { + observationLevel = observationLevel || 10; + // ^ arbitrary: should be Infinity, when route.js supports it. TODO + + World.spawn({ + boot: function () { this.updateState(); }, + + state: Route.emptyGestalt.serialize(), + nextState: Route.emptyGestalt.serialize(), + timer: false, + + localGestalt: (sub( ["DOM", selector, fragmentClass, __], 0, 2) + .union(pub(["DOM", selector, fragmentClass, __], 0, 2)) + .telescoped()), + + digestGestalt: function (g) { + return g.stripLabel().erasePath(this.localGestalt).serialize(); + }, + + updateState: function () { + var elts = ["pre", Route.deserializeGestalt(this.state).pretty()]; + World.updateRoutes([sub(__, 0, observationLevel), + pub(__, 0, observationLevel), + pub(["DOM", selector, fragmentClass, elts])]); + }, + + handleEvent: function (e) { + var self = this; + if (e.type === "routes") { + self.nextState = self.digestGestalt(e.gestalt); + if (self.timer) { + clearTimeout(self.timer); + self.timer = false; + } + self.timer = setTimeout(World.wrap(function () { + if (JSON.stringify(self.nextState) !== JSON.stringify(self.state)) { + self.state = self.nextState; + self.updateState(); + } + self.timer = false; + }), 50); + } + } + }); + +} + +module.exports.spawnRoutingTableWidget = spawnRoutingTableWidget; + +},{"./minimart.js":4}],7:[function(_dereq_,module,exports){ +// Generic Spy +var Minimart = _dereq_("./minimart.js"); +var World = Minimart.World; +var sub = Minimart.sub; +var pub = Minimart.pub; +var __ = Minimart.__; +var _$ = Minimart._$; + +function Spy(label, useJson, observationLevel) { + this.label = label || "SPY"; + this.observationLevel = observationLevel || 10; // arbitrary. Should be Infinity. TODO + this.useJson = useJson; +} + +Spy.prototype.boot = function () { + World.updateRoutes([sub(__, 0, this.observationLevel), pub(__, 0, this.observationLevel)]); +}; + +Spy.prototype.handleEvent = function (e) { + switch (e.type) { + case "routes": + console.log(this.label, "routes", e.gestalt.pretty()); + break; + case "message": + var messageRepr; + try { + messageRepr = this.useJson ? JSON.stringify(e.message) : e.message; + } catch (exn) { + messageRepr = e.message; + } + console.log(this.label, "message", messageRepr, e.metaLevel, e.isFeedback); + break; + default: + console.log(this.label, "unknown", e); + break; + } +}; + +module.exports.Spy = Spy; + +},{"./minimart.js":4}],8:[function(_dereq_,module,exports){ +// Wake detector - notices when something (such as +// suspension/sleeping!) has caused periodic activities to be +// interrupted, and warns others about it +// Inspired by http://blog.alexmaccaw.com/javascript-wake-event +var Minimart = _dereq_("./minimart.js"); +var World = Minimart.World; +var sub = Minimart.sub; +var pub = Minimart.pub; +var __ = Minimart.__; +var _$ = Minimart._$; + +function WakeDetector(period) { + this.message = "wake"; + this.period = period || 10000; + this.mostRecentTrigger = +(new Date()); + this.timerId = null; +} + +WakeDetector.prototype.boot = function () { + var self = this; + World.updateRoutes([pub(this.message)]); + this.timerId = setInterval(World.wrap(function () { self.trigger(); }), this.period); +}; + +WakeDetector.prototype.handleEvent = function (e) {}; + +WakeDetector.prototype.trigger = function () { + var now = +(new Date()); + if (now - this.mostRecentTrigger > this.period * 1.5) { + World.send(this.message); + } + this.mostRecentTrigger = now; +}; + +module.exports.WakeDetector = WakeDetector; + +},{"./minimart.js":4}],9:[function(_dereq_,module,exports){ +var Minimart = _dereq_("./minimart.js"); +var Route = Minimart.Route; +var World = Minimart.World; +var sub = Minimart.sub; +var pub = Minimart.pub; +var __ = Minimart.__; +var _$ = Minimart._$; + +/////////////////////////////////////////////////////////////////////////// +// WebSocket client driver + +var DEFAULT_RECONNECT_DELAY = 100; +var MAX_RECONNECT_DELAY = 30000; +var DEFAULT_IDLE_TIMEOUT = 300000; // 5 minutes +var DEFAULT_PING_INTERVAL = DEFAULT_IDLE_TIMEOUT - 10000; + +function WebSocketConnection(label, wsurl, shouldReconnect) { + this.label = label; + this.sendsAttempted = 0; + this.sendsTransmitted = 0; + this.receiveCount = 0; + this.sock = null; + this.wsurl = wsurl; + this.shouldReconnect = shouldReconnect ? true : false; + this.reconnectDelay = DEFAULT_RECONNECT_DELAY; + this.localGestalt = Route.emptyGestalt; + this.peerGestalt = Route.emptyGestalt; + this.prevLocalRoutesMessage = null; + this.prevPeerRoutesMessage = null; + this.deduplicator = new Minimart.Deduplicator(); + this.connectionCount = 0; + + this.activityTimestamp = 0; + this.idleTimeout = DEFAULT_IDLE_TIMEOUT; + this.pingInterval = DEFAULT_PING_INTERVAL; + this.idleTimer = null; + this.pingTimer = null; +} + +WebSocketConnection.prototype.clearHeartbeatTimers = function () { + if (this.idleTimer) { clearTimeout(this.idleTimer); this.idleTimer = null; } + if (this.pingTimer) { clearTimeout(this.pingTimer); this.pingTimer = null; } +}; + +WebSocketConnection.prototype.recordActivity = function () { + var self = this; + this.activityTimestamp = +(new Date()); + this.clearHeartbeatTimers(); + this.idleTimer = setTimeout(function () { self.forceclose(); }, + this.idleTimeout); + this.pingTimer = setTimeout(function () { self.safeSend(JSON.stringify("ping")) }, + this.pingInterval); +}; + +WebSocketConnection.prototype.statusRoute = function (status) { + return pub([this.label + "_state", status]); +}; + +WebSocketConnection.prototype.relayGestalt = function () { + return this.statusRoute(this.isConnected() ? "connected" : "disconnected") + .union(pub([this.label, __, __], 0, 10)) + .union(sub([this.label, __, __], 0, 10)); + // TODO: level 10 is ad-hoc; support infinity at some point in future +}; + +WebSocketConnection.prototype.aggregateGestalt = function () { + var self = this; + return this.peerGestalt.transform(function (m, metaLevel) { + return Route.compilePattern(true, + [self.label, metaLevel, Route.embeddedMatcher(m)]); + }).union(this.relayGestalt()); +}; + +WebSocketConnection.prototype.boot = function () { + this.reconnect(); +}; + +WebSocketConnection.prototype.trapexit = function () { + this.forceclose(); +}; + +WebSocketConnection.prototype.isConnected = function () { + return this.sock && this.sock.readyState === this.sock.OPEN; +}; + +WebSocketConnection.prototype.safeSend = function (m) { + try { + this.sendsAttempted++; + if (this.isConnected()) { + this.sock.send(m); + this.sendsTransmitted++; + } + } catch (e) { + console.warn("Trapped exn while sending", e); + } +}; + +WebSocketConnection.prototype.sendLocalRoutes = function () { + var newLocalRoutesMessage = + JSON.stringify(encodeEvent(Minimart.updateRoutes([this.localGestalt]))); + if (this.prevLocalRoutesMessage !== newLocalRoutesMessage) { + this.prevLocalRoutesMessage = newLocalRoutesMessage; + this.safeSend(newLocalRoutesMessage); + } +}; + +WebSocketConnection.prototype.collectMatchers = function (getAdvertisements, level, g) { + var extractMetaLevels = Route.compileProjection([this.label, _$, __]); + var mls = Route.matcherKeys(g.project(extractMetaLevels, getAdvertisements, 0, level)); + for (var i = 0; i < mls.length; i++) { + var metaLevel = mls[i][0]; // only one capture in the projection + var extractMatchers = Route.compileProjection([this.label, metaLevel, _$]); + var m = g.project(extractMatchers, getAdvertisements, 0, level); + this.localGestalt = this.localGestalt.union(Route.simpleGestalt(getAdvertisements, + Route.embeddedMatcher(m), + metaLevel, + level)); + } +}; + +WebSocketConnection.prototype.handleEvent = function (e) { + // console.log("WebSocketConnection.handleEvent", e); + switch (e.type) { + case "routes": + // TODO: GROSS - erasing by pid! + var nLevels = e.gestalt.levelCount(0); + var relayGestalt = Route.fullGestalt(1, nLevels).label(World.activePid()); + var g = e.gestalt.erasePath(relayGestalt); + this.localGestalt = Route.emptyGestalt; + for (var level = 0; level < nLevels; level++) { + this.collectMatchers(false, level, g); + this.collectMatchers(true, level, g); + } + + this.sendLocalRoutes(); + break; + case "message": + var m = e.message; + if (m.length && m.length === 3 && m[0] === this.label) + { + var encoded = JSON.stringify(encodeEvent( + Minimart.sendMessage(m[2], m[1], e.isFeedback))); + if (this.deduplicator.accept(encoded)) { + this.safeSend(encoded); + } + } + break; + } +}; + +WebSocketConnection.prototype.forceclose = function (keepReconnectDelay) { + if (!keepReconnectDelay) { + this.reconnectDelay = DEFAULT_RECONNECT_DELAY; + } + this.clearHeartbeatTimers(); + if (this.sock) { + console.log("WebSocketConnection.forceclose called"); + this.sock.close(); + this.sock = null; + } +}; + +WebSocketConnection.prototype.reconnect = function () { + var self = this; + this.forceclose(true); + this.connectionCount++; + this.sock = new WebSocket(this.wsurl); + this.sock.onopen = World.wrap(function (e) { return self.onopen(e); }); + this.sock.onmessage = World.wrap(function (e) { + self.receiveCount++; + return self.onmessage(e); + }); + this.sock.onclose = World.wrap(function (e) { return self.onclose(e); }); +}; + +WebSocketConnection.prototype.onopen = function (e) { + console.log("connected to " + this.sock.url); + this.reconnectDelay = DEFAULT_RECONNECT_DELAY; + this.prevLocalRoutesMessage = null; + this.sendLocalRoutes(); +}; + +WebSocketConnection.prototype.onmessage = function (wse) { + // console.log("onmessage", wse); + this.recordActivity(); + + var j = JSON.parse(wse.data); + if (j === "ping") { + this.safeSend(JSON.stringify("pong")); + return; + } else if (j === "pong") { + return; // recordActivity already took care of our timers + } + + var e = decodeAction(j); + switch (e.type) { + case "routes": + if (this.prevPeerRoutesMessage !== wse.data) { + this.prevPeerRoutesMessage = wse.data; + this.peerGestalt = e.gestalt; + World.updateRoutes([this.aggregateGestalt()]); + } + break; + case "message": + if (this.deduplicator.accept(wse.data)) { + World.send([this.label, e.metaLevel, e.message], 0, e.isFeedback); + } + break; + } +}; + +WebSocketConnection.prototype.onclose = function (e) { + var self = this; + console.log("onclose", e); + + // Update routes to give clients some indication of the discontinuity + World.updateRoutes([this.aggregateGestalt()]); + + if (this.shouldReconnect) { + console.log("reconnecting to " + this.wsurl + " in " + this.reconnectDelay + "ms"); + setTimeout(World.wrap(function () { self.reconnect(); }), this.reconnectDelay); + this.reconnectDelay = this.reconnectDelay * 1.618 + (Math.random() * 1000); + this.reconnectDelay = + this.reconnectDelay > MAX_RECONNECT_DELAY + ? MAX_RECONNECT_DELAY + (Math.random() * 1000) + : this.reconnectDelay; + } +}; + +/////////////////////////////////////////////////////////////////////////// +// Wire protocol representation of events and actions + +function encodeEvent(e) { + switch (e.type) { + case "routes": + return ["routes", e.gestalt.serialize(function (v) { return true; })]; + case "message": + return ["message", e.message, e.metaLevel, e.isFeedback]; + } +} + +function decodeAction(j) { + switch (j[0]) { + case "routes": + return Minimart.updateRoutes([ + Route.deserializeGestalt(j[1], function (v) { return true; })]); + case "message": + return Minimart.sendMessage(j[1], j[2], j[3]); + default: + throw { message: "Invalid JSON-encoded action: " + JSON.stringify(j) }; + } +} + +/////////////////////////////////////////////////////////////////////////// + +module.exports.WebSocketConnection = WebSocketConnection; +module.exports.encodeEvent = encodeEvent; +module.exports.decodeAction = decodeAction; + +},{"./minimart.js":4}]},{},[3]) +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/tonyg/src/js-marketplace/node_modules/browserify/node_modules/browser-pack/_prelude.js","/home/tonyg/src/js-marketplace/src/dom-driver.js","/home/tonyg/src/js-marketplace/src/jquery-driver.js","/home/tonyg/src/js-marketplace/src/main.js","/home/tonyg/src/js-marketplace/src/minimart.js","/home/tonyg/src/js-marketplace/src/route.js","/home/tonyg/src/js-marketplace/src/routing-table-widget.js","/home/tonyg/src/js-marketplace/src/spy.js","/home/tonyg/src/js-marketplace/src/wake-detector.js","/home/tonyg/src/js-marketplace/src/websocket-driver.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACz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iBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/+CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error(\"Cannot find module '\"+o+\"'\")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","// DOM fragment display driver\nvar Minimart = require(\"./minimart.js\");\nvar World = Minimart.World;\nvar sub = Minimart.sub;\nvar pub = Minimart.pub;\nvar __ = Minimart.__;\nvar _$ = Minimart._$;\n\nfunction spawnDOMDriver() {\n    var d = new Minimart.DemandMatcher([\"DOM\", _$, _$, _$]);\n    d.onDemandIncrease = function (captures) {\n\tvar selector = captures[0];\n\tvar fragmentClass = captures[1];\n\tvar fragmentSpec = captures[2];\n\tWorld.spawn(new DOMFragment(selector, fragmentClass, fragmentSpec),\n\t\t    [sub([\"DOM\", selector, fragmentClass, fragmentSpec]),\n\t\t     sub([\"DOM\", selector, fragmentClass, fragmentSpec], 0, 1)]);\n    };\n    World.spawn(d);\n}\n\nfunction DOMFragment(selector, fragmentClass, fragmentSpec) {\n    this.selector = selector;\n    this.fragmentClass = fragmentClass;\n    this.fragmentSpec = fragmentSpec;\n    this.nodes = this.buildNodes();\n}\n\nDOMFragment.prototype.boot = function () {\n    var self = this;\n    var monitoring = sub([\"DOM\", self.selector, self.fragmentClass, self.fragmentSpec], 1, 2);\n    World.spawn(new World(function () {\n\tMinimart.JQuery.spawnJQueryDriver(self.selector+\" > .\"+self.fragmentClass, 1);\n\tWorld.spawn({\n\t    handleEvent: function (e) {\n\t\tif (e.type === \"routes\") {\n\t\t    var level = e.gestalt.getLevel(1, 0); // find participant peers\n\t\t    if (!e.gestalt.isEmpty() && level.isEmpty()) {\n\t\t\tWorld.shutdownWorld();\n\t\t    }\n\t\t}\n\t    }\n\t}, [monitoring]);\n    }));\n};\n\nDOMFragment.prototype.handleEvent = function (e) {\n    if (e.type === \"routes\" && e.gestalt.isEmpty()) {\n\tfor (var i = 0; i < this.nodes.length; i++) {\n\t    var n = this.nodes[i];\n\t    n.parentNode.removeChild(n);\n\t}\n\tWorld.exit();\n    }\n};\n\nDOMFragment.prototype.interpretSpec = function (spec) {\n    // Fragment specs are roughly JSON-equivalents of SXML.\n    // spec ::== [\"tag\", {\"attr\": \"value\", ...}, spec, spec, ...]\n    //         | [\"tag\", spec, spec, ...]\n    //         | \"cdata\"\n    if (typeof(spec) === \"string\" || typeof(spec) === \"number\") {\n\treturn document.createTextNode(spec);\n    } else if ($.isArray(spec)) {\n\tvar tagName = spec[0];\n\tvar hasAttrs = $.isPlainObject(spec[1]);\n\tvar attrs = hasAttrs ? spec[1] : {};\n\tvar kidIndex = hasAttrs ? 2 : 1;\n\n\t// Wow! Such XSS! Many hacks! So vulnerability! Amaze!\n\tvar n = document.createElement(tagName);\n\tfor (var attr in attrs) {\n\t    if (attrs.hasOwnProperty(attr)) {\n\t\tn.setAttribute(attr, attrs[attr]);\n\t    }\n\t}\n\tfor (var i = kidIndex; i < spec.length; i++) {\n\t    n.appendChild(this.interpretSpec(spec[i]));\n\t}\n\treturn n;\n    }\n};\n\nDOMFragment.prototype.buildNodes = function () {\n    var self = this;\n    var nodes = [];\n    $(self.selector).each(function (index, domNode) {\n\tvar n = self.interpretSpec(self.fragmentSpec);\n\tn.classList.add(self.fragmentClass);\n\tdomNode.appendChild(n);\n\tnodes.push(n);\n    });\n    return nodes;\n};\n\n///////////////////////////////////////////////////////////////////////////\n\nmodule.exports.spawnDOMDriver = spawnDOMDriver;\n","// JQuery event driver\nvar Minimart = require(\"./minimart.js\");\nvar World = Minimart.World;\nvar sub = Minimart.sub;\nvar pub = Minimart.pub;\nvar __ = Minimart.__;\nvar _$ = Minimart._$;\n\nfunction spawnJQueryDriver(baseSelector, metaLevel) {\n    metaLevel = metaLevel || 0;\n    var d = new Minimart.DemandMatcher([\"jQuery\", _$, _$, __], metaLevel,\n\t\t\t\t       {demandSideIsSubscription: true});\n    d.onDemandIncrease = function (captures) {\n\tvar selector = captures[0];\n\tvar eventName = captures[1];\n\tWorld.spawn(new JQueryEventRouter(baseSelector, selector, eventName, metaLevel),\n\t\t    [pub([\"jQuery\", selector, eventName, __], metaLevel),\n\t\t     pub([\"jQuery\", selector, eventName, __], metaLevel, 1)]);\n    };\n    World.spawn(d);\n}\n\nfunction JQueryEventRouter(baseSelector, selector, eventName, metaLevel) {\n    var self = this;\n    this.baseSelector = baseSelector || null;\n    this.selector = selector;\n    this.eventName = eventName;\n    this.metaLevel = metaLevel || 0;\n    this.preventDefault = (this.eventName.charAt(0) !== \"+\");\n    this.handler =\n\tWorld.wrap(function (e) {\n\t    World.send([\"jQuery\", self.selector, self.eventName, e], self.metaLevel);\n\t    if (self.preventDefault) e.preventDefault();\n\t    return !self.preventDefault;\n\t});\n    this.computeNodes().on(this.preventDefault ? this.eventName : this.eventName.substring(1),\n\t\t\t   this.handler);\n}\n\nJQueryEventRouter.prototype.handleEvent = function (e) {\n    if (e.type === \"routes\" && e.gestalt.isEmpty()) {\n\tthis.computeNodes().off(this.eventName, this.handler);\n\tWorld.exit();\n    }\n};\n\nJQueryEventRouter.prototype.computeNodes = function () {\n    if (this.baseSelector) {\n\treturn $(this.baseSelector).children(this.selector).addBack(this.selector);\n    } else {\n\treturn $(this.selector);\n    }\n};\n\n///////////////////////////////////////////////////////////////////////////\n\nmodule.exports.spawnJQueryDriver = spawnJQueryDriver;\n","module.exports = require(\"./minimart.js\");\n\nmodule.exports.DOM = require(\"./dom-driver.js\");\nmodule.exports.JQuery = require(\"./jquery-driver.js\");\nmodule.exports.RoutingTableWidget = require(\"./routing-table-widget.js\");\nmodule.exports.WebSocket = require(\"./websocket-driver.js\");\n\nmodule.exports.Spy = require(\"./spy.js\").Spy;\nmodule.exports.WakeDetector = require(\"./wake-detector.js\").WakeDetector;\n","var Route = require(\"./route.js\");\n\n///////////////////////////////////////////////////////////////////////////\n\n// TODO: trigger-guards as per minimart\n\n/*---------------------------------------------------------------------------*/\n/* Events and Actions */\n\nvar __ = Route.__;\nvar _$ = Route._$;\n\nfunction sub(pattern, metaLevel, level) {\n    return Route.simpleGestalt(false, pattern, metaLevel, level);\n}\n\nfunction pub(pattern, metaLevel, level) {\n    return Route.simpleGestalt(true, pattern, metaLevel, level);\n}\n\nfunction spawn(behavior, initialGestalts) {\n    return { type: \"spawn\",\n\t     behavior: behavior,\n\t     initialGestalt: Route.gestaltUnion(initialGestalts || []) };\n}\n\nfunction updateRoutes(gestalts) {\n    return { type: \"routes\", gestalt: Route.gestaltUnion(gestalts) };\n}\n\nfunction pendingRoutingUpdate(aggregate, affectedSubgestalt, knownTarget) {\n    return { type: \"pendingRoutingUpdate\",\n\t     aggregate: aggregate,\n\t     affectedSubgestalt: affectedSubgestalt,\n\t     knownTarget: knownTarget };\n}\n\nfunction sendMessage(m, metaLevel, isFeedback) {\n    return { type: \"message\",\n\t     metaLevel: (metaLevel === undefined) ? 0 : metaLevel,\n\t     message: m,\n\t     isFeedback: (isFeedback === undefined) ? false : isFeedback };\n}\n\nfunction shutdownWorld() {\n    return { type: \"shutdownWorld\" };\n}\n\n/*---------------------------------------------------------------------------*/\n/* Configurations */\n\nfunction World(bootFn) {\n    this.alive = true;\n    this.eventQueue = [];\n    this.runnablePids = {};\n    this.partialGestalt = Route.emptyGestalt; // Only gestalt from local processes\n    this.fullGestalt = Route.emptyGestalt ;; // partialGestalt unioned with downwardGestalt\n    this.processTable = {};\n    this.tombstones = {};\n    this.downwardGestalt = Route.emptyGestalt;\n    this.processActions = [];\n    this.asChild(-1, bootFn, true);\n}\n\n/* Class state / methods */\n\nWorld.nextPid = 0;\n\nWorld.stack = [];\n\nWorld.current = function () {\n    return World.stack[World.stack.length - 1][0];\n};\n\nWorld.activePid = function () {\n    return World.stack[World.stack.length - 1][1];\n};\n\nWorld.send = function (m, metaLevel, isFeedback) {\n    World.current().enqueueAction(World.activePid(), sendMessage(m, metaLevel, isFeedback));\n};\n\nWorld.updateRoutes = function (gestalts) {\n    World.current().enqueueAction(World.activePid(), updateRoutes(gestalts));\n};\n\nWorld.spawn = function (behavior, initialGestalts) {\n    World.current().enqueueAction(World.activePid(), spawn(behavior, initialGestalts));\n};\n\nWorld.exit = function (exn) {\n    World.current().kill(World.activePid(), exn);\n};\n\nWorld.shutdownWorld = function () {\n    World.current().enqueueAction(World.activePid(), shutdownWorld());\n};\n\nWorld.withWorldStack = function (stack, f) {\n    var oldStack = World.stack;\n    World.stack = stack;\n    var result = null;\n    try {\n\tresult = f();\n    } catch (e) {\n\tWorld.stack = oldStack;\n\tthrow e;\n    }\n    World.stack = oldStack;\n    return result;\n};\n\nWorld.wrap = function (f) {\n    var savedStack = World.stack.slice();\n    return function () {\n\tvar actuals = arguments;\n\treturn World.withWorldStack(savedStack, function () {\n\t    var result = World.current().asChild(World.activePid(), function () {\n\t\treturn f.apply(null, actuals);\n\t    });\n\t    for (var i = World.stack.length - 1; i >= 0; i--) {\n\t\tWorld.stack[i][0].markPidRunnable(World.stack[i][1]);\n\t    }\n\t    return result;\n\t});\n    };\n};\n\n/* Instance methods */\n\nWorld.prototype.enqueueAction = function (pid, action) {\n    this.processActions.push([pid, action]);\n};\n\n// The code is written to maintain the runnablePids set carefully, to\n// ensure we can locally decide whether we're inert or not without\n// having to search the whole deep process tree.\nWorld.prototype.isInert = function () {\n    return this.eventQueue.length === 0\n\t&& this.processActions.length === 0\n\t&& Route.is_emptySet(this.runnablePids);\n};\n\nWorld.prototype.markPidRunnable = function (pid) {\n    this.runnablePids[pid] = [pid];\n};\n\nWorld.prototype.step = function () {\n    this.dispatchEvents();\n    this.performActions();\n    this.stepChildren();\n    return this.alive && !this.isInert();\n};\n\nWorld.prototype.asChild = function (pid, f, omitLivenessCheck) {\n    if (!(pid in this.processTable) && !omitLivenessCheck) {\n\tconsole.warn(\"World.asChild eliding invocation of dead process\", pid);\n\treturn;\n    }\n\n    World.stack.push([this, pid]);\n    var result = null;\n    try {\n\tresult = f();\n    } catch (e) {\n\tthis.kill(pid, e);\n    }\n    if (World.stack.pop()[0] !== this) {\n\tthrow new Error(\"Internal error: World stack imbalance\");\n    }\n    return result;\n};\n\nWorld.prototype.kill = function (pid, exn) {\n    if (exn && exn.stack) {\n\tconsole.log(\"Process exited\", pid, exn, exn.stack);\n    } else {\n\tconsole.log(\"Process exited\", pid, exn);\n    }\n    var p = this.processTable[pid];\n    if (p && p.behavior.trapexit) {\n\tthis.asChild(pid, function () { return p.behavior.trapexit(exn); });\n    }\n    delete this.processTable[pid];\n    if (p) {\n\tif (exn) {\n\t    p.exitReason = exn;\n\t    this.tombstones[pid] = p;\n\t}\n\tthis.applyAndIssueRoutingUpdate(p.gestalt, Route.emptyGestalt);\n    }\n};\n\nWorld.prototype.stepChildren = function () {\n    var pids = this.runnablePids;\n    this.runnablePids = {};\n    for (var pid in pids) {\n\tvar p = this.processTable[pid];\n\tif (p && p.behavior.step /* exists, haven't called it yet */) {\n\t    var childBusy = this.asChild(pid | 0, function () { return p.behavior.step() });\n\t    if (childBusy) this.markPidRunnable(pid);\n\t}\n    }\n};\n\nWorld.prototype.performActions = function () {\n    var queue = this.processActions;\n    this.processActions = [];\n    var item;\n    while ((item = queue.shift()) && this.alive) {\n\tthis.performAction(item[0], item[1]);\n    }\n};\n\nWorld.prototype.dispatchEvents = function () {\n    var queue = this.eventQueue;\n    this.eventQueue = [];\n    var item;\n    while ((item = queue.shift())) {\n\tthis.dispatchEvent(item);\n    }\n};\n\nWorld.prototype.performAction = function (pid, action) {\n    switch (action.type) {\n    case \"spawn\":\n\tvar pid = World.nextPid++;\n\tvar newGestalt = action.initialGestalt.label(pid);\n\tthis.processTable[pid] = { gestalt: newGestalt, behavior: action.behavior };\n\tif (action.behavior.boot) {\n\t    this.asChild(pid, function () { action.behavior.boot() });\n\t    this.markPidRunnable(pid);\n\t}\n\tthis.applyAndIssueRoutingUpdate(Route.emptyGestalt, newGestalt, pid);\n\tbreak;\n    case \"routes\":\n\tif (pid in this.processTable) {\n\t    // it may not be: this might be the routing update from a\n\t    // kill of the process\n\t    var oldGestalt = this.processTable[pid].gestalt;\n\t    var newGestalt = action.gestalt.label(pid|0);\n\t    // ^ pid|0: convert pid from string (table key!) to integer\n\t    this.processTable[pid].gestalt = newGestalt;\n\t    this.applyAndIssueRoutingUpdate(oldGestalt, newGestalt, pid);\n\t}\n\tbreak;\n    case \"message\":\n\tif (action.metaLevel === 0) {\n\t    this.eventQueue.push(action);\n\t} else {\n\t    World.send(action.message, action.metaLevel - 1, action.isFeedback);\n\t}\n\tbreak;\n    case \"shutdownWorld\":\n\tthis.alive = false; // force us to stop doing things immediately\n\tWorld.exit();\n\tbreak;\n    default:\n\tvar exn = new Error(\"Action type \" + action.type + \" not understood\");\n\texn.action = action;\n\tthrow exn;\n    }\n};\n\nWorld.prototype.updateFullGestalt = function () {\n    this.fullGestalt = this.partialGestalt.union(this.downwardGestalt);\n};\n\nWorld.prototype.issueLocalRoutingUpdate = function (affectedSubgestalt, knownTarget) {\n    this.eventQueue.push(pendingRoutingUpdate(this.fullGestalt,\n\t\t\t\t\t      affectedSubgestalt,\n\t\t\t\t\t      knownTarget));\n};\n\nWorld.prototype.applyAndIssueRoutingUpdate = function (oldg, newg, knownTarget) {\n    knownTarget = typeof knownTarget === 'undefined' ? null : knownTarget;\n    this.partialGestalt = this.partialGestalt.erasePath(oldg).union(newg);\n    this.updateFullGestalt();\n    this.issueLocalRoutingUpdate(oldg.union(newg), knownTarget);\n    World.updateRoutes([this.partialGestalt.drop()]);\n};\n\nWorld.prototype.dispatchEvent = function (e) {\n    switch (e.type) {\n    case \"pendingRoutingUpdate\":\n\tvar pids = e.affectedSubgestalt.match(e.aggregate);\n\tif (e.knownTarget !== null) pids.unshift(e.knownTarget);\n\tfor (var i = 0; i < pids.length; i++) {\n\t    var pid = pids[i];\n\t    if (pid === \"out\") console.warn(\"Would have delivered a routing update to environment\");\n\t    var p = this.processTable[pid];\n\t    if (p) {\n\t\tvar g = e.aggregate.filter(p.gestalt);\n\t\tthis.asChild(pid, function () { p.behavior.handleEvent(updateRoutes([g])) });\n\t\tthis.markPidRunnable(pid);\n\t    }\n\t}\n\tbreak;\n\n    case \"message\":\n\tvar pids = this.partialGestalt.matchValue(e.message, e.metaLevel, e.isFeedback);\n\tfor (var i = 0; i < pids.length; i++) {\n\t    var pid = pids[i];\n\t    var p = this.processTable[pid];\n\t    this.asChild(pid, function () { p.behavior.handleEvent(e) });\n\t    this.markPidRunnable(pid);\n\t}\n\tbreak;\n\n    default:\n\tvar exn = new Error(\"Event type \" + e.type + \" not dispatchable\");\n\texn.event = e;\n\tthrow exn;\n    }\n};\n\nWorld.prototype.handleEvent = function (e) {\n    switch (e.type) {\n    case \"routes\":\n\tvar oldDownward = this.downwardGestalt;\n\tthis.downwardGestalt = e.gestalt.label(\"out\").lift();\n\tthis.updateFullGestalt();\n\tthis.issueLocalRoutingUpdate(oldDownward.union(this.downwardGestalt), null);\n\tbreak;\n    case \"message\":\n\tthis.eventQueue.push(sendMessage(e.message, e.metaLevel + 1, e.isFeedback));\n\tbreak;\n    default:\n\tvar exn = new Error(\"Event type \" + e.type + \" not understood\");\n\texn.event = e;\n\tthrow exn;\n    }\n};\n\n/* Debugging, management, and monitoring */\n\nWorld.prototype.processTree = function () {\n    var kids = [];\n    for (var pid in this.processTable) {\n\tvar p = this.processTable[pid];\n\tif (p.behavior instanceof World) {\n\t    kids.push([pid, p.behavior.processTree()]);\n\t} else {\n\t    kids.push([pid, p]);\n\t}\n    }\n    for (var pid in this.tombstones) {\n\tkids.push([pid, this.tombstones[pid]]);\n    }\n    kids.sort();\n    return kids;\n};\n\nWorld.prototype.textProcessTree = function (ownPid) {\n    var lines = [];\n\n    function dumpProcess(prefix, pid, p) {\n\tif (p instanceof Array) {\n\t    lines.push(prefix + '--+ ' + pid);\n\t    for (var i = 0; i < p.length; i++) {\n\t\tdumpProcess(prefix + '  |', p[i][0], p[i][1]);\n\t    }\n\t    lines.push(prefix);\n\t} else {\n\t    var label = p.behavior.name || p.behavior.constructor.name || '';\n\t    var tombstoneString = p.exitReason ? ' (EXITED: ' + p.exitReason + ') ' : '';\n\t    lines.push(prefix + '-- ' + pid + ': ' + label +\n\t\t       tombstoneString +\n\t\t       JSON.stringify(p.behavior, function (k, v) {\n\t\t\t   return k === 'name' ? undefined : v;\n\t\t       }));\n\t}\n    }\n\n    dumpProcess('', ownPid || '', this.processTree());\n    return lines.join('\\n');\n};\n\nWorld.prototype.clearTombstones = function () {\n    this.tombstones = {};\n    for (var pid in this.processTable) {\n\tvar p = this.processTable[pid];\n\tif (p.behavior instanceof World) {\n\t    p.behavior.clearTombstones();\n\t}\n    }\n};\n\n/*---------------------------------------------------------------------------*/\n/* Utilities: matching demand for some service */\n\nfunction DemandMatcher(projection, metaLevel, options) {\n    options = $.extend({\n\tdemandLevel: 0,\n\tsupplyLevel: 0,\n\tdemandSideIsSubscription: false\n    }, options);\n    this.pattern = Route.projectionToPattern(projection);\n    this.projectionSpec = Route.compileProjection(projection);\n    this.metaLevel = metaLevel | 0;\n    this.demandLevel = options.demandLevel;\n    this.supplyLevel = options.supplyLevel;\n    this.demandSideIsSubscription = options.demandSideIsSubscription;\n    this.onDemandIncrease = function (captures) {\n\tconsole.error(\"Unhandled increase in demand for route\", captures);\n    };\n    this.onSupplyDecrease = function (captures) {\n\tconsole.error(\"Unhandled decrease in supply for route\", captures);\n    };\n    this.currentDemand = {};\n    this.currentSupply = {};\n}\n\nDemandMatcher.prototype.boot = function () {\n    var observerLevel = 1 + Math.max(this.demandLevel, this.supplyLevel);\n    World.updateRoutes([sub(this.pattern, this.metaLevel, observerLevel),\n\t\t\tpub(this.pattern, this.metaLevel, observerLevel)]);\n};\n\nDemandMatcher.prototype.handleEvent = function (e) {\n    if (e.type === \"routes\") {\n\tthis.handleGestalt(e.gestalt);\n    }\n};\n\nDemandMatcher.prototype.handleGestalt = function (gestalt) {\n    var newDemandMatcher = gestalt.project(this.projectionSpec,\n\t\t\t\t\t   !this.demandSideIsSubscription,\n\t\t\t\t\t   this.metaLevel,\n\t\t\t\t\t   this.demandLevel);\n    var newSupplyMatcher = gestalt.project(this.projectionSpec,\n\t\t\t\t\t   this.demandSideIsSubscription,\n\t\t\t\t\t   this.metaLevel,\n\t\t\t\t\t   this.supplyLevel);\n    var newDemand = Route.arrayToSet(Route.matcherKeys(newDemandMatcher));\n    var newSupply = Route.arrayToSet(Route.matcherKeys(newSupplyMatcher));\n    var demandDelta = Route.setSubtract(newDemand, this.currentDemand);\n    var supplyDelta = Route.setSubtract(this.currentSupply, newSupply);\n    var demandIncr = Route.setSubtract(demandDelta, newSupply);\n    var supplyDecr = Route.setIntersect(supplyDelta, newDemand);\n    this.currentDemand = newDemand;\n    this.currentSupply = newSupply;\n    for (var k in demandIncr) this.onDemandIncrease(demandIncr[k]);\n    for (var k in supplyDecr) this.onSupplyDecrease(supplyDecr[k]);\n};\n\n/*---------------------------------------------------------------------------*/\n/* Utilities: deduplicator */\n\nfunction Deduplicator(ttl_ms) {\n    this.ttl_ms = ttl_ms || 10000;\n    this.queue = [];\n    this.map = {};\n    this.timerId = null;\n}\n\nDeduplicator.prototype.accept = function (m) {\n    var s = JSON.stringify(m);\n    if (s in this.map) return false;\n    var entry = [(+new Date()) + this.ttl_ms, s, m];\n    this.map[s] = entry;\n    this.queue.push(entry);\n\n    if (this.timerId === null) {\n\tvar self = this;\n\tthis.timerId = setInterval(function () { self.expireMessages(); },\n\t\t\t\t   this.ttl_ms > 1000 ? 1000 : this.ttl_ms);\n    }\n    return true;\n};\n\nDeduplicator.prototype.expireMessages = function () {\n    var now = +new Date();\n    while (this.queue.length > 0 && this.queue[0][0] <= now) {\n\tvar entry = this.queue.shift();\n\tdelete this.map[entry[1]];\n    }\n    if (this.queue.length === 0) {\n\tclearInterval(this.timerId);\n\tthis.timerId = null;\n    }\n};\n\n/*---------------------------------------------------------------------------*/\n/* Ground interface */\n\nfunction Ground(bootFn) {\n    var self = this;\n    this.stepperId = null;\n    World.withWorldStack([[this, -1]], function () {\n\tself.world = new World(bootFn);\n    });\n}\n\nGround.prototype.step = function () {\n    var self = this;\n    return World.withWorldStack([[this, -1]], function () {\n\treturn self.world.step();\n    });\n};\n\nGround.prototype.checkPid = function (pid) {\n    if (pid !== -1) console.error(\"Weird pid in Ground markPidRunnable\", pid);\n};    \n\nGround.prototype.markPidRunnable = function (pid) {\n    this.checkPid(pid);\n    this.startStepping();\n};\n\nGround.prototype.startStepping = function () {\n    var self = this;\n    if (this.stepperId) return;\n    if (this.step()) {\n\tthis.stepperId = setTimeout(function () {\n\t    self.stepperId = null;\n\t    self.startStepping();\n\t}, 0);\n    }\n};\n\nGround.prototype.stopStepping = function () {\n    if (this.stepperId) {\n\tclearTimeout(this.stepperId);\n\tthis.stepperId = null;\n    }\n};\n\nGround.prototype.enqueueAction = function (pid, action) {\n    this.checkPid(pid);\n    if (action.type === 'routes') {\n\tif (!action.gestalt.isEmpty()) {\n\t    console.error(\"You have subscribed to a nonexistent event source.\",\n\t\t\t  action.gestalt.pretty());\n\t}\n    } else {\n\tconsole.error(\"You have sent a message into the outer void.\", action);\n    }\n};\n\n///////////////////////////////////////////////////////////////////////////\n\nmodule.exports.__ = __;\nmodule.exports._$ = _$;\n\nmodule.exports.sub = sub;\nmodule.exports.pub = pub;\nmodule.exports.spawn = spawn;\nmodule.exports.updateRoutes = updateRoutes;\nmodule.exports.sendMessage = sendMessage;\nmodule.exports.shutdownWorld = shutdownWorld;\n\nmodule.exports.World = World;\nmodule.exports.DemandMatcher = DemandMatcher;\nmodule.exports.Deduplicator = Deduplicator;\nmodule.exports.Ground = Ground;\nmodule.exports.Route = Route;\n","var __ = \"__\"; /* wildcard marker */\n\nvar SOA = \"__[\"; // start of array\nvar EOA = \"__]\"; // end of array\n\nfunction die(message) {\n    throw new Error(message);\n}\n\nfunction $Embedded(matcher) {\n    this.matcher = matcher;\n}\n\nfunction embeddedMatcher(matcher) {\n    return new $Embedded(matcher);\n}\n\n// The pattern argument defaults to wildcard, __.\nfunction $Capture(pattern) {\n    this.pattern = (typeof pattern === 'undefined' ? __ : pattern);\n}\n\n// Abbreviation: _$(x) <==> new $Capture(x)\nfunction _$(pattern) {\n    return new $Capture(pattern);\n}\n\nfunction isCapture(x) { return x instanceof $Capture || x === _$; }\nfunction capturePattern(x) { return x instanceof $Capture ? x.pattern : __; }\n\nvar SOC = \"__{{\"; // start of capture\nvar EOC = \"__}}\"; // end of capture\n\nfunction $Success(value) {\n    this.value = value;\n}\n\nfunction $WildcardSequence(matcher) {\n    this.matcher = matcher;\n}\n\nfunction $Dict() {\n    this.length = 0;\n    this.entries = {};\n}\n\n$Dict.prototype.get = function (key) {\n    return this.entries[key] || emptyMatcher;\n};\n\n$Dict.prototype.set = function (key, val) {\n    if (!(key in this.entries)) this.length++;\n    this.entries[key] = val;\n};\n\n$Dict.prototype.clear = function (key) {\n    if (key in this.entries) this.length--;\n    delete this.entries[key];\n};\n\n$Dict.prototype.isEmpty = function () {\n    return this.length === 0;\n};\n\n$Dict.prototype.copy = function () {\n    var other = new $Dict();\n    other.length = this.length;\n    for (var key in this.entries) {\n\tif (this.entries.hasOwnProperty(key)) {\n\t    other.entries[key] = this.entries[key];\n\t}\n    }\n    return other;\n};\n\n$Dict.prototype.emptyGuard = function () {\n    if (this.isEmpty()) return emptyMatcher;\n    return this;\n};\n\n$Dict.prototype.has = function (key) {\n    return key in this.entries;\n};\n\n$Dict.prototype.sortedKeys = function () {\n    var ks = [];\n    for (var k in this.entries) ks.push(k);\n    ks.sort();\n    return ks;\n}\n\nfunction is_emptyMatcher(m) {\n    return (m === emptyMatcher);\n}\n\n///////////////////////////////////////////////////////////////////////////\n// Constructors\n\nvar emptyMatcher = null;\n\nfunction rsuccess(v) {\n    return (v === emptyMatcher) ? emptyMatcher : new $Success(v);\n}\n\nfunction rseq(e, r) {\n    if (r === emptyMatcher) return emptyMatcher;\n    var s = new $Dict();\n    s.set(e, r);\n    return s;\n}\n\nfunction rwild(r) {\n    return rseq(__, r);\n}\n\nfunction rwildseq(r) {\n    return (r === emptyMatcher) ? emptyMatcher : new $WildcardSequence(r);\n}\n\n///////////////////////////////////////////////////////////////////////////\n\nfunction compilePattern(v, p) {\n    if (!p) die(\"compilePattern: missing pattern\");\n    return walk(p, rseq(EOA, rsuccess(v)));\n\n    function walk(p, acc) {\n\tif (p === __) return rwild(acc);\n\n\tif (Array.isArray(p)) {\n\t    acc = rseq(EOA, acc);\n\t    for (var i = p.length - 1; i >= 0; i--) {\n\t\tacc = walk(p[i], acc);\n\t    }\n\t    return rseq(SOA, acc);\n\t}\n\n\tif (p instanceof $Embedded) {\n\t    return appendMatcher(p.matcher, function (v) { return acc; });\n\t} else {\n\t    return rseq(JSON.stringify(p), acc);\n\t}\n    }\n}\n\nfunction shallowCopyArray(s) {\n    return s.slice();\n}\n\nfunction rupdateInplace(r, key, k) {\n    if (is_emptyMatcher(k)) {\n\tr.clear(key);\n    } else {\n\tr.set(key, k);\n    }\n}\n\nfunction matcherEquals(a, b) {\n    if (a === null) {\n\treturn (b === null);\n    }\n    if (b === null) return false;\n\n    if (a instanceof $WildcardSequence) {\n\tif (!(b instanceof $WildcardSequence)) return false;\n\ta = a.matcher;\n\tb = b.matcher;\n    } else if (b instanceof $WildcardSequence) return false;\n\n    if (a instanceof $Success) {\n\tif (!(b instanceof $Success)) return false;\n\treturn valuesEqual(a.value, b.value);\n    }\n    if (b instanceof $Success) return false;\n\n    for (var key in a.entries) {\n\tif (!b.has(key)) return false;\n\tif (!matcherEquals(a.entries[key], b.entries[key])) return false;\n    }\n    return true;\n}\n\nfunction is_keyOpen(k) {\n    return k === SOA;\n}\n\nfunction is_keyClose(k) {\n    return k === EOA;\n}\n\nfunction is_keyNormal(k) {\n    return !(is_keyOpen(k) || is_keyClose(k));\n}\n\n///////////////////////////////////////////////////////////////////////////\n// Enough of sets to get by with\n\nfunction arrayToSet(xs) {\n    var s = {};\n    for (var i = 0; i < xs.length; i++) {\n\ts[JSON.stringify(xs[i])] = xs[i];\n    }\n    return s;\n}\n\nfunction setToArray(s) {\n    var r = [];\n    for (var k in s) r.push(s[k]);\n    return r;\n}\n\nfunction setUnion(s1, s2) {\n    var s = {};\n    setUnionInplace(s, s1);\n    setUnionInplace(s, s2);\n    return s;\n}\n\nfunction is_emptySet(s) {\n    for (var k in s) {\n\tif (s.hasOwnProperty(k))\n\t    return false;\n    }\n    return true;\n}\n\nfunction setSubtract(s1, s2) {\n    var s = {};\n    for (var key in s1) {\n\tif (s1.hasOwnProperty(key) && !s2.hasOwnProperty(key)) {\n\t    s[key] = s1[key];\n\t}\n    }\n    return s;\n}\n\nfunction setIntersect(s1, s2) {\n    var s = {};\n    for (var key in s1) {\n\tif (s1.hasOwnProperty(key) && s2.hasOwnProperty(key)) {\n\t    s[key] = s1[key];\n\t}\n    }\n    return s;\n}\n\nfunction setUnionInplace(acc, s) {\n    for (var key in s) {\n\tif (s.hasOwnProperty(key)) {\n\t    acc[key] = s[key];\n\t}\n    }\n}\n\nfunction setEqual(s1, s2) {\n    for (var key in s1) {\n\tif (s1.hasOwnProperty(key)) {\n\t    if (s1[key] !== s2[key]) return false;\n\t}\n    }\n    for (var key in s2) {\n\tif (s2.hasOwnProperty(key)) {\n\t    if (s1[key] !== s2[key]) return false;\n\t}\n    }\n    return true;\n}\n\n///////////////////////////////////////////////////////////////////////////\n\nvar unionSuccesses = function (v1, v2) {\n    if (v1 === true) return v2;\n    if (v2 === true) return v1;\n    return setUnion(v1, v2);\n};\n\nvar intersectSuccesses = function (v1, v2) {\n    return v1;\n};\n\nvar erasePathSuccesses = function (v1, v2) {\n    var r = setSubtract(v1, v2);\n    if (is_emptySet(r)) return null;\n    return r;\n};\n\nvar matchMatcherSuccesses = function (v1, v2, acc) {\n    setUnionInplace(acc, v2);\n};\n\nvar projectSuccess = function (v) {\n    return v;\n};\n\nvar valuesEqual = function (a, b) {\n    return setEqual(a, b);\n};\n\n///////////////////////////////////////////////////////////////////////////\n\nfunction expandWildseq(r) {\n    return union(rwild(rwildseq(r)), rseq(EOA, r));\n}\n\nfunction union(o1, o2) {\n    return merge(o1, o2);\n\n    function merge(o1, o2) {\n\tif (is_emptyMatcher(o1)) return o2;\n\tif (is_emptyMatcher(o2)) return o1;\n\treturn walk(o1, o2);\n    }\n\n    function walk(r1, r2) {\n\tif (r1 instanceof $WildcardSequence) {\n\t    if (r2 instanceof $WildcardSequence) {\n\t\treturn rwildseq(walk(r1.matcher, r2.matcher));\n\t    }\n\t    r1 = expandWildseq(r1.matcher);\n\t} else if (r2 instanceof $WildcardSequence) {\n\t    r2 = expandWildseq(r2.matcher);\n\t}\n\n\tif (r1 instanceof $Success && r2 instanceof $Success) {\n\t    return rsuccess(unionSuccesses(r1.value, r2.value));\n\t}\n\n\tvar w = merge(r1.get(__), r2.get(__));\n\tif (is_emptyMatcher(w)) {\n\t    var smaller = r1.length < r2.length ? r1 : r2;\n\t    var larger  = r1.length < r2.length ? r2 : r1;\n\t    var target = larger.copy();\n\t    for (var key in smaller.entries) {\n\t\tvar k = merge(smaller.get(key), larger.get(key));\n\t\trupdateInplace(target, key, k);\n\t    }\n\t    return target.emptyGuard();\n\t} else {\n\t    function examineKey(rA, key, rB) {\n\t\tif ((key !== __) && !target.has(key)) {\n\t\t    var k = merge(rA.get(key), rB.get(key));\n\t\t    if (is_keyOpen(key)) {\n\t\t\trupdateInplace(target, key, merge(rwildseq(w), k));\n\t\t    } else if (is_keyClose(key)) {\n\t\t\tif (w instanceof $WildcardSequence) {\n\t\t\t    rupdateInplace(target, key, merge(w.matcher, k));\n\t\t\t} else {\n\t\t\t    rupdateInplace(target, key, k);\n\t\t\t}\n\t\t    } else {\n\t\t\trupdateInplace(target, key, merge(w, k));\n\t\t    }\n\t\t}\n\t    }\n\t    var target = rwild(w).copy();\n\t    for (var key in r1.entries) { examineKey(r1, key, r2); }\n\t    for (var key in r2.entries) { examineKey(r2, key, r1); }\n\t    return target;\n\t}\n    }\n}\n\nfunction unionN() {\n    var acc = emptyMatcher;\n    for (var i = 0; i < arguments.length; i++) {\n\tacc = union(acc, arguments[i]);\n    }\n    return acc;\n}\n\nfunction intersect(o1, o2) {\n    if (is_emptyMatcher(o1)) return emptyMatcher;\n    if (is_emptyMatcher(o2)) return emptyMatcher;\n    return walk(o1, o2);\n\n    function walkFlipped(r2, r1) { return walk(r1, r2); }\n\n    function walk(r1, r2) {\n\t// INVARIANT: r1 is a part of the original o1, and\n\t// likewise for r2. This is so that the first arg to\n\t// intersectSuccesses always comes from r1, and the second\n\t// from r2.\n\tif (is_emptyMatcher(r1)) return emptyMatcher;\n\tif (is_emptyMatcher(r2)) return emptyMatcher;\n\n\tif (r1 instanceof $WildcardSequence) {\n\t    if (r2 instanceof $WildcardSequence) {\n\t\treturn rwildseq(walk(r1.matcher, r2.matcher));\n\t    }\n\t    r1 = expandWildseq(r1.matcher);\n\t} else if (r2 instanceof $WildcardSequence) {\n\t    r2 = expandWildseq(r2.matcher);\n\t}\n\n\tif (r1 instanceof $Success && r2 instanceof $Success) {\n\t    return rsuccess(intersectSuccesses(r1.value, r2.value));\n\t}\n\n\tvar w1 = r1.get(__);\n\tvar w2 = r2.get(__);\n\tvar w = walk(w1, w2);\n\n\tvar target = new $Dict();\n\n\tfunction examineKey(key) {\n\t    if ((key !== __) && !target.has(key)) {\n\t\tvar k1 = r1.get(key);\n\t\tvar k2 = r2.get(key);\n\t\tif (is_emptyMatcher(k1)) {\n\t\t    if (is_emptyMatcher(k2)) {\n\t\t\trupdateInplace(target, key, emptyMatcher);\n\t\t    } else {\n\t\t\trupdateInplace(target, key, walkWild(walk, w1, key, k2));\n\t\t    }\n\t\t} else {\n\t\t    if (is_emptyMatcher(k2)) {\n\t\t\trupdateInplace(target, key, walkWild(walkFlipped, w2, key, k1));\n\t\t    } else {\n\t\t\trupdateInplace(target, key, walk(k1, k2));\n\t\t    }\n\t\t}\n\t    }\n\t}\n\n\tif (is_emptyMatcher(w1)) {\n\t    if (is_emptyMatcher(w2)) {\n\t\tfor (var key in (r1.length < r2.length ? r1 : r2).entries) examineKey(key);\n\t    } else {\n\t\tfor (var key in r1.entries) examineKey(key);\n\t    }\n\t} else {\n\t    if (is_emptyMatcher(w2)) {\n\t\tfor (var key in r2.entries) examineKey(key);\n\t    } else {\n\t\trupdateInplace(target, __, w);\n\t\tfor (var key in r1.entries) examineKey(key);\n\t\tfor (var key in r2.entries) examineKey(key);\n\t    }\n\t}\n\treturn target.emptyGuard();\n    }\n\n    function walkWild(walker, w, key, k) {\n\tif (is_emptyMatcher(w)) return emptyMatcher;\n\tif (is_keyOpen(key)) return walker(rwildseq(w), k);\n\tif (is_keyClose(key)) {\n\t    if (w instanceof $WildcardSequence) return walker(w.matcher, k);\n\t    return emptyMatcher;\n\t}\n\treturn walker(w, k);\n    }\n}\n\n// Removes r2's mappings from r1. Assumes r2 has previously been\n// union'd into r1. The erasePathSuccesses function should return\n// null to signal \"no remaining success values\".\nfunction erasePath(o1, o2) {\n    return walk(o1, o2);\n\n    function walk(r1, r2) {\n\tif (is_emptyMatcher(r1)) {\n\t    return emptyMatcher;\n\t} else {\n\t    if (is_emptyMatcher(r2)) {\n\t\treturn r1;\n\t    }\n\t}\n\n\tif (r1 instanceof $WildcardSequence) {\n\t    if (r2 instanceof $WildcardSequence) {\n\t\treturn rwildseq(walk(r1.matcher, r2.matcher));\n\t    }\n\t    r1 = expandWildseq(r1.matcher);\n\t} else if (r2 instanceof $WildcardSequence) {\n\t    r2 = expandWildseq(r2.matcher);\n\t}\n\n\tif (r1 instanceof $Success && r2 instanceof $Success) {\n\t    return rsuccess(erasePathSuccesses(r1.value, r2.value));\n\t}\n\n\tvar w1 = r1.get(__);\n\tvar w2 = r2.get(__);\n\tvar w = walk(w1, w2);\n\tvar target;\n\n\tfunction examineKey(key) {\n\t    if (key !== __) {\n\t\tvar k1 = r1.get(key);\n\t\tvar k2 = r2.get(key);\n\t\tvar updatedK;\n\t\tif (is_emptyMatcher(k2)) {\n\t\t    updatedK = walkWild(key, k1, w2);\n\t\t} else {\n\t\t    updatedK = walk(k1, k2);\n\t\t}\n\t\t// Here we ensure a \"minimal\" remainder in cases\n\t\t// where after an erasure, a particular key's\n\t\t// continuation is the same as the wildcard's\n\t\t// continuation. TODO: the matcherEquals check may\n\t\t// be expensive. If so, how can it be made\n\t\t// cheaper?\n\t\tif (is_keyOpen(key)) {\n\t\t    rupdateInplace(target, key,\n\t\t\t\t   ((updatedK instanceof $WildcardSequence) &&\n\t\t\t\t    matcherEquals(updatedK.matcher, w))\n\t\t\t\t   ? emptyMatcher\n\t\t\t\t   : updatedK);\n\t\t} else if (is_keyClose(key)) {\n\t\t    // We take care of this case later, after the\n\t\t    // target is fully constructed/rebuilt.\n\t\t    rupdateInplace(target, key, updatedK);\n\t\t} else {\n\t\t    rupdateInplace(target, key,\n\t\t\t\t   (matcherEquals(updatedK, w) ? emptyMatcher : updatedK));\n\t\t}\n\t    }\n\t}\n\n\tif (is_emptyMatcher(w2)) {\n\t    target = r1.copy();\n\t    for (var key in r2.entries) examineKey(key);\n\t} else {\n\t    target = new $Dict();\n\t    rupdateInplace(target, __, w);\n\t    for (var key in r1.entries) examineKey(key);\n\t    for (var key in r2.entries) examineKey(key);\n\t}\n\n\t// Here, the target is complete. If it has only two keys,\n\t// one wild and one is_keyClose, and wild's continuation\n\t// is a $WildcardSequence and the other continuation is\n\t// identical to the sequence's continuation, then replace\n\t// the whole thing with a nested $WildcardSequence.\n\t// (We know w === target.get(__) from before.)\n\t//\n\t// TODO: I suspect actually this applies even if there are\n\t// more than two keys, so long as all their continuations\n\t// are identical and there's at least one is_keyClose\n\t// alongside a wild.\n\tif (target.length === 2) {\n\t    var finalW = target.get(__);\n\t    if (finalW instanceof $WildcardSequence) {\n\t\tfor (var key in target.entries) {\n\t\t    if ((key !== __) && is_keyClose(key)) {\n\t\t\tvar k = target.get(key);\n\t\t\tif (matcherEquals(k, finalW.matcher)) {\n\t\t\t    return finalW;\n\t\t\t}\n\t\t    }\n\t\t}\n\t    }\n\t}\n\n\treturn target.emptyGuard();\n    }\n\n    function walkWild(key, k, w) {\n\tif (is_emptyMatcher(w)) return k;\n\tif (is_keyOpen(key)) return walk(k, rwildseq(w));\n\tif (is_keyClose(key)) {\n\t    if (w instanceof $WildcardSequence) return walk(k, w.matcher);\n\t    return k;\n\t}\n\treturn walk(k, w);\n    }\n}\n\n// Returns null on failed match, otherwise the appropriate success\n// value contained in the matcher r.\nfunction matchValue(r, v) {\n    var failureResult = null;\n\n    var vs = [v];\n    var stack = [[]];\n\n    while (!is_emptyMatcher(r)) {\n\tif (r instanceof $WildcardSequence) {\n\t    if (stack.length === 0) return failureResult;\n\t    vs = stack.pop();\n\t    r = r.matcher;\n\t    continue;\n\t}\n\n\tif (r instanceof $Success) {\n\t    if (vs.length === 0 && stack.length === 0) return r.value;\n\t    return failureResult;\n\t}\n\n\tif (vs.length === 0) {\n\t    if (stack.length === 0) return failureResult;\n\t    vs = stack.pop();\n\t    r = r.get(EOA);\n\t    continue;\n\t}\n\n\tvar v = vs.shift();\n\n\tif (typeof v === 'string' && v.substring(0, 2) === '__') {\n\t    die(\"Cannot match special string starting with __\");\n\t}\n\n\tif (Array.isArray(v)) {\n\t    if (SOA in r.entries) {\n\t\tr = r.get(SOA);\n\t\tstack.push(vs);\n\t\tvs = shallowCopyArray(v);\n\t    } else {\n\t\tr = r.get(__);\n\t    }\n\t} else {\n\t    var key;\n\t    try {\n\t\tkey = JSON.stringify(v);\n\t    } catch (exn) {\n\t\t// For example, v might be cyclic, as in DOM events.\n\t\tkey = null;\n\t    }\n\t    if (key in r.entries) {\n\t\tr = r.get(key);\n\t    } else {\n\t\tr = r.get(__);\n\t    }\n\t}\n    }\n\n    return failureResult;\n}\n\n// TODO: better name for this\nfunction matchMatcher(o1, o2, seed) {\n    var acc = typeof seed === 'undefined' ? {} : seed; // will be modified in place\n    walk(o1, o2);\n    return acc;\n\n    function walkFlipped(r2, r1) { return walk(r1, r2); }\n\n    function walk(r1, r2) {\n\tif (is_emptyMatcher(r1) || is_emptyMatcher(r2)) return;\n\n\tif (r1 instanceof $WildcardSequence) {\n\t    if (r2 instanceof $WildcardSequence) {\n\t\twalk(r1.matcher, r2.matcher);\n\t\treturn;\n\t    }\n\t    r1 = expandWildseq(r1.matcher);\n\t} else if (r2 instanceof $WildcardSequence) {\n\t    r2 = expandWildseq(r2.matcher);\n\t}\n\n\tif (r1 instanceof $Success && r2 instanceof $Success) {\n\t    matchMatcherSuccesses(r1.value, r2.value, acc);\n\t    return;\n\t}\n\n\tvar w1 = r1.get(__);\n\tvar w2 = r2.get(__);\n\twalk(w1, w2);\n\n\tfunction examineKey(key) {\n\t    if (key !== __) {\n\t\tvar k1 = r1.get(key);\n\t\tvar k2 = r2.get(key);\n\t\tif (is_emptyMatcher(k1)) {\n\t\t    if (is_emptyMatcher(k2)) {\n\t\t\treturn;\n\t\t    } else {\n\t\t\twalkWild(walk, w1, key, k2);\n\t\t    }\n\t\t} else {\n\t\t    if (is_emptyMatcher(k2)) {\n\t\t\twalkWild(walkFlipped, w2, key, k1);\n\t\t    } else {\n\t\t\twalk(k1, k2);\n\t\t    }\n\t\t}\n\t    }\n\t}\n\n\t// Optimize similarly to intersect().\n\tif (is_emptyMatcher(w1)) {\n\t    if (is_emptyMatcher(w2)) {\n\t\tfor (var key in (r1.length < r2.length ? r1 : r2).entries) examineKey(key);\n\t    } else {\n\t\tfor (var key in r1.entries) examineKey(key);\n\t    }\n\t} else {\n\t    if (is_emptyMatcher(w2)) {\n\t\tfor (var key in r2.entries) examineKey(key);\n\t    } else {\n\t\tfor (var key in r1.entries) examineKey(key);\n\t\tfor (var key in r2.entries) examineKey(key);\n\t    }\n\t}\n    }\n\n    function walkWild(walker, w, key, k) {\n\tif (is_emptyMatcher(w)) return;\n\tif (is_keyOpen(key)) {\n\t    walker(rwildseq(w), k);\n\t    return;\n\t}\n\tif (is_keyClose(key)) {\n\t    if (w instanceof $WildcardSequence) walker(w.matcher, k);\n\t    return;\n\t}\n\twalker(w, k);\n    }\n}\n\nfunction appendMatcher(m, mTailFn) {\n    return walk(m);\n\n    function walk(m) {\n\tif (is_emptyMatcher(m)) return emptyMatcher;\n\tif (m instanceof $WildcardSequence) return rwildseq(walk(m.matcher));\n\tif (m instanceof $Success) die(\"Ill-formed matcher\");\n\n\tvar target = new $Dict();\n\tfor (var key in m.entries) {\n\t    var k = m.get(key);\n\t    if (is_keyClose(key) && (k instanceof $Success)) {\n\t\ttarget = union(target, mTailFn(k.value));\n\t    } else {\n\t\trupdateInplace(target, key, walk(k));\n\t    }\n\t}\n\treturn target.emptyGuard();\n    }\n}\n\nfunction relabel(m, f) {\n    return walk(m);\n\n    function walk(m) {\n\tif (is_emptyMatcher(m)) return emptyMatcher;\n\tif (m instanceof $WildcardSequence) return rwildseq(walk(m.matcher));\n\tif (m instanceof $Success) return rsuccess(f(m.value));\n\n\tvar target = new $Dict();\n\tfor (var key in m.entries) {\n\t    rupdateInplace(target, key, walk(m.get(key)));\n\t}\n\treturn target.emptyGuard();\n    }\n}\n\nfunction compileProjection(/* projection, projection, ... */) {\n    var acc = [];\n    for (var i = 0; i < arguments.length; i++) {\n\twalk(arguments[i]);\n    }\n    acc.push(EOA);\n    return acc;\n\n    function walk(p) {\n\tif (isCapture(p)) {\n\t    acc.push(SOC);\n\t    walk(capturePattern(p));\n\t    acc.push(EOC);\n\t    return;\n\t}\n\n\tif (Array.isArray(p)) {\n\t    acc.push(SOA);\n\t    for (var i = 0; i < p.length; i++) {\n\t\twalk(p[i]);\n\t    }\n\t    acc.push(EOA);\n\t    return;\n\t}\n\n\tif (p instanceof $Embedded) {\n\t    die(\"Cannot embed matcher in projection\");\n\t} else {\n\t    if (p === __) {\n\t\tacc.push(p);\n\t    } else {\n\t\tacc.push(JSON.stringify(p));\n\t    }\n\t}\n    }\n}\n\nfunction projectionToPattern(p) {\n    return walk(p);\n\n    function walk(p) {\n\tif (isCapture(p)) return walk(capturePattern(p));\n\n\tif (Array.isArray(p)) {\n\t    var result = [];\n\t    for (var i = 0; i < p.length; i++) {\n\t\tresult.push(walk(p[i]));\n\t    }\n\t    return result;\n\t}\n\n\tif (p instanceof $Embedded) {\n\t    return p.matcher;\n\t} else {\n\t    return p;\n\t}\n    }\n}\n\nfunction project(m, spec) {\n    return walk(false, m, 0);\n\n    function walk(isCapturing, m, specIndex) {\n\tif (specIndex >= spec.length) {\n\t    if (isCapturing) die(\"Bad specification: unclosed capture\");\n\t    if (m instanceof $Success) {\n\t\treturn rseq(EOA, rsuccess(projectSuccess(m.value)));\n\t    } else {\n\t\treturn emptyMatcher;\n\t    }\n\t}\n\n\tif (is_emptyMatcher(m)) return emptyMatcher;\n\n\tvar item = spec[specIndex];\n\tvar nextIndex = specIndex + 1;\n\n\tif (item === EOC) {\n\t    if (!isCapturing) die(\"Bad specification: unepxected EOC\");\n\t    return walk(false, m, nextIndex);\n\t}\n\n\tif (item === SOC) {\n\t    if (isCapturing) die(\"Bad specification: nested capture\");\n\t    return walk(true, m, nextIndex);\n\t}\n\n\tif (item === __) {\n\t    if (m instanceof $WildcardSequence) {\n\t\tif (isCapturing) {\n\t\t    return rwild(walk(isCapturing, m, nextIndex));\n\t\t} else {\n\t\t    return walk(isCapturing, m, nextIndex);\n\t\t}\n\t    }\n\n\t    if (m instanceof $Success) {\n\t\treturn emptyMatcher;\n\t    }\n\n\t    var target;\n\t    if (isCapturing) {\n\t\ttarget = new $Dict();\n\t\trupdateInplace(target, __, walk(isCapturing, m.get(__), nextIndex));\n\t\tfor (var key in m.entries) {\n\t\t    if (key !== __) {\n\t\t\tvar mk = m.get(key);\n\t\t\tif (is_keyOpen(key)) {\n\t\t\t    function cont(mk2) { return walk(isCapturing, mk2, nextIndex); }\n\t\t\t    rupdateInplace(target, key, captureNested(mk, cont));\n\t\t\t} else if (is_keyClose(key)) {\n\t\t\t    // do nothing\n\t\t\t} else {\n\t\t\t    rupdateInplace(target, key, walk(isCapturing, mk, nextIndex));\n\t\t\t}\n\t\t    }\n\t\t}\n\t    } else {\n\t\ttarget = walk(isCapturing, m.get(__), nextIndex);\n\t\tfor (var key in m.entries) {\n\t\t    if (key !== __) {\n\t\t\tvar mk = m.get(key);\n\t\t\tif (is_keyOpen(key)) {\n\t\t\t    function cont(mk2) { return walk(isCapturing, mk2, nextIndex); }\n\t\t\t    target = union(target, skipNested(mk, cont));\n\t\t\t} else if (is_keyClose(key)) {\n\t\t\t    // do nothing\n\t\t\t} else {\n\t\t\t    target = union(target, walk(isCapturing, mk, nextIndex));\n\t\t\t}\n\t\t    }\n\t\t}\n\t    }\n\t    return target;\n\t}\n\n\tvar result;\n\tif (m instanceof $WildcardSequence) {\n\t    if (is_keyOpen(item)) {\n\t\tresult = walk(isCapturing, rwildseq(m), nextIndex);\n\t    } else if (is_keyClose(item)) {\n\t\tresult = walk(isCapturing, m.matcher, nextIndex);\n\t    } else {\n\t\tresult = walk(isCapturing, m, nextIndex);\n\t    }\n\t} else if (m instanceof $Success) {\n\t    result = emptyMatcher;\n\t} else {\n\t    if (is_keyOpen(item)) {\n\t\tresult = walk(isCapturing, rwildseq(m.get(__)), nextIndex);\n\t    } else if (is_keyClose(item)) {\n\t\tresult = emptyMatcher;\n\t    } else {\n\t\tresult = walk(isCapturing, m.get(__), nextIndex);\n\t    }\n\t    result = union(result, walk(isCapturing, m.get(item), nextIndex));\n\t}\n\tif (isCapturing) {\n\t    result = rseq(item, result);\n\t}\n\treturn result;\n    }\n\n    function captureNested(m, cont) {\n\tif (m instanceof $WildcardSequence) {\n\t    return rwildseq(cont(m.matcher));\n\t}\n\n\tif (is_emptyMatcher(m) || (m instanceof $Success)) {\n\t    return emptyMatcher;\n\t}\n\n\tvar target = new $Dict();\n\trupdateInplace(target, __, captureNested(m.get(__), cont));\n\tfor (var key in m.entries) {\n\t    if (key !== __) {\n\t\tvar mk = m.get(key);\n\t\tif (is_keyOpen(key)) {\n\t\t    function cont2(mk2) { return captureNested(mk2, cont); }\n\t\t    rupdateInplace(target, key, captureNested(mk, cont2));\n\t\t} else if (is_keyClose(key)) {\n\t\t    rupdateInplace(target, key, cont(mk));\n\t\t} else {\n\t\t    rupdateInplace(target, key, captureNested(mk, cont));\n\t\t}\n\t    }\n\t}\n\treturn target.emptyGuard();\n    }\n\n    function skipNested(m, cont) {\n\tif (m instanceof $WildcardSequence) {\n\t    return cont(m.matcher);\n\t}\n\n\tif (is_emptyMatcher(m) || (m instanceof $Success)) {\n\t    return emptyMatcher;\n\t}\n\n\tvar target = skipNested(m.get(__), cont);\n\tfor (var key in m.entries) {\n\t    if (key !== __) {\n\t\tvar mk = m.get(key);\n\t\tif (is_keyOpen(key)) {\n\t\t    function cont2(mk2) { return skipNested(mk2, cont); }\n\t\t    target = union(target, skipNested(mk, cont2));\n\t\t} else if (is_keyClose(key)) {\n\t\t    target = union(target, cont(mk));\n\t\t} else {\n\t\t    target = union(target, skipNested(mk, cont));\n\t\t}\n\t    }\n\t}\n\treturn target;\n    }\n}\n\nfunction matcherKeys(m) {\n    if (is_emptyMatcher(m)) return [];\n    return walkSeq(m, function (vss, vsk) { return vss; });\n\n    function walk(m, k) {\n\tif (m instanceof $WildcardSequence) return null;\n\tif (m instanceof $Success) return [];\n\tif (m.has(__)) return null;\n\tvar acc = [];\n\tfor (var key in m.entries) {\n\t    var mk = m.get(key);\n\t    var piece;\n\t    if (is_keyOpen(key)) {\n\t\tfunction seqK(vss, vsk) {\n\t\t    var acc = [];\n\t\t    for (var i = 0; i < vss.length; i++) {\n\t\t\tvar vs = vss[i];\n\t\t\tacc = acc.concat(k(transformSeqs(vs, key), vsk));\n\t\t    }\n\t\t    return acc;\n\t\t}\n\t\tpiece = walkSeq(mk, seqK);\n\t    } else if (is_keyClose(key)) {\n\t\tdie(\"matcherKeys: internal error: unexpected key-close\");\n\t    } else {\n\t\tpiece = k(JSON.parse(key), mk);\n\t    }\n\t    if (piece == null) return null;\n\t    acc = acc.concat(piece);\n\t}\n\treturn acc;\n    }\n\n    function walkSeq(m, k) {\n\tif (m instanceof $WildcardSequence) return null;\n\tif (m instanceof $Success) return k([], emptyMatcher); // TODO: ??\n\tif (m.has(__)) return null;\n\tvar acc = [];\n\tfor (var key in m.entries) {\n\t    var mk = m.get(key);\n\t    var piece;\n\t    if (is_keyClose(key)) {\n\t\tpiece = k([[]], mk);\n\t    } else {\n\t\tfunction outerK(v, vk) {\n\t\t    return walkSeq(vk, innerK);\n\t\t    function innerK(vss, vsk) {\n\t\t\tvar acc = [];\n\t\t\tfor (var i = 0; i < vss.length; i++) {\n\t\t\t    var vs = shallowCopyArray(vss[i]);\n\t\t\t    vs.unshift(v);\n\t\t\t    acc.push(vs);\n\t\t\t}\n\t\t\treturn k(acc, vsk);\n\t\t    }\n\t\t}\n\t\tpiece = walk(rseq(key, mk), outerK);\n\t    }\n\t    if (piece == null) return null;\n\t    acc = acc.concat(piece);\n\t}\n\treturn acc;\n    }\n\n    function transformSeqs(vs, opener) {\n\tif (opener === SOA) return vs;\n\tdie(\"Internal error: unknown opener \" + opener);\n    }\n}\n\nfunction prettyMatcher(m, initialIndent) {\n    var acc = [];\n    walk(initialIndent || 0, m);\n    return acc.join('');\n\n    function walk(i, m) {\n\tif (is_emptyMatcher(m)) {\n\t    acc.push(\"::: no further matches possible\");\n\t    return;\n\t}\n\tif (m instanceof $WildcardSequence) {\n\t    acc.push(\"...>\");\n\t    walk(i + 4, m.matcher);\n\t    return;\n\t}\n\tif (m instanceof $Success) {\n\t    var vs = JSON.stringify(typeof m.value === 'object'\n\t\t\t\t    ? setToArray(m.value)\n\t\t\t\t    : m.value);\n\t    acc.push(\"{\" + vs + \"}\");\n\t    return;\n\t}\n\n\tif (m.length === 0) {\n\t    acc.push(\" ::: empty hash!\");\n\t    return;\n\t}\n\n\tvar needSep = false;\n\tvar keys = m.sortedKeys();\n\tfor (var keyi = 0; keyi < keys.length; keyi++) {\n\t    var key = keys[keyi];\n\t    var k = m.entries[key];\n\t    if (needSep) {\n\t\tacc.push(\"\\n\");\n\t\tacc.push(indentStr(i));\n\t    } else {\n\t\tneedSep = true;\n\t    }\n\t    acc.push(\" \");\n\t    if (key === __) key = '★';\n\t    if (key === SOA) key = '<';\n\t    if (key === EOA) key = '>';\n\t    acc.push(key);\n\t    walk(i + key.length + 1, k);\n\t}\n    }\n\n    function indentStr(i) {\n\treturn new Array(i + 1).join(' '); // eww\n    }\n}\n\nfunction serializeMatcher(m, serializeSuccess) {\n    return walk(m);\n    function walk(m) {\n\tif (is_emptyMatcher(m)) return [];\n\tif (m instanceof $WildcardSequence) {\n\t    return [\"...)\", walk(m.matcher)];\n\t}\n\tif (m instanceof $Success) {\n\t    return [\"\", serializeSuccess(m.value)];\n\t}\n\tvar acc = [];\n\tfor (var key in m.entries) {\n\t    var k = m.entries[key];\n\t    if (key === __) key = [\"__\"];\n\t    else if (key === SOA) key = [\"(\"];\n\t    else if (key === EOA) key = [\")\"];\n\t    else key = JSON.parse(key);\n\t    acc.push([key, walk(k)]);\n\t}\n\treturn acc;\n    }\n}\n\nfunction deserializeMatcher(r, deserializeSuccess) {\n    return walk(r);\n    function walk(r) {\n\tif (r.length === 0) return emptyMatcher;\n\tif (r[0] === \"...)\") return rwildseq(walk(r[1]));\n\tif (r[0] === \"\") return rsuccess(deserializeSuccess(r[1]));\n\tvar acc = new $Dict();\n\tfor (var i = 0; i < r.length; i++) {\n\t    var rkey = r[i][0];\n\t    var rk = r[i][1];\n\t    var key;\n\t    if (Array.isArray(rkey)) {\n\t\tswitch (rkey[0]) {\n\t\tcase \"__\": key = __; break;\n\t\tcase \"(\": key = SOA; break;\n\t\tcase \")\": key = EOA; break;\n\t\tdefault: die(\"Invalid serialized special key: \" + rkey[0]);\n\t\t}\n\t    } else {\n\t\tkey = JSON.stringify(rkey);\n\t    }\n\t    rupdateInplace(acc, key, walk(rk));\n\t}\n\treturn acc;\n    }\n}\n\n///////////////////////////////////////////////////////////////////////////\n// Gestalts.\n// TODO: support Infinity as a level number\n\nfunction GestaltLevel(subs, advs) {\n    this.subscriptions = subs;\n    this.advertisements = advs;\n}\n\nGestaltLevel.prototype.isEmpty = function () {\n    return is_emptyMatcher(this.subscriptions) && is_emptyMatcher(this.advertisements);\n};\n\nGestaltLevel.prototype.equals = function (other) {\n    return matcherEquals(this.subscriptions, other.subscriptions)\n\t&& matcherEquals(this.advertisements, other.advertisements);\n};\n\nGestaltLevel.prototype.pretty = function () {\n    var acc = [];\n    if (!is_emptyMatcher(this.subscriptions)) {\n\tacc.push(\"  - subs:\");\n\tacc.push(prettyMatcher(this.subscriptions, 9));\n\tacc.push(\"\\n\");\n    }\n    if (!is_emptyMatcher(this.advertisements)) {\n\tacc.push(\"  - advs:\");\n\tacc.push(prettyMatcher(this.advertisements, 9));\n\tacc.push(\"\\n\");\n    }\n    return acc.join('');\n};\n\nfunction straightGestaltLevelOp(op) {\n    return function (p1, p2) {\n\treturn new GestaltLevel(op(p1.subscriptions, p2.subscriptions),\n\t\t\t\top(p1.advertisements, p2.advertisements));\n    };\n};\n\nvar emptyLevel = new GestaltLevel(emptyMatcher, emptyMatcher);\nvar emptyMetaLevel = [];\n\nfunction Gestalt(metaLevels) {\n    this.metaLevels = metaLevels;\n}\n\nGestalt.prototype.getMetaLevel = function (n) {\n    return this.metaLevels[n] || emptyMetaLevel;\n};\n\nGestalt.prototype.getLevel = function (metaLevel, level) {\n    return this.getMetaLevel(metaLevel)[level] || emptyLevel;\n};\n\nGestalt.prototype.metaLevelCount = function () { return this.metaLevels.length; };\nGestalt.prototype.levelCount = function (n) { return this.getMetaLevel(n).length; };\n\nGestalt.prototype.matchValue = function (body, metaLevel, isFeedback) {\n    var levels = this.getMetaLevel(metaLevel);\n    var pids = {};\n    for (var i = 0; i < levels.length; i++) {\n\tvar matcher = (isFeedback ? levels[i].advertisements : levels[i].subscriptions);\n\tsetUnionInplace(pids, matchValue(matcher, body));\n    }\n    return setToArray(pids);\n};\n\nGestalt.prototype.project = function (spec, getAdvertisements, metaLevel, level) {\n    var l = this.getLevel(metaLevel | 0, level | 0);\n    var matcher = (getAdvertisements ? l.advertisements : l.subscriptions);\n    return project(matcher, spec);\n};\n\nGestalt.prototype.drop = function () {\n    var mls = shallowCopyArray(this.metaLevels);\n    mls.shift();\n    return new Gestalt(mls);\n};\n\nGestalt.prototype.lift = function () {\n    var mls = shallowCopyArray(this.metaLevels);\n    mls.unshift(emptyMetaLevel);\n    return new Gestalt(mls);\n};\n\nGestalt.prototype.equals = function (other) {\n    if (this.metaLevels.length !== other.metaLevels.length) return false;\n    for (var i = 0; i < this.metaLevels.length; i++) {\n\tvar ls1 = this.metaLevels[i];\n\tvar ls2 = other.metaLevels[i];\n\tif (ls1.length !== ls2.length) return false;\n\tfor (var j = 0; j < ls1.length; j++) {\n\t    var p1 = ls1[j];\n\t    var p2 = ls2[j];\n\t    if (!p1.equals(p2)) return false;\n\t}\n    }\n    return true;\n};\n\nfunction simpleGestalt(isAdv, pat, metaLevel, level) {\n    metaLevel = metaLevel || 0;\n    level = level || 0;\n    var matcher = compilePattern(true, pat);\n    var l = new GestaltLevel(isAdv ? emptyMatcher : matcher,\n\t\t\t     isAdv ? matcher : emptyMatcher);\n    var levels = [l];\n    while (level--) { levels.unshift(emptyLevel); }\n    var metaLevels = [levels];\n    while (metaLevel--) { metaLevels.unshift(emptyMetaLevel); }\n    return new Gestalt(metaLevels);\n}\n\nvar emptyGestalt = new Gestalt([]);\n\n// Not quite what it says on the tin - the true fullGestalt\n// wouldn't be parameterized on the number of levels and\n// metalevels, but instead would be full at *all* levels and\n// metalevels. Our representation leaks through into the interface\n// here :-/\nfunction fullGestalt(nMetalevels, nLevels) {\n    var matcher = compilePattern(true, __);\n    var l = new GestaltLevel(matcher, matcher);\n    var levels = [];\n    while (nLevels--) { levels.push(l); }\n    var metaLevels = [];\n    while (nMetalevels--) { metaLevels.push(levels); }\n    return new Gestalt(metaLevels);\n}\n\nGestalt.prototype.isEmpty = function () {\n    for (var i = 0; i < this.metaLevels.length; i++) {\n\tvar levels = this.metaLevels[i];\n\tfor (var j = 0; j < levels.length; j++) {\n\t    if (!levels[j].isEmpty()) return false;\n\t}\n    }\n    return true;\n};\n\nfunction maybePushLevel(levels, i, level) {\n    if (!level.isEmpty()) {\n\twhile (levels.length < i) levels.push(emptyLevel);\n\tlevels.push(level);\n    }\n}\n\nfunction maybePushMetaLevel(metaLevels, i, metaLevel) {\n    if (metaLevel.length > 0) {\n\twhile (metaLevels.length < i) metaLevels.push(emptyMetaLevel);\n\tmetaLevels.push(metaLevel);\n    }\n}\n\nGestalt.prototype.mapZip = function (other, lengthCombiner, f) {\n    var metaLevels = [];\n    var mls1 = this.metaLevels;\n    var mls2 = other.metaLevels;\n    var nm = lengthCombiner(mls1.length, mls2.length);\n    for (var i = 0; i < nm; i++) {\n\tvar levels = [];\n\tvar ls1 = mls1[i] || emptyMetaLevel;\n\tvar ls2 = mls2[i] || emptyMetaLevel;\n\tvar nl = lengthCombiner(ls1.length, ls2.length);\n\tfor (var j = 0; j < nl; j++) {\n\t    var p1 = ls1[j] || emptyLevel;\n\t    var p2 = ls2[j] || emptyLevel;\n\t    var p = f(p1, p2);\n\t    maybePushLevel(levels, j, p);\n\t}\n\tmaybePushMetaLevel(metaLevels, i, levels);\n    }\n    return new Gestalt(metaLevels);\n};\n\nGestalt.prototype.union1 = function (other) {\n    return this.mapZip(other, Math.max, straightGestaltLevelOp(union));\n};\n\nfunction gestaltUnion(gs) {\n    if (gs.length === 0) return emptyGestalt;\n    var acc = gs[0];\n    for (var i = 1; i < gs.length; i++) {\n\tacc = acc.union1(gs[i]);\n    }\n    return acc;\n}\n\nGestalt.prototype.union = function () {\n    return arguments.length > 0 ? this.union1(gestaltUnion(arguments)) : this;\n};\n\n// Accumulates matchers from higher-numbered levels into\n// lower-numbered levels.\nfunction telescopeLevels(levels) {\n    var result = shallowCopyArray(levels);\n    for (var i = result.length - 2; i >= 0; i--) {\n\tresult[i] =\n\t    new GestaltLevel(union(result[i].subscriptions, result[i+1].subscriptions),\n\t\t\t     union(result[i].advertisements, result[i+1].advertisements));\n    }\n    return result;\n};\n\nGestalt.prototype.telescoped = function () {\n    var mls = [];\n    for (var i = 0; i < this.metaLevels.length; i++) {\n\tmls.push(telescopeLevels(this.metaLevels[i]));\n    }\n    return new Gestalt(mls);\n};\n\nGestalt.prototype.filter = function (perspective) {\n    var metaLevels = [];\n    var mls1 = this.metaLevels;\n    var mls2 = perspective.metaLevels;\n    var nm = Math.min(mls1.length, mls2.length);\n    for (var i = 0; i < nm; i++) {\n\tvar levels = [];\n\tvar ls1 = mls1[i] || emptyMetaLevel;\n\tvar ls2 = mls2[i] || emptyMetaLevel;\n\tvar nl = Math.min(ls1.length, ls2.length - 1);\n\tfor (var j = 0; j < nl; j++) {\n\t    var p1 = ls1[j] || emptyLevel;\n\t    var subs = emptyMatcher;\n\t    var advs = emptyMatcher;\n\t    for (var k = j + 1; k < ls2.length; k++) {\n\t\tvar p2 = ls2[k] || emptyLevel;\n\t\tsubs = union(subs, intersect(p1.subscriptions, p2.advertisements));\n\t\tadvs = union(advs, intersect(p1.advertisements, p2.subscriptions));\n\t    }\n\t    maybePushLevel(levels, j, new GestaltLevel(subs, advs));\n\t}\n\tmaybePushMetaLevel(metaLevels, i, levels);\n    }\n    return new Gestalt(metaLevels);\n};\n\nGestalt.prototype.match = function (perspective) {\n    var pids = {};\n    var nm = Math.min(this.metaLevels.length, perspective.metaLevels.length);\n    for (var i = 0; i < nm; i++) {\n\tvar ls1 = this.metaLevels[i] || emptyMetaLevel;\n\tvar ls2 = perspective.metaLevels[i] || emptyMetaLevel;\n\tvar nl = Math.min(ls1.length, ls2.length - 1);\n\tfor (var j = 0; j < nl; j++) {\n\t    var p1 = ls1[j] || emptyLevel;\n\t    for (var k = j + 1; k < ls2.length; k++) {\n\t\tvar p2 = ls2[k] || emptyLevel;\n\t\tmatchMatcher(p1.subscriptions, p2.advertisements, pids);\n\t\tmatchMatcher(p1.advertisements, p2.subscriptions, pids);\n\t    }\n\t}\n    }\n    return setToArray(pids);\n};\n\nGestalt.prototype.erasePath = function (path) {\n    return this.mapZip(path, Math.max, straightGestaltLevelOp(erasePath));\n};\n\nfunction mapLevels(inputMetaLevels, f, emptyCheck, inputEmptyLevel, outputEmptyLevel) {\n    var outputMetaLevels = [];\n    for (var i = 0; i < inputMetaLevels.length; i++) {\n\tvar ls = inputMetaLevels[i];\n\tvar levels = [];\n\tfor (var j = 0; j < ls.length; j++) {\n\t    var p = f(ls[j] || inputEmptyLevel, i, j);\n\t    if (!emptyCheck(p, i, j)) {\n\t\twhile (levels.length < j) levels.push(outputEmptyLevel);\n\t\tlevels.push(p);\n\t    }\n\t}\n\tif (levels.length > 0) {\n\t    while (outputMetaLevels.length < i) outputMetaLevels.push(emptyMetaLevel);\n\t    outputMetaLevels.push(levels);\n\t}\n    }\n    return outputMetaLevels;\n};\n\nGestalt.prototype.transform = function (f) {\n    return new Gestalt(mapLevels(this.metaLevels, function (p, ml, l) {\n\treturn new GestaltLevel(f(p.subscriptions, ml, l, false),\n\t\t\t\tf(p.advertisements, ml, l, true));\n    }, function (p) {\n\treturn p.isEmpty();\n    }, emptyLevel, emptyLevel));\n};\n\nGestalt.prototype.stripLabel = function () {\n    return this.transform(function (m) { return relabel(m, function (v) { return true; }); });\n};\n\nGestalt.prototype.label = function (pid) {\n    var pids = arrayToSet([pid]);\n    return this.transform(function (m) { return relabel(m, function (v) { return pids; }); });\n};\n\nGestalt.prototype.pretty = function () {\n    var acc = [];\n    if (this.isEmpty()) {\n\tacc.push(\"EMPTY GESTALT\\n\");\n    } else {\n\tfor (var i = 0; i < this.metaLevels.length; i++) {\n\t    var ls = this.metaLevels[i];\n\t    for (var j = 0; j < ls.length; j++) {\n\t\tvar p = ls[j];\n\t\tif (!p.isEmpty()) {\n\t\t    acc.push(\"GESTALT metalevel \" + i + \" level \" + j + \":\\n\");\n\t\t    acc.push(p.pretty());\n\t\t}\n\t    }\n\t}\n    }\n    return acc.join('');\n};\n\nGestalt.prototype.serialize = function (serializeSuccess) {\n    if (typeof serializeSuccess === 'undefined') {\n\tserializeSuccess = function (v) { return v === true ? true : setToArray(v); };\n    }\n    return [\"gestalt\", mapLevels(this.metaLevels, function (p) {\n\treturn [serializeMatcher(p.subscriptions, serializeSuccess),\n\t\tserializeMatcher(p.advertisements, serializeSuccess)];\n    }, function (pr) {\n\treturn pr.length === 2 && pr[0].length === 0 && pr[1].length === 0;\n    }, emptyLevel, [[],[]])];\n};\n\nfunction deserializeGestalt(r, deserializeSuccess) {\n    if (typeof deserializeSuccess === 'undefined') {\n\tdeserializeSuccess = function (v) { return v === true ? true : arrayToSet(v); };\n    }\n    if (r[0] !== \"gestalt\") die(\"Invalid gestalt serialization: \" + r);\n    return new Gestalt(mapLevels(r[1], function (pr) {\n\treturn new GestaltLevel(deserializeMatcher(pr[0], deserializeSuccess),\n\t\t\t\tdeserializeMatcher(pr[1], deserializeSuccess));\n    }, function (p) {\n\treturn p.isEmpty();\n    }, [[],[]], emptyLevel));\n}\n\n///////////////////////////////////////////////////////////////////////////\n\nmodule.exports.__ = __;\nmodule.exports.arrayToSet = arrayToSet;\nmodule.exports.setToArray = setToArray;\nmodule.exports.setUnion = setUnion;\nmodule.exports.setSubtract = setSubtract;\nmodule.exports.setIntersect = setIntersect;\nmodule.exports.setEqual = setEqual;\nmodule.exports.is_emptySet = is_emptySet;\nmodule.exports.$Capture = $Capture;\nmodule.exports._$ = _$;\nmodule.exports.is_emptyMatcher = is_emptyMatcher;\nmodule.exports.emptyMatcher = emptyMatcher;\nmodule.exports.embeddedMatcher = embeddedMatcher;\nmodule.exports.compilePattern = compilePattern;\nmodule.exports.union = unionN;\nmodule.exports.intersect = intersect;\nmodule.exports.erasePath = erasePath;\nmodule.exports.matchValue = matchValue;\nmodule.exports.matchMatcher = matchMatcher;\nmodule.exports.appendMatcher = appendMatcher;\nmodule.exports.relabel = relabel;\nmodule.exports.compileProjection = compileProjection;\nmodule.exports.projectionToPattern = projectionToPattern;\nmodule.exports.project = project;\nmodule.exports.matcherKeys = matcherKeys;\nmodule.exports.matcherEquals = matcherEquals;\nmodule.exports.prettyMatcher = prettyMatcher;\nmodule.exports.serializeMatcher = serializeMatcher;\nmodule.exports.deserializeMatcher = deserializeMatcher;\n\nmodule.exports.GestaltLevel = GestaltLevel;\nmodule.exports.Gestalt = Gestalt;\nmodule.exports.simpleGestalt = simpleGestalt;\nmodule.exports.emptyGestalt = emptyGestalt;\nmodule.exports.fullGestalt = fullGestalt;\nmodule.exports.gestaltUnion = gestaltUnion;\nmodule.exports.deserializeGestalt = deserializeGestalt;\n","var Minimart = require(\"./minimart.js\");\nvar Route = Minimart.Route;\nvar World = Minimart.World;\nvar sub = Minimart.sub;\nvar pub = Minimart.pub;\nvar __ = Minimart.__;\nvar _$ = Minimart._$;\n\nfunction spawnRoutingTableWidget(selector, fragmentClass, observationLevel) {\n    observationLevel = observationLevel || 10;\n    // ^ arbitrary: should be Infinity, when route.js supports it. TODO\n\n    World.spawn({\n\tboot: function () { this.updateState(); },\n\n\tstate: Route.emptyGestalt.serialize(),\n\tnextState: Route.emptyGestalt.serialize(),\n\ttimer: false,\n\n\tlocalGestalt: (sub(       [\"DOM\", selector, fragmentClass, __], 0, 2)\n\t\t       .union(pub([\"DOM\", selector, fragmentClass, __], 0, 2))\n\t\t       .telescoped()),\n\n\tdigestGestalt: function (g) {\n\t    return g.stripLabel().erasePath(this.localGestalt).serialize();\n\t},\n\n\tupdateState: function () {\n\t    var elts = [\"pre\", Route.deserializeGestalt(this.state).pretty()];\n\t    World.updateRoutes([sub(__, 0, observationLevel),\n\t\t\t\tpub(__, 0, observationLevel),\n\t\t\t\tpub([\"DOM\", selector, fragmentClass, elts])]);\n\t},\n\n\thandleEvent: function (e) {\n\t    var self = this;\n\t    if (e.type === \"routes\") {\n\t\tself.nextState = self.digestGestalt(e.gestalt);\n\t\tif (self.timer) {\n\t\t    clearTimeout(self.timer);\n\t\t    self.timer = false;\n\t\t}\n\t\tself.timer = setTimeout(World.wrap(function () {\n\t\t    if (JSON.stringify(self.nextState) !== JSON.stringify(self.state)) {\n\t\t\tself.state = self.nextState;\n\t\t\tself.updateState();\n\t\t    }\n\t\t    self.timer = false;\n\t\t}), 50);\n\t    }\n\t}\n    });\n\n}\n\nmodule.exports.spawnRoutingTableWidget = spawnRoutingTableWidget;\n","// Generic Spy\nvar Minimart = require(\"./minimart.js\");\nvar World = Minimart.World;\nvar sub = Minimart.sub;\nvar pub = Minimart.pub;\nvar __ = Minimart.__;\nvar _$ = Minimart._$;\n\nfunction Spy(label, useJson, observationLevel) {\n    this.label = label || \"SPY\";\n    this.observationLevel = observationLevel || 10; // arbitrary. Should be Infinity. TODO\n    this.useJson = useJson;\n}\n\nSpy.prototype.boot = function () {\n    World.updateRoutes([sub(__, 0, this.observationLevel), pub(__, 0, this.observationLevel)]);\n};\n\nSpy.prototype.handleEvent = function (e) {\n    switch (e.type) {\n    case \"routes\":\n\tconsole.log(this.label, \"routes\", e.gestalt.pretty());\n\tbreak;\n    case \"message\":\n\tvar messageRepr;\n\ttry {\n\t    messageRepr = this.useJson ? JSON.stringify(e.message) : e.message;\n\t} catch (exn) {\n\t    messageRepr = e.message;\n\t}\n\tconsole.log(this.label, \"message\", messageRepr, e.metaLevel, e.isFeedback);\n\tbreak;\n    default:\n\tconsole.log(this.label, \"unknown\", e);\n\tbreak;\n    }\n};\n\nmodule.exports.Spy = Spy;\n","// Wake detector - notices when something (such as\n// suspension/sleeping!) has caused periodic activities to be\n// interrupted, and warns others about it\n// Inspired by http://blog.alexmaccaw.com/javascript-wake-event\nvar Minimart = require(\"./minimart.js\");\nvar World = Minimart.World;\nvar sub = Minimart.sub;\nvar pub = Minimart.pub;\nvar __ = Minimart.__;\nvar _$ = Minimart._$;\n\nfunction WakeDetector(period) {\n    this.message = \"wake\";\n    this.period = period || 10000;\n    this.mostRecentTrigger = +(new Date());\n    this.timerId = null;\n}\n\nWakeDetector.prototype.boot = function () {\n    var self = this;\n    World.updateRoutes([pub(this.message)]);\n    this.timerId = setInterval(World.wrap(function () { self.trigger(); }), this.period);\n};\n\nWakeDetector.prototype.handleEvent = function (e) {};\n\nWakeDetector.prototype.trigger = function () {\n    var now = +(new Date());\n    if (now - this.mostRecentTrigger > this.period * 1.5) {\n\tWorld.send(this.message);\n    }\n    this.mostRecentTrigger = now;\n};\n\nmodule.exports.WakeDetector = WakeDetector;\n","var Minimart = require(\"./minimart.js\");\nvar Route = Minimart.Route;\nvar World = Minimart.World;\nvar sub = Minimart.sub;\nvar pub = Minimart.pub;\nvar __ = Minimart.__;\nvar _$ = Minimart._$;\n\n///////////////////////////////////////////////////////////////////////////\n// WebSocket client driver\n\nvar DEFAULT_RECONNECT_DELAY = 100;\nvar MAX_RECONNECT_DELAY = 30000;\nvar DEFAULT_IDLE_TIMEOUT = 300000; // 5 minutes\nvar DEFAULT_PING_INTERVAL = DEFAULT_IDLE_TIMEOUT - 10000;\n\nfunction WebSocketConnection(label, wsurl, shouldReconnect) {\n    this.label = label;\n    this.sendsAttempted = 0;\n    this.sendsTransmitted = 0;\n    this.receiveCount = 0;\n    this.sock = null;\n    this.wsurl = wsurl;\n    this.shouldReconnect = shouldReconnect ? true : false;\n    this.reconnectDelay = DEFAULT_RECONNECT_DELAY;\n    this.localGestalt = Route.emptyGestalt;\n    this.peerGestalt = Route.emptyGestalt;\n    this.prevLocalRoutesMessage = null;\n    this.prevPeerRoutesMessage = null;\n    this.deduplicator = new Minimart.Deduplicator();\n    this.connectionCount = 0;\n\n    this.activityTimestamp = 0;\n    this.idleTimeout = DEFAULT_IDLE_TIMEOUT;\n    this.pingInterval = DEFAULT_PING_INTERVAL;\n    this.idleTimer = null;\n    this.pingTimer = null;\n}\n\nWebSocketConnection.prototype.clearHeartbeatTimers = function () {\n    if (this.idleTimer) { clearTimeout(this.idleTimer); this.idleTimer = null; }\n    if (this.pingTimer) { clearTimeout(this.pingTimer); this.pingTimer = null; }\n};\n\nWebSocketConnection.prototype.recordActivity = function () {\n    var self = this;\n    this.activityTimestamp = +(new Date());\n    this.clearHeartbeatTimers();\n    this.idleTimer = setTimeout(function () { self.forceclose(); },\n\t\t\t\tthis.idleTimeout);\n    this.pingTimer = setTimeout(function () { self.safeSend(JSON.stringify(\"ping\")) },\n\t\t\t\tthis.pingInterval);\n};\n\nWebSocketConnection.prototype.statusRoute = function (status) {\n    return pub([this.label + \"_state\", status]);\n};\n\nWebSocketConnection.prototype.relayGestalt = function () {\n    return this.statusRoute(this.isConnected() ? \"connected\" : \"disconnected\")\n\t.union(pub([this.label, __, __], 0, 10))\n\t.union(sub([this.label, __, __], 0, 10));\n    // TODO: level 10 is ad-hoc; support infinity at some point in future\n};\n\nWebSocketConnection.prototype.aggregateGestalt = function () {\n    var self = this;\n    return this.peerGestalt.transform(function (m, metaLevel) {\n\treturn Route.compilePattern(true,\n\t\t\t\t    [self.label, metaLevel, Route.embeddedMatcher(m)]);\n    }).union(this.relayGestalt());\n};\n\nWebSocketConnection.prototype.boot = function () {\n    this.reconnect();\n};\n\nWebSocketConnection.prototype.trapexit = function () {\n    this.forceclose();\n};\n\nWebSocketConnection.prototype.isConnected = function () {\n    return this.sock && this.sock.readyState === this.sock.OPEN;\n};\n\nWebSocketConnection.prototype.safeSend = function (m) {\n    try {\n\tthis.sendsAttempted++;\n\tif (this.isConnected()) {\n\t    this.sock.send(m);\n\t    this.sendsTransmitted++;\n\t}\n    } catch (e) {\n\tconsole.warn(\"Trapped exn while sending\", e);\n    }\n};\n\nWebSocketConnection.prototype.sendLocalRoutes = function () {\n    var newLocalRoutesMessage =\n\tJSON.stringify(encodeEvent(Minimart.updateRoutes([this.localGestalt])));\n    if (this.prevLocalRoutesMessage !== newLocalRoutesMessage) {\n\tthis.prevLocalRoutesMessage = newLocalRoutesMessage;\n\tthis.safeSend(newLocalRoutesMessage);\n    }\n};\n\nWebSocketConnection.prototype.collectMatchers = function (getAdvertisements, level, g) {\n    var extractMetaLevels = Route.compileProjection([this.label, _$, __]);\n    var mls = Route.matcherKeys(g.project(extractMetaLevels, getAdvertisements, 0, level));\n    for (var i = 0; i < mls.length; i++) {\n\tvar metaLevel = mls[i][0]; // only one capture in the projection\n\tvar extractMatchers = Route.compileProjection([this.label, metaLevel, _$]);\n\tvar m = g.project(extractMatchers, getAdvertisements, 0, level);\n\tthis.localGestalt = this.localGestalt.union(Route.simpleGestalt(getAdvertisements,\n\t\t\t\t\t\t\t\t\tRoute.embeddedMatcher(m),\n\t\t\t\t\t\t\t\t\tmetaLevel,\n\t\t\t\t\t\t\t\t\tlevel));\n    }\n};\n\nWebSocketConnection.prototype.handleEvent = function (e) {\n    // console.log(\"WebSocketConnection.handleEvent\", e);\n    switch (e.type) {\n    case \"routes\":\n\t// TODO: GROSS - erasing by pid!\n\tvar nLevels = e.gestalt.levelCount(0);\n\tvar relayGestalt = Route.fullGestalt(1, nLevels).label(World.activePid());\n\tvar g = e.gestalt.erasePath(relayGestalt);\n\tthis.localGestalt = Route.emptyGestalt;\n\tfor (var level = 0; level < nLevels; level++) {\n\t    this.collectMatchers(false, level, g);\n\t    this.collectMatchers(true, level, g);\n\t}\n\n\tthis.sendLocalRoutes();\n\tbreak;\n    case \"message\":\n\tvar m = e.message;\n\tif (m.length && m.length === 3 && m[0] === this.label)\n\t{\n\t    var encoded = JSON.stringify(encodeEvent(\n\t\tMinimart.sendMessage(m[2], m[1], e.isFeedback)));\n\t    if (this.deduplicator.accept(encoded)) {\n\t\tthis.safeSend(encoded);\n\t    }\n\t}\n\tbreak;\n    }\n};\n\nWebSocketConnection.prototype.forceclose = function (keepReconnectDelay) {\n    if (!keepReconnectDelay) {\n\tthis.reconnectDelay = DEFAULT_RECONNECT_DELAY;\n    }\n    this.clearHeartbeatTimers();\n    if (this.sock) {\n\tconsole.log(\"WebSocketConnection.forceclose called\");\n\tthis.sock.close();\n\tthis.sock = null;\n    }\n};\n\nWebSocketConnection.prototype.reconnect = function () {\n    var self = this;\n    this.forceclose(true);\n    this.connectionCount++;\n    this.sock = new WebSocket(this.wsurl);\n    this.sock.onopen = World.wrap(function (e) { return self.onopen(e); });\n    this.sock.onmessage = World.wrap(function (e) {\n\tself.receiveCount++;\n\treturn self.onmessage(e);\n    });\n    this.sock.onclose = World.wrap(function (e) { return self.onclose(e); });\n};\n\nWebSocketConnection.prototype.onopen = function (e) {\n    console.log(\"connected to \" + this.sock.url);\n    this.reconnectDelay = DEFAULT_RECONNECT_DELAY;\n    this.prevLocalRoutesMessage = null;\n    this.sendLocalRoutes();\n};\n\nWebSocketConnection.prototype.onmessage = function (wse) {\n    // console.log(\"onmessage\", wse);\n    this.recordActivity();\n\n    var j = JSON.parse(wse.data);\n    if (j === \"ping\") {\n\tthis.safeSend(JSON.stringify(\"pong\"));\n\treturn;\n    } else if (j === \"pong\") {\n\treturn; // recordActivity already took care of our timers\n    }\n\n    var e = decodeAction(j);\n    switch (e.type) {\n    case \"routes\":\n\tif (this.prevPeerRoutesMessage !== wse.data) {\n\t    this.prevPeerRoutesMessage = wse.data;\n\t    this.peerGestalt = e.gestalt;\n\t    World.updateRoutes([this.aggregateGestalt()]);\n\t}\n\tbreak;\n    case \"message\":\n\tif (this.deduplicator.accept(wse.data)) {\n\t    World.send([this.label, e.metaLevel, e.message], 0, e.isFeedback);\n\t}\n\tbreak;\n    }\n};\n\nWebSocketConnection.prototype.onclose = function (e) {\n    var self = this;\n    console.log(\"onclose\", e);\n\n    // Update routes to give clients some indication of the discontinuity\n    World.updateRoutes([this.aggregateGestalt()]);\n\n    if (this.shouldReconnect) {\n\tconsole.log(\"reconnecting to \" + this.wsurl + \" in \" + this.reconnectDelay + \"ms\");\n\tsetTimeout(World.wrap(function () { self.reconnect(); }), this.reconnectDelay);\n\tthis.reconnectDelay = this.reconnectDelay * 1.618 + (Math.random() * 1000);\n\tthis.reconnectDelay =\n\t    this.reconnectDelay > MAX_RECONNECT_DELAY\n\t    ? MAX_RECONNECT_DELAY + (Math.random() * 1000)\n\t    : this.reconnectDelay;\n    }\n};\n\n///////////////////////////////////////////////////////////////////////////\n// Wire protocol representation of events and actions\n\nfunction encodeEvent(e) {\n    switch (e.type) {\n    case \"routes\":\n\treturn [\"routes\", e.gestalt.serialize(function (v) { return true; })];\n    case \"message\":\n\treturn [\"message\", e.message, e.metaLevel, e.isFeedback];\n    }\n}\n\nfunction decodeAction(j) {\n    switch (j[0]) {\n    case \"routes\":\n\treturn Minimart.updateRoutes([\n\t    Route.deserializeGestalt(j[1], function (v) { return true; })]);\n    case \"message\":\n\treturn Minimart.sendMessage(j[1], j[2], j[3]);\n    default:\n\tthrow { message: \"Invalid JSON-encoded action: \" + JSON.stringify(j) };\n    }\n}\n\n///////////////////////////////////////////////////////////////////////////\n\nmodule.exports.WebSocketConnection = WebSocketConnection;\nmodule.exports.encodeEvent = encodeEvent;\nmodule.exports.decodeAction = decodeAction;\n"]} +(3) +}); diff --git a/dist/minimart.min.js b/dist/minimart.min.js new file mode 100644 index 0000000..8a95939 --- /dev/null +++ b/dist/minimart.min.js @@ -0,0 +1,2 @@ +!function(e){if("object"==typeof exports)module.exports=e();else if("function"==typeof define&&define.amd)define(e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.Minimart=e()}}(function(){var define,module,exports;return function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o ."+self.fragmentClass,1);World.spawn({handleEvent:function(e){if(e.type==="routes"){var level=e.gestalt.getLevel(1,0);if(!e.gestalt.isEmpty()&&level.isEmpty()){World.shutdownWorld()}}}},[monitoring])}))};DOMFragment.prototype.handleEvent=function(e){if(e.type==="routes"&&e.gestalt.isEmpty()){for(var i=0;i=0;i--){World.stack[i][0].markPidRunnable(World.stack[i][1])}return result})}};World.prototype.enqueueAction=function(pid,action){this.processActions.push([pid,action])};World.prototype.isInert=function(){return this.eventQueue.length===0&&this.processActions.length===0&&Route.is_emptySet(this.runnablePids)};World.prototype.markPidRunnable=function(pid){this.runnablePids[pid]=[pid]};World.prototype.step=function(){this.dispatchEvents();this.performActions();this.stepChildren();return this.alive&&!this.isInert()};World.prototype.asChild=function(pid,f,omitLivenessCheck){if(!(pid in this.processTable)&&!omitLivenessCheck){console.warn("World.asChild eliding invocation of dead process",pid);return}World.stack.push([this,pid]);var result=null;try{result=f()}catch(e){this.kill(pid,e)}if(World.stack.pop()[0]!==this){throw new Error("Internal error: World stack imbalance")}return result};World.prototype.kill=function(pid,exn){if(exn&&exn.stack){console.log("Process exited",pid,exn,exn.stack)}else{console.log("Process exited",pid,exn)}var p=this.processTable[pid];if(p&&p.behavior.trapexit){this.asChild(pid,function(){return p.behavior.trapexit(exn)})}delete this.processTable[pid];if(p){if(exn){p.exitReason=exn;this.tombstones[pid]=p}this.applyAndIssueRoutingUpdate(p.gestalt,Route.emptyGestalt)}};World.prototype.stepChildren=function(){var pids=this.runnablePids;this.runnablePids={};for(var pid in pids){var p=this.processTable[pid];if(p&&p.behavior.step){var childBusy=this.asChild(pid|0,function(){return p.behavior.step()});if(childBusy)this.markPidRunnable(pid)}}};World.prototype.performActions=function(){var queue=this.processActions;this.processActions=[];var item;while((item=queue.shift())&&this.alive){this.performAction(item[0],item[1])}};World.prototype.dispatchEvents=function(){var queue=this.eventQueue;this.eventQueue=[];var item;while(item=queue.shift()){this.dispatchEvent(item)}};World.prototype.performAction=function(pid,action){switch(action.type){case"spawn":var pid=World.nextPid++;var newGestalt=action.initialGestalt.label(pid);this.processTable[pid]={gestalt:newGestalt,behavior:action.behavior};if(action.behavior.boot){this.asChild(pid,function(){action.behavior.boot()});this.markPidRunnable(pid)}this.applyAndIssueRoutingUpdate(Route.emptyGestalt,newGestalt,pid);break;case"routes":if(pid in this.processTable){var oldGestalt=this.processTable[pid].gestalt;var newGestalt=action.gestalt.label(pid|0);this.processTable[pid].gestalt=newGestalt;this.applyAndIssueRoutingUpdate(oldGestalt,newGestalt,pid)}break;case"message":if(action.metaLevel===0){this.eventQueue.push(action)}else{World.send(action.message,action.metaLevel-1,action.isFeedback)}break;case"shutdownWorld":this.alive=false;World.exit();break;default:var exn=new Error("Action type "+action.type+" not understood");exn.action=action;throw exn}};World.prototype.updateFullGestalt=function(){this.fullGestalt=this.partialGestalt.union(this.downwardGestalt)};World.prototype.issueLocalRoutingUpdate=function(affectedSubgestalt,knownTarget){this.eventQueue.push(pendingRoutingUpdate(this.fullGestalt,affectedSubgestalt,knownTarget))};World.prototype.applyAndIssueRoutingUpdate=function(oldg,newg,knownTarget){knownTarget=typeof knownTarget==="undefined"?null:knownTarget;this.partialGestalt=this.partialGestalt.erasePath(oldg).union(newg);this.updateFullGestalt();this.issueLocalRoutingUpdate(oldg.union(newg),knownTarget);World.updateRoutes([this.partialGestalt.drop()])};World.prototype.dispatchEvent=function(e){switch(e.type){case"pendingRoutingUpdate":var pids=e.affectedSubgestalt.match(e.aggregate);if(e.knownTarget!==null)pids.unshift(e.knownTarget);for(var i=0;i1e3?1e3:this.ttl_ms)}return true};Deduplicator.prototype.expireMessages=function(){var now=+new Date;while(this.queue.length>0&&this.queue[0][0]<=now){var entry=this.queue.shift();delete this.map[entry[1]]}if(this.queue.length===0){clearInterval(this.timerId);this.timerId=null}};function Ground(bootFn){var self=this;this.stepperId=null;World.withWorldStack([[this,-1]],function(){self.world=new World(bootFn)})}Ground.prototype.step=function(){var self=this;return World.withWorldStack([[this,-1]],function(){return self.world.step()})};Ground.prototype.checkPid=function(pid){if(pid!==-1)console.error("Weird pid in Ground markPidRunnable",pid)};Ground.prototype.markPidRunnable=function(pid){this.checkPid(pid);this.startStepping()};Ground.prototype.startStepping=function(){var self=this;if(this.stepperId)return;if(this.step()){this.stepperId=setTimeout(function(){self.stepperId=null;self.startStepping()},0)}};Ground.prototype.stopStepping=function(){if(this.stepperId){clearTimeout(this.stepperId);this.stepperId=null}};Ground.prototype.enqueueAction=function(pid,action){this.checkPid(pid);if(action.type==="routes"){if(!action.gestalt.isEmpty()){console.error("You have subscribed to a nonexistent event source.",action.gestalt.pretty())}}else{console.error("You have sent a message into the outer void.",action)}};module.exports.__=__;module.exports._$=_$;module.exports.sub=sub;module.exports.pub=pub;module.exports.spawn=spawn;module.exports.updateRoutes=updateRoutes;module.exports.sendMessage=sendMessage;module.exports.shutdownWorld=shutdownWorld;module.exports.World=World;module.exports.DemandMatcher=DemandMatcher;module.exports.Deduplicator=Deduplicator;module.exports.Ground=Ground;module.exports.Route=Route},{"./route.js":5}],5:[function(_dereq_,module,exports){var __="__";var SOA="__[";var EOA="__]";function die(message){throw new Error(message)}function $Embedded(matcher){this.matcher=matcher}function embeddedMatcher(matcher){return new $Embedded(matcher)}function $Capture(pattern){this.pattern=typeof pattern==="undefined"?__:pattern}function _$(pattern){return new $Capture(pattern)}function isCapture(x){return x instanceof $Capture||x===_$}function capturePattern(x){return x instanceof $Capture?x.pattern:__}var SOC="__{{";var EOC="__}}";function $Success(value){this.value=value}function $WildcardSequence(matcher){this.matcher=matcher}function $Dict(){this.length=0;this.entries={}}$Dict.prototype.get=function(key){return this.entries[key]||emptyMatcher};$Dict.prototype.set=function(key,val){if(!(key in this.entries))this.length++;this.entries[key]=val};$Dict.prototype.clear=function(key){if(key in this.entries)this.length--;delete this.entries[key]};$Dict.prototype.isEmpty=function(){return this.length===0};$Dict.prototype.copy=function(){var other=new $Dict;other.length=this.length;for(var key in this.entries){if(this.entries.hasOwnProperty(key)){other.entries[key]=this.entries[key]}}return other};$Dict.prototype.emptyGuard=function(){if(this.isEmpty())return emptyMatcher;return this};$Dict.prototype.has=function(key){return key in this.entries};$Dict.prototype.sortedKeys=function(){var ks=[];for(var k in this.entries)ks.push(k);ks.sort();return ks};function is_emptyMatcher(m){return m===emptyMatcher}var emptyMatcher=null;function rsuccess(v){return v===emptyMatcher?emptyMatcher:new $Success(v)}function rseq(e,r){if(r===emptyMatcher)return emptyMatcher;var s=new $Dict;s.set(e,r);return s}function rwild(r){return rseq(__,r)}function rwildseq(r){return r===emptyMatcher?emptyMatcher:new $WildcardSequence(r)}function compilePattern(v,p){if(!p)die("compilePattern: missing pattern");return walk(p,rseq(EOA,rsuccess(v)));function walk(p,acc){if(p===__)return rwild(acc);if(Array.isArray(p)){acc=rseq(EOA,acc);for(var i=p.length-1;i>=0;i--){acc=walk(p[i],acc)}return rseq(SOA,acc)}if(p instanceof $Embedded){return appendMatcher(p.matcher,function(v){return acc})}else{return rseq(JSON.stringify(p),acc)}}}function shallowCopyArray(s){return s.slice()}function rupdateInplace(r,key,k){if(is_emptyMatcher(k)){r.clear(key)}else{r.set(key,k)}}function matcherEquals(a,b){if(a===null){return b===null}if(b===null)return false;if(a instanceof $WildcardSequence){if(!(b instanceof $WildcardSequence))return false;a=a.matcher;b=b.matcher}else if(b instanceof $WildcardSequence)return false;if(a instanceof $Success){if(!(b instanceof $Success))return false;return valuesEqual(a.value,b.value)}if(b instanceof $Success)return false;for(var key in a.entries){if(!b.has(key))return false;if(!matcherEquals(a.entries[key],b.entries[key]))return false}return true}function is_keyOpen(k){return k===SOA}function is_keyClose(k){return k===EOA}function is_keyNormal(k){return!(is_keyOpen(k)||is_keyClose(k))}function arrayToSet(xs){var s={};for(var i=0;i=spec.length){if(isCapturing)die("Bad specification: unclosed capture");if(m instanceof $Success){return rseq(EOA,rsuccess(projectSuccess(m.value)))}else{return emptyMatcher}}if(is_emptyMatcher(m))return emptyMatcher;var item=spec[specIndex];var nextIndex=specIndex+1;if(item===EOC){if(!isCapturing)die("Bad specification: unepxected EOC");return walk(false,m,nextIndex)}if(item===SOC){if(isCapturing)die("Bad specification: nested capture");return walk(true,m,nextIndex)}if(item===__){if(m instanceof $WildcardSequence){if(isCapturing){return rwild(walk(isCapturing,m,nextIndex))}else{return walk(isCapturing,m,nextIndex)}}if(m instanceof $Success){return emptyMatcher}var target;if(isCapturing){target=new $Dict;rupdateInplace(target,__,walk(isCapturing,m.get(__),nextIndex));for(var key in m.entries){if(key!==__){var mk=m.get(key);if(is_keyOpen(key)){function cont(mk2){return walk(isCapturing,mk2,nextIndex)}rupdateInplace(target,key,captureNested(mk,cont))}else if(is_keyClose(key)){}else{rupdateInplace(target,key,walk(isCapturing,mk,nextIndex))}}}}else{target=walk(isCapturing,m.get(__),nextIndex);for(var key in m.entries){if(key!==__){var mk=m.get(key);if(is_keyOpen(key)){function cont(mk2){return walk(isCapturing,mk2,nextIndex)}target=union(target,skipNested(mk,cont))}else if(is_keyClose(key)){}else{target=union(target,walk(isCapturing,mk,nextIndex))}}}}return target}var result;if(m instanceof $WildcardSequence){if(is_keyOpen(item)){result=walk(isCapturing,rwildseq(m),nextIndex)}else if(is_keyClose(item)){result=walk(isCapturing,m.matcher,nextIndex)}else{result=walk(isCapturing,m,nextIndex)}}else if(m instanceof $Success){result=emptyMatcher}else{if(is_keyOpen(item)){result=walk(isCapturing,rwildseq(m.get(__)),nextIndex)}else if(is_keyClose(item)){result=emptyMatcher}else{result=walk(isCapturing,m.get(__),nextIndex)}result=union(result,walk(isCapturing,m.get(item),nextIndex))}if(isCapturing){result=rseq(item,result) +}return result}function captureNested(m,cont){if(m instanceof $WildcardSequence){return rwildseq(cont(m.matcher))}if(is_emptyMatcher(m)||m instanceof $Success){return emptyMatcher}var target=new $Dict;rupdateInplace(target,__,captureNested(m.get(__),cont));for(var key in m.entries){if(key!==__){var mk=m.get(key);if(is_keyOpen(key)){function cont2(mk2){return captureNested(mk2,cont)}rupdateInplace(target,key,captureNested(mk,cont2))}else if(is_keyClose(key)){rupdateInplace(target,key,cont(mk))}else{rupdateInplace(target,key,captureNested(mk,cont))}}}return target.emptyGuard()}function skipNested(m,cont){if(m instanceof $WildcardSequence){return cont(m.matcher)}if(is_emptyMatcher(m)||m instanceof $Success){return emptyMatcher}var target=skipNested(m.get(__),cont);for(var key in m.entries){if(key!==__){var mk=m.get(key);if(is_keyOpen(key)){function cont2(mk2){return skipNested(mk2,cont)}target=union(target,skipNested(mk,cont2))}else if(is_keyClose(key)){target=union(target,cont(mk))}else{target=union(target,skipNested(mk,cont))}}}return target}}function matcherKeys(m){if(is_emptyMatcher(m))return[];return walkSeq(m,function(vss,vsk){return vss});function walk(m,k){if(m instanceof $WildcardSequence)return null;if(m instanceof $Success)return[];if(m.has(__))return null;var acc=[];for(var key in m.entries){var mk=m.get(key);var piece;if(is_keyOpen(key)){function seqK(vss,vsk){var acc=[];for(var i=0;i");walk(i+4,m.matcher);return}if(m instanceof $Success){var vs=JSON.stringify(typeof m.value==="object"?setToArray(m.value):m.value);acc.push("{"+vs+"}");return}if(m.length===0){acc.push(" ::: empty hash!");return}var needSep=false;var keys=m.sortedKeys();for(var keyi=0;keyi";acc.push(key);walk(i+key.length+1,k)}}function indentStr(i){return new Array(i+1).join(" ")}}function serializeMatcher(m,serializeSuccess){return walk(m);function walk(m){if(is_emptyMatcher(m))return[];if(m instanceof $WildcardSequence){return["...)",walk(m.matcher)]}if(m instanceof $Success){return["",serializeSuccess(m.value)]}var acc=[];for(var key in m.entries){var k=m.entries[key];if(key===__)key=["__"];else if(key===SOA)key=["("];else if(key===EOA)key=[")"];else key=JSON.parse(key);acc.push([key,walk(k)])}return acc}}function deserializeMatcher(r,deserializeSuccess){return walk(r);function walk(r){if(r.length===0)return emptyMatcher;if(r[0]==="...)")return rwildseq(walk(r[1]));if(r[0]==="")return rsuccess(deserializeSuccess(r[1]));var acc=new $Dict;for(var i=0;i0){while(metaLevels.length0?this.union1(gestaltUnion(arguments)):this};function telescopeLevels(levels){var result=shallowCopyArray(levels);for(var i=result.length-2;i>=0;i--){result[i]=new GestaltLevel(union(result[i].subscriptions,result[i+1].subscriptions),union(result[i].advertisements,result[i+1].advertisements))}return result}Gestalt.prototype.telescoped=function(){var mls=[];for(var i=0;i0){while(outputMetaLevels.lengththis.period*1.5){World.send(this.message)}this.mostRecentTrigger=now};module.exports.WakeDetector=WakeDetector},{"./minimart.js":4}],9:[function(_dereq_,module,exports){var Minimart=_dereq_("./minimart.js");var Route=Minimart.Route;var World=Minimart.World;var sub=Minimart.sub;var pub=Minimart.pub;var __=Minimart.__;var _$=Minimart._$;var DEFAULT_RECONNECT_DELAY=100;var MAX_RECONNECT_DELAY=3e4;var DEFAULT_IDLE_TIMEOUT=3e5;var DEFAULT_PING_INTERVAL=DEFAULT_IDLE_TIMEOUT-1e4;function WebSocketConnection(label,wsurl,shouldReconnect){this.label=label;this.sendsAttempted=0;this.sendsTransmitted=0;this.receiveCount=0;this.sock=null;this.wsurl=wsurl;this.shouldReconnect=shouldReconnect?true:false;this.reconnectDelay=DEFAULT_RECONNECT_DELAY;this.localGestalt=Route.emptyGestalt;this.peerGestalt=Route.emptyGestalt;this.prevLocalRoutesMessage=null;this.prevPeerRoutesMessage=null;this.deduplicator=new Minimart.Deduplicator;this.connectionCount=0;this.activityTimestamp=0;this.idleTimeout=DEFAULT_IDLE_TIMEOUT;this.pingInterval=DEFAULT_PING_INTERVAL;this.idleTimer=null;this.pingTimer=null}WebSocketConnection.prototype.clearHeartbeatTimers=function(){if(this.idleTimer){clearTimeout(this.idleTimer);this.idleTimer=null}if(this.pingTimer){clearTimeout(this.pingTimer);this.pingTimer=null}};WebSocketConnection.prototype.recordActivity=function(){var self=this;this.activityTimestamp=+new Date;this.clearHeartbeatTimers();this.idleTimer=setTimeout(function(){self.forceclose()},this.idleTimeout);this.pingTimer=setTimeout(function(){self.safeSend(JSON.stringify("ping"))},this.pingInterval)};WebSocketConnection.prototype.statusRoute=function(status){return pub([this.label+"_state",status])};WebSocketConnection.prototype.relayGestalt=function(){return this.statusRoute(this.isConnected()?"connected":"disconnected").union(pub([this.label,__,__],0,10)).union(sub([this.label,__,__],0,10))};WebSocketConnection.prototype.aggregateGestalt=function(){var self=this;return this.peerGestalt.transform(function(m,metaLevel){return Route.compilePattern(true,[self.label,metaLevel,Route.embeddedMatcher(m)])}).union(this.relayGestalt())};WebSocketConnection.prototype.boot=function(){this.reconnect()};WebSocketConnection.prototype.trapexit=function(){this.forceclose()};WebSocketConnection.prototype.isConnected=function(){return this.sock&&this.sock.readyState===this.sock.OPEN};WebSocketConnection.prototype.safeSend=function(m){try{this.sendsAttempted++;if(this.isConnected()){this.sock.send(m);this.sendsTransmitted++}}catch(e){console.warn("Trapped exn while sending",e)}};WebSocketConnection.prototype.sendLocalRoutes=function(){var newLocalRoutesMessage=JSON.stringify(encodeEvent(Minimart.updateRoutes([this.localGestalt])));if(this.prevLocalRoutesMessage!==newLocalRoutesMessage){this.prevLocalRoutesMessage=newLocalRoutesMessage;this.safeSend(newLocalRoutesMessage)}};WebSocketConnection.prototype.collectMatchers=function(getAdvertisements,level,g){var extractMetaLevels=Route.compileProjection([this.label,_$,__]);var mls=Route.matcherKeys(g.project(extractMetaLevels,getAdvertisements,0,level));for(var i=0;iMAX_RECONNECT_DELAY?MAX_RECONNECT_DELAY+Math.random()*1e3:this.reconnectDelay}};function encodeEvent(e){switch(e.type){case"routes":return["routes",e.gestalt.serialize(function(v){return true})];case"message":return["message",e.message,e.metaLevel,e.isFeedback]}}function decodeAction(j){switch(j[0]){case"routes":return Minimart.updateRoutes([Route.deserializeGestalt(j[1],function(v){return true})]);case"message":return Minimart.sendMessage(j[1],j[2],j[3]);default:throw{message:"Invalid JSON-encoded action: "+JSON.stringify(j)}}}module.exports.WebSocketConnection=WebSocketConnection;module.exports.encodeEvent=encodeEvent;module.exports.decodeAction=decodeAction},{"./minimart.js":4}]},{},[3])(3)}); \ No newline at end of file diff --git a/examples/chat/index.html b/examples/chat/index.html index 01fee0e..b0a816f 100644 --- a/examples/chat/index.html +++ b/examples/chat/index.html @@ -3,33 +3,15 @@ JS Marketplace: Chat Example - - - - - - - - - - - - - - +
- - - - -
diff --git a/examples/chat/index.js b/examples/chat/index.js index 97906da..997ff1c 100644 --- a/examples/chat/index.js +++ b/examples/chat/index.js @@ -1,3 +1,10 @@ +var Route = Minimart.Route; +var World = Minimart.World; +var sub = Minimart.sub; +var pub = Minimart.pub; +var __ = Minimart.__; +var _$ = Minimart._$; + function chatEvent(nym, status, utterance, stamp) { return ["chatEvent", nym, status, utterance, stamp || +(new Date())]; } @@ -18,7 +25,7 @@ function outputItem(item) { function updateNymList(g) { var statuses = {}; var nymProj = ["broker", 0, ["chatEvent", _$, _$, __, __]]; - var matchedNyms = route.matcherKeys(g.project(route.compileProjection(nymProj), true, 0, 0)); + var matchedNyms = Route.matcherKeys(g.project(Route.compileProjection(nymProj), true, 0, 0)); for (var i = 0; i < matchedNyms.length; i++) { statuses[matchedNyms[i][0]] = matchedNyms[i][1]; } @@ -55,15 +62,15 @@ $(document).ready(function () { $("#nym_form").submit(function (e) { e.preventDefault(); return false; }); if (!($("#nym").val())) { $("#nym").val("nym" + Math.floor(Math.random() * 65536)); } - G = new Ground(function () { + G = new Minimart.Ground(function () { console.log('starting ground boot'); // World.spawn(new Spy()); - spawnJQueryDriver(); - spawnDOMDriver(); - spawnRoutingTableWidget("#spy-holder", "spy"); + Minimart.JQuery.spawnJQueryDriver(); + Minimart.DOM.spawnDOMDriver(); + Minimart.RoutingTableWidget.spawnRoutingTableWidget("#spy-holder", "spy"); - World.spawn(new WakeDetector()); - var wsconn = new WebSocketConnection("broker", $("#wsurl").val(), true); + World.spawn(new Minimart.WakeDetector()); + var wsconn = new Minimart.WebSocket.WebSocketConnection("broker", $("#wsurl").val(), true); World.spawn(wsconn); World.spawn({ // Monitor connection, notifying connectivity changes @@ -74,7 +81,7 @@ $(document).ready(function () { handleEvent: function (e) { if (e.type === "routes") { var states = - route.matcherKeys(e.gestalt.project(route.compileProjection([__, _$]), + Route.matcherKeys(e.gestalt.project(Route.compileProjection([__, _$]), true, 0, 0)); var newState = states.length > 0 ? states[0][0] : "crashed"; if (this.state != newState) { diff --git a/examples/dom/index.html b/examples/dom/index.html index c3331e3..5556bdf 100644 --- a/examples/dom/index.html +++ b/examples/dom/index.html @@ -3,24 +3,11 @@ JS Marketplace: DOM Example - - - - - - - - - - - - - - + diff --git a/examples/dom/index.js b/examples/dom/index.js index 6ce479c..94c6040 100644 --- a/examples/dom/index.js +++ b/examples/dom/index.js @@ -1,10 +1,16 @@ var G; $(document).ready(function () { - G = new Ground(function () { + var World = Minimart.World; + var sub = Minimart.sub; + var pub = Minimart.pub; + var __ = Minimart.__; + var _$ = Minimart._$; + + G = new Minimart.Ground(function () { console.log('starting ground boot'); // World.spawn(new Spy("GROUND", true)); - spawnDOMDriver(); - spawnRoutingTableWidget("#spy-holder", "spy"); + Minimart.DOM.spawnDOMDriver(); + Minimart.RoutingTableWidget.spawnRoutingTableWidget("#spy-holder", "spy"); World.spawn({ handleEvent: function (e) { diff --git a/examples/smoketest/index.html b/examples/smoketest/index.html index 779a255..6422dd6 100644 --- a/examples/smoketest/index.html +++ b/examples/smoketest/index.html @@ -4,9 +4,7 @@ JS Marketplace: Smoketest - - - + diff --git a/examples/smoketest/index.js b/examples/smoketest/index.js index d3b8423..b0ee8aa 100644 --- a/examples/smoketest/index.js +++ b/examples/smoketest/index.js @@ -1,8 +1,14 @@ var G; $(document).ready(function () { - G = new Ground(function () { + var World = Minimart.World; + var sub = Minimart.sub; + var pub = Minimart.pub; + var __ = Minimart.__; + var _$ = Minimart._$; + + G = new Minimart.Ground(function () { console.log('starting ground boot'); - World.spawn(new Spy("GROUND", true)); + World.spawn(new Minimart.Spy("GROUND", true)); World.spawn({ counter: 0, handleEvent: function (e) {}, diff --git a/examples/textfield/index.html b/examples/textfield/index.html index c705756..4b1e8d3 100644 --- a/examples/textfield/index.html +++ b/examples/textfield/index.html @@ -9,16 +9,7 @@ - - - - - - - - - - + diff --git a/examples/textfield/index.js b/examples/textfield/index.js index 868c705..a097cd8 100644 --- a/examples/textfield/index.js +++ b/examples/textfield/index.js @@ -1,6 +1,13 @@ /////////////////////////////////////////////////////////////////////////// // GUI +var Route = Minimart.Route; +var World = Minimart.World; +var sub = Minimart.sub; +var pub = Minimart.pub; +var __ = Minimart.__; +var _$ = Minimart._$; + function piece(text, pos, lo, hi, cls) { return ""+ ((pos >= lo && pos < hi) @@ -16,19 +23,19 @@ function spawnGui() { sub(["fieldContents", __, __], 0, 1), sub(["highlight", __], 0, 1)]); }, - fieldContentsSpec: route.compileProjection(["fieldContents", _$, _$]), - highlightSpec: route.compileProjection(["highlight", _$]), + fieldContentsSpec: Route.compileProjection(["fieldContents", _$, _$]), + highlightSpec: Route.compileProjection(["highlight", _$]), handleEvent: function (e) { switch (e.type) { case "routes": var text = "", pos = 0, highlight = false; // BUG: escape text! - var fc = route.matcherKeys(e.gestalt.project(this.fieldContentsSpec, true)); + var fc = Route.matcherKeys(e.gestalt.project(this.fieldContentsSpec, true)); if (fc.length > 0) { text = fc[0][0]; pos = fc[0][1]; } - var hl = route.matcherKeys(e.gestalt.project(this.highlightSpec, true)); + var hl = Route.matcherKeys(e.gestalt.project(this.highlightSpec, true)); if (hl.length > 0) { highlight = hl[0][0]; } @@ -112,7 +119,7 @@ function spawnSearch() { World.spawn({ fieldContents: "", highlight: false, - fieldContentsSpec: route.compileProjection(["fieldContents", _$, _$]), + fieldContentsSpec: Route.compileProjection(["fieldContents", _$, _$]), boot: function () { World.updateRoutes(this.subscriptions()); }, @@ -137,7 +144,7 @@ function spawnSearch() { handleEvent: function (e) { switch (e.type) { case "routes": - var fc = route.matcherKeys(e.gestalt.project(this.fieldContentsSpec, true)); + var fc = Route.matcherKeys(e.gestalt.project(this.fieldContentsSpec, true)); if (fc.length > 0) { this.fieldContents = fc[0][0]; } @@ -157,10 +164,10 @@ function spawnSearch() { var G; $(document).ready(function () { - G = new Ground(function () { - spawnJQueryDriver(); - spawnDOMDriver(); - spawnRoutingTableWidget("#spy-holder", "spy"); + G = new Minimart.Ground(function () { + Minimart.JQuery.spawnJQueryDriver(); + Minimart.DOM.spawnDOMDriver(); + Minimart.RoutingTableWidget.spawnRoutingTableWidget("#spy-holder", "spy"); spawnGui(); spawnModel(); diff --git a/package.json b/package.json new file mode 100644 index 0000000..b17c311 --- /dev/null +++ b/package.json @@ -0,0 +1,22 @@ +{ + "name": "js-marketplace", + "version": "0.0.0", + "description": "Network Calculus in the browser", + "homepage": "https://github.com/tonyg/js-marketplace", + "main": "src/main.js", + "scripts": { + "clean": "rm -f dist/*", + "build-debug": "browserify src/main.js -d -s Minimart -o dist/minimart.js", + "build-min": "browserify src/main.js -s Minimart -o dist/_minimart.js && uglifyjs dist/_minimart.js -o dist/minimart.min.js && rm dist/_minimart.js", + "build": "npm run build-debug && npm run build-min", + "watch": "watchify src/main.js -d -s Minimart -o dist/minimart.js", + "prepublish": "npm run build" + }, + "author": "Tony Garnock-Jones ", + "devDependencies": { + "watchify": "^0.6.1", + "uglify-js": "^2.4.12", + "browserify": "^3.30.4", + "mocha": "^1.17.1" + } +} diff --git a/route.js b/route.js deleted file mode 100644 index 895427c..0000000 --- a/route.js +++ /dev/null @@ -1,1531 +0,0 @@ -/* Routing */ - -function Routing(exports) { - - var __ = "__"; /* wildcard marker */ - - var SOA = "__["; // start of array - var EOA = "__]"; // end of array - - function die(message) { - throw new Error(message); - } - - function $Embedded(matcher) { - this.matcher = matcher; - } - - function embeddedMatcher(matcher) { - return new $Embedded(matcher); - } - - // The pattern argument defaults to wildcard, __. - function $Capture(pattern) { - this.pattern = (typeof pattern === 'undefined' ? __ : pattern); - } - - // Abbreviation: _$(x) <==> new $Capture(x) - function _$(pattern) { - return new $Capture(pattern); - } - - function isCapture(x) { return x instanceof $Capture || x === _$; } - function capturePattern(x) { return x instanceof $Capture ? x.pattern : __; } - - var SOC = "__{{"; // start of capture - var EOC = "__}}"; // end of capture - - function $Success(value) { - this.value = value; - } - - function $WildcardSequence(matcher) { - this.matcher = matcher; - } - - function $Dict() { - this.length = 0; - this.entries = {}; - } - - $Dict.prototype.get = function (key) { - return this.entries[key] || emptyMatcher; - }; - - $Dict.prototype.set = function (key, val) { - if (!(key in this.entries)) this.length++; - this.entries[key] = val; - }; - - $Dict.prototype.clear = function (key) { - if (key in this.entries) this.length--; - delete this.entries[key]; - }; - - $Dict.prototype.isEmpty = function () { - return this.length === 0; - }; - - $Dict.prototype.copy = function () { - var other = new $Dict(); - other.length = this.length; - for (var key in this.entries) { - if (this.entries.hasOwnProperty(key)) { - other.entries[key] = this.entries[key]; - } - } - return other; - }; - - $Dict.prototype.emptyGuard = function () { - if (this.isEmpty()) return emptyMatcher; - return this; - }; - - $Dict.prototype.has = function (key) { - return key in this.entries; - }; - - $Dict.prototype.sortedKeys = function () { - var ks = []; - for (var k in this.entries) ks.push(k); - ks.sort(); - return ks; - } - - function is_emptyMatcher(m) { - return (m === emptyMatcher); - } - - /////////////////////////////////////////////////////////////////////////// - // Constructors - - var emptyMatcher = null; - - function rsuccess(v) { - return (v === emptyMatcher) ? emptyMatcher : new $Success(v); - } - - function rseq(e, r) { - if (r === emptyMatcher) return emptyMatcher; - var s = new $Dict(); - s.set(e, r); - return s; - } - - function rwild(r) { - return rseq(__, r); - } - - function rwildseq(r) { - return (r === emptyMatcher) ? emptyMatcher : new $WildcardSequence(r); - } - - /////////////////////////////////////////////////////////////////////////// - - function compilePattern(v, p) { - if (!p) die("compilePattern: missing pattern"); - return walk(p, rseq(EOA, rsuccess(v))); - - function walk(p, acc) { - if (p === __) return rwild(acc); - - if (Array.isArray(p)) { - acc = rseq(EOA, acc); - for (var i = p.length - 1; i >= 0; i--) { - acc = walk(p[i], acc); - } - return rseq(SOA, acc); - } - - if (p instanceof $Embedded) { - return appendMatcher(p.matcher, function (v) { return acc; }); - } else { - return rseq(JSON.stringify(p), acc); - } - } - } - - function shallowCopyArray(s) { - return s.slice(); - } - - function rupdateInplace(r, key, k) { - if (is_emptyMatcher(k)) { - r.clear(key); - } else { - r.set(key, k); - } - } - - function matcherEquals(a, b) { - if (a === null) { - return (b === null); - } - if (b === null) return false; - - if (a instanceof $WildcardSequence) { - if (!(b instanceof $WildcardSequence)) return false; - a = a.matcher; - b = b.matcher; - } else if (b instanceof $WildcardSequence) return false; - - if (a instanceof $Success) { - if (!(b instanceof $Success)) return false; - return valuesEqual(a.value, b.value); - } - if (b instanceof $Success) return false; - - for (var key in a.entries) { - if (!b.has(key)) return false; - if (!matcherEquals(a.entries[key], b.entries[key])) return false; - } - return true; - } - - function is_keyOpen(k) { - return k === SOA; - } - - function is_keyClose(k) { - return k === EOA; - } - - function is_keyNormal(k) { - return !(is_keyOpen(k) || is_keyClose(k)); - } - - /////////////////////////////////////////////////////////////////////////// - // Enough of sets to get by with - - function arrayToSet(xs) { - var s = {}; - for (var i = 0; i < xs.length; i++) { - s[JSON.stringify(xs[i])] = xs[i]; - } - return s; - } - - function setToArray(s) { - var r = []; - for (var k in s) r.push(s[k]); - return r; - } - - function setUnion(s1, s2) { - var s = {}; - setUnionInplace(s, s1); - setUnionInplace(s, s2); - return s; - } - - function is_emptySet(s) { - for (var k in s) { - if (s.hasOwnProperty(k)) - return false; - } - return true; - } - - function setSubtract(s1, s2) { - var s = {}; - for (var key in s1) { - if (s1.hasOwnProperty(key) && !s2.hasOwnProperty(key)) { - s[key] = s1[key]; - } - } - return s; - } - - function setIntersect(s1, s2) { - var s = {}; - for (var key in s1) { - if (s1.hasOwnProperty(key) && s2.hasOwnProperty(key)) { - s[key] = s1[key]; - } - } - return s; - } - - function setUnionInplace(acc, s) { - for (var key in s) { - if (s.hasOwnProperty(key)) { - acc[key] = s[key]; - } - } - } - - function setEqual(s1, s2) { - for (var key in s1) { - if (s1.hasOwnProperty(key)) { - if (s1[key] !== s2[key]) return false; - } - } - for (var key in s2) { - if (s2.hasOwnProperty(key)) { - if (s1[key] !== s2[key]) return false; - } - } - return true; - } - - /////////////////////////////////////////////////////////////////////////// - - var unionSuccesses = function (v1, v2) { - if (v1 === true) return v2; - if (v2 === true) return v1; - return setUnion(v1, v2); - }; - - var intersectSuccesses = function (v1, v2) { - return v1; - }; - - var erasePathSuccesses = function (v1, v2) { - var r = setSubtract(v1, v2); - if (is_emptySet(r)) return null; - return r; - }; - - var matchMatcherSuccesses = function (v1, v2, acc) { - setUnionInplace(acc, v2); - }; - - var projectSuccess = function (v) { - return v; - }; - - var valuesEqual = function (a, b) { - return setEqual(a, b); - }; - - /////////////////////////////////////////////////////////////////////////// - - function expandWildseq(r) { - return union(rwild(rwildseq(r)), rseq(EOA, r)); - } - - function union(o1, o2) { - return merge(o1, o2); - - function merge(o1, o2) { - if (is_emptyMatcher(o1)) return o2; - if (is_emptyMatcher(o2)) return o1; - return walk(o1, o2); - } - - function walk(r1, r2) { - if (r1 instanceof $WildcardSequence) { - if (r2 instanceof $WildcardSequence) { - return rwildseq(walk(r1.matcher, r2.matcher)); - } - r1 = expandWildseq(r1.matcher); - } else if (r2 instanceof $WildcardSequence) { - r2 = expandWildseq(r2.matcher); - } - - if (r1 instanceof $Success && r2 instanceof $Success) { - return rsuccess(unionSuccesses(r1.value, r2.value)); - } - - var w = merge(r1.get(__), r2.get(__)); - if (is_emptyMatcher(w)) { - var smaller = r1.length < r2.length ? r1 : r2; - var larger = r1.length < r2.length ? r2 : r1; - var target = larger.copy(); - for (var key in smaller.entries) { - var k = merge(smaller.get(key), larger.get(key)); - rupdateInplace(target, key, k); - } - return target.emptyGuard(); - } else { - function examineKey(rA, key, rB) { - if ((key !== __) && !target.has(key)) { - var k = merge(rA.get(key), rB.get(key)); - if (is_keyOpen(key)) { - rupdateInplace(target, key, merge(rwildseq(w), k)); - } else if (is_keyClose(key)) { - if (w instanceof $WildcardSequence) { - rupdateInplace(target, key, merge(w.matcher, k)); - } else { - rupdateInplace(target, key, k); - } - } else { - rupdateInplace(target, key, merge(w, k)); - } - } - } - var target = rwild(w).copy(); - for (var key in r1.entries) { examineKey(r1, key, r2); } - for (var key in r2.entries) { examineKey(r2, key, r1); } - return target; - } - } - } - - function unionN() { - var acc = emptyMatcher; - for (var i = 0; i < arguments.length; i++) { - acc = union(acc, arguments[i]); - } - return acc; - } - - function intersect(o1, o2) { - if (is_emptyMatcher(o1)) return emptyMatcher; - if (is_emptyMatcher(o2)) return emptyMatcher; - return walk(o1, o2); - - function walkFlipped(r2, r1) { return walk(r1, r2); } - - function walk(r1, r2) { - // INVARIANT: r1 is a part of the original o1, and - // likewise for r2. This is so that the first arg to - // intersectSuccesses always comes from r1, and the second - // from r2. - if (is_emptyMatcher(r1)) return emptyMatcher; - if (is_emptyMatcher(r2)) return emptyMatcher; - - if (r1 instanceof $WildcardSequence) { - if (r2 instanceof $WildcardSequence) { - return rwildseq(walk(r1.matcher, r2.matcher)); - } - r1 = expandWildseq(r1.matcher); - } else if (r2 instanceof $WildcardSequence) { - r2 = expandWildseq(r2.matcher); - } - - if (r1 instanceof $Success && r2 instanceof $Success) { - return rsuccess(intersectSuccesses(r1.value, r2.value)); - } - - var w1 = r1.get(__); - var w2 = r2.get(__); - var w = walk(w1, w2); - - var target = new $Dict(); - - function examineKey(key) { - if ((key !== __) && !target.has(key)) { - var k1 = r1.get(key); - var k2 = r2.get(key); - if (is_emptyMatcher(k1)) { - if (is_emptyMatcher(k2)) { - rupdateInplace(target, key, emptyMatcher); - } else { - rupdateInplace(target, key, walkWild(walk, w1, key, k2)); - } - } else { - if (is_emptyMatcher(k2)) { - rupdateInplace(target, key, walkWild(walkFlipped, w2, key, k1)); - } else { - rupdateInplace(target, key, walk(k1, k2)); - } - } - } - } - - if (is_emptyMatcher(w1)) { - if (is_emptyMatcher(w2)) { - for (var key in (r1.length < r2.length ? r1 : r2).entries) examineKey(key); - } else { - for (var key in r1.entries) examineKey(key); - } - } else { - if (is_emptyMatcher(w2)) { - for (var key in r2.entries) examineKey(key); - } else { - rupdateInplace(target, __, w); - for (var key in r1.entries) examineKey(key); - for (var key in r2.entries) examineKey(key); - } - } - return target.emptyGuard(); - } - - function walkWild(walker, w, key, k) { - if (is_emptyMatcher(w)) return emptyMatcher; - if (is_keyOpen(key)) return walker(rwildseq(w), k); - if (is_keyClose(key)) { - if (w instanceof $WildcardSequence) return walker(w.matcher, k); - return emptyMatcher; - } - return walker(w, k); - } - } - - // Removes r2's mappings from r1. Assumes r2 has previously been - // union'd into r1. The erasePathSuccesses function should return - // null to signal "no remaining success values". - function erasePath(o1, o2) { - return walk(o1, o2); - - function walk(r1, r2) { - if (is_emptyMatcher(r1)) { - return emptyMatcher; - } else { - if (is_emptyMatcher(r2)) { - return r1; - } - } - - if (r1 instanceof $WildcardSequence) { - if (r2 instanceof $WildcardSequence) { - return rwildseq(walk(r1.matcher, r2.matcher)); - } - r1 = expandWildseq(r1.matcher); - } else if (r2 instanceof $WildcardSequence) { - r2 = expandWildseq(r2.matcher); - } - - if (r1 instanceof $Success && r2 instanceof $Success) { - return rsuccess(erasePathSuccesses(r1.value, r2.value)); - } - - var w1 = r1.get(__); - var w2 = r2.get(__); - var w = walk(w1, w2); - var target; - - function examineKey(key) { - if (key !== __) { - var k1 = r1.get(key); - var k2 = r2.get(key); - var updatedK; - if (is_emptyMatcher(k2)) { - updatedK = walkWild(key, k1, w2); - } else { - updatedK = walk(k1, k2); - } - // Here we ensure a "minimal" remainder in cases - // where after an erasure, a particular key's - // continuation is the same as the wildcard's - // continuation. TODO: the matcherEquals check may - // be expensive. If so, how can it be made - // cheaper? - if (is_keyOpen(key)) { - rupdateInplace(target, key, - ((updatedK instanceof $WildcardSequence) && - matcherEquals(updatedK.matcher, w)) - ? emptyMatcher - : updatedK); - } else if (is_keyClose(key)) { - // We take care of this case later, after the - // target is fully constructed/rebuilt. - rupdateInplace(target, key, updatedK); - } else { - rupdateInplace(target, key, - (matcherEquals(updatedK, w) ? emptyMatcher : updatedK)); - } - } - } - - if (is_emptyMatcher(w2)) { - target = r1.copy(); - for (var key in r2.entries) examineKey(key); - } else { - target = new $Dict(); - rupdateInplace(target, __, w); - for (var key in r1.entries) examineKey(key); - for (var key in r2.entries) examineKey(key); - } - - // Here, the target is complete. If it has only two keys, - // one wild and one is_keyClose, and wild's continuation - // is a $WildcardSequence and the other continuation is - // identical to the sequence's continuation, then replace - // the whole thing with a nested $WildcardSequence. - // (We know w === target.get(__) from before.) - // - // TODO: I suspect actually this applies even if there are - // more than two keys, so long as all their continuations - // are identical and there's at least one is_keyClose - // alongside a wild. - if (target.length === 2) { - var finalW = target.get(__); - if (finalW instanceof $WildcardSequence) { - for (var key in target.entries) { - if ((key !== __) && is_keyClose(key)) { - var k = target.get(key); - if (matcherEquals(k, finalW.matcher)) { - return finalW; - } - } - } - } - } - - return target.emptyGuard(); - } - - function walkWild(key, k, w) { - if (is_emptyMatcher(w)) return k; - if (is_keyOpen(key)) return walk(k, rwildseq(w)); - if (is_keyClose(key)) { - if (w instanceof $WildcardSequence) return walk(k, w.matcher); - return k; - } - return walk(k, w); - } - } - - // Returns null on failed match, otherwise the appropriate success - // value contained in the matcher r. - function matchValue(r, v) { - var failureResult = null; - - var vs = [v]; - var stack = [[]]; - - while (!is_emptyMatcher(r)) { - if (r instanceof $WildcardSequence) { - if (stack.length === 0) return failureResult; - vs = stack.pop(); - r = r.matcher; - continue; - } - - if (r instanceof $Success) { - if (vs.length === 0 && stack.length === 0) return r.value; - return failureResult; - } - - if (vs.length === 0) { - if (stack.length === 0) return failureResult; - vs = stack.pop(); - r = r.get(EOA); - continue; - } - - var v = vs.shift(); - - if (typeof v === 'string' && v.substring(0, 2) === '__') { - die("Cannot match special string starting with __"); - } - - if (Array.isArray(v)) { - if (SOA in r.entries) { - r = r.get(SOA); - stack.push(vs); - vs = shallowCopyArray(v); - } else { - r = r.get(__); - } - } else { - var key; - try { - key = JSON.stringify(v); - } catch (exn) { - // For example, v might be cyclic, as in DOM events. - key = null; - } - if (key in r.entries) { - r = r.get(key); - } else { - r = r.get(__); - } - } - } - - return failureResult; - } - - // TODO: better name for this - function matchMatcher(o1, o2, seed) { - var acc = typeof seed === 'undefined' ? {} : seed; // will be modified in place - walk(o1, o2); - return acc; - - function walkFlipped(r2, r1) { return walk(r1, r2); } - - function walk(r1, r2) { - if (is_emptyMatcher(r1) || is_emptyMatcher(r2)) return; - - if (r1 instanceof $WildcardSequence) { - if (r2 instanceof $WildcardSequence) { - walk(r1.matcher, r2.matcher); - return; - } - r1 = expandWildseq(r1.matcher); - } else if (r2 instanceof $WildcardSequence) { - r2 = expandWildseq(r2.matcher); - } - - if (r1 instanceof $Success && r2 instanceof $Success) { - matchMatcherSuccesses(r1.value, r2.value, acc); - return; - } - - var w1 = r1.get(__); - var w2 = r2.get(__); - walk(w1, w2); - - function examineKey(key) { - if (key !== __) { - var k1 = r1.get(key); - var k2 = r2.get(key); - if (is_emptyMatcher(k1)) { - if (is_emptyMatcher(k2)) { - return; - } else { - walkWild(walk, w1, key, k2); - } - } else { - if (is_emptyMatcher(k2)) { - walkWild(walkFlipped, w2, key, k1); - } else { - walk(k1, k2); - } - } - } - } - - // Optimize similarly to intersect(). - if (is_emptyMatcher(w1)) { - if (is_emptyMatcher(w2)) { - for (var key in (r1.length < r2.length ? r1 : r2).entries) examineKey(key); - } else { - for (var key in r1.entries) examineKey(key); - } - } else { - if (is_emptyMatcher(w2)) { - for (var key in r2.entries) examineKey(key); - } else { - for (var key in r1.entries) examineKey(key); - for (var key in r2.entries) examineKey(key); - } - } - } - - function walkWild(walker, w, key, k) { - if (is_emptyMatcher(w)) return; - if (is_keyOpen(key)) { - walker(rwildseq(w), k); - return; - } - if (is_keyClose(key)) { - if (w instanceof $WildcardSequence) walker(w.matcher, k); - return; - } - walker(w, k); - } - } - - function appendMatcher(m, mTailFn) { - return walk(m); - - function walk(m) { - if (is_emptyMatcher(m)) return emptyMatcher; - if (m instanceof $WildcardSequence) return rwildseq(walk(m.matcher)); - if (m instanceof $Success) die("Ill-formed matcher"); - - var target = new $Dict(); - for (var key in m.entries) { - var k = m.get(key); - if (is_keyClose(key) && (k instanceof $Success)) { - target = union(target, mTailFn(k.value)); - } else { - rupdateInplace(target, key, walk(k)); - } - } - return target.emptyGuard(); - } - } - - function relabel(m, f) { - return walk(m); - - function walk(m) { - if (is_emptyMatcher(m)) return emptyMatcher; - if (m instanceof $WildcardSequence) return rwildseq(walk(m.matcher)); - if (m instanceof $Success) return rsuccess(f(m.value)); - - var target = new $Dict(); - for (var key in m.entries) { - rupdateInplace(target, key, walk(m.get(key))); - } - return target.emptyGuard(); - } - } - - function compileProjection(/* projection, projection, ... */) { - var acc = []; - for (var i = 0; i < arguments.length; i++) { - walk(arguments[i]); - } - acc.push(EOA); - return acc; - - function walk(p) { - if (isCapture(p)) { - acc.push(SOC); - walk(capturePattern(p)); - acc.push(EOC); - return; - } - - if (Array.isArray(p)) { - acc.push(SOA); - for (var i = 0; i < p.length; i++) { - walk(p[i]); - } - acc.push(EOA); - return; - } - - if (p instanceof $Embedded) { - die("Cannot embed matcher in projection"); - } else { - if (p === __) { - acc.push(p); - } else { - acc.push(JSON.stringify(p)); - } - } - } - } - - function projectionToPattern(p) { - return walk(p); - - function walk(p) { - if (isCapture(p)) return walk(capturePattern(p)); - - if (Array.isArray(p)) { - var result = []; - for (var i = 0; i < p.length; i++) { - result.push(walk(p[i])); - } - return result; - } - - if (p instanceof $Embedded) { - return p.matcher; - } else { - return p; - } - } - } - - function project(m, spec) { - return walk(false, m, 0); - - function walk(isCapturing, m, specIndex) { - if (specIndex >= spec.length) { - if (isCapturing) die("Bad specification: unclosed capture"); - if (m instanceof $Success) { - return rseq(EOA, rsuccess(projectSuccess(m.value))); - } else { - return emptyMatcher; - } - } - - if (is_emptyMatcher(m)) return emptyMatcher; - - var item = spec[specIndex]; - var nextIndex = specIndex + 1; - - if (item === EOC) { - if (!isCapturing) die("Bad specification: unepxected EOC"); - return walk(false, m, nextIndex); - } - - if (item === SOC) { - if (isCapturing) die("Bad specification: nested capture"); - return walk(true, m, nextIndex); - } - - if (item === __) { - if (m instanceof $WildcardSequence) { - if (isCapturing) { - return rwild(walk(isCapturing, m, nextIndex)); - } else { - return walk(isCapturing, m, nextIndex); - } - } - - if (m instanceof $Success) { - return emptyMatcher; - } - - var target; - if (isCapturing) { - target = new $Dict(); - rupdateInplace(target, __, walk(isCapturing, m.get(__), nextIndex)); - for (var key in m.entries) { - if (key !== __) { - var mk = m.get(key); - if (is_keyOpen(key)) { - function cont(mk2) { return walk(isCapturing, mk2, nextIndex); } - rupdateInplace(target, key, captureNested(mk, cont)); - } else if (is_keyClose(key)) { - // do nothing - } else { - rupdateInplace(target, key, walk(isCapturing, mk, nextIndex)); - } - } - } - } else { - target = walk(isCapturing, m.get(__), nextIndex); - for (var key in m.entries) { - if (key !== __) { - var mk = m.get(key); - if (is_keyOpen(key)) { - function cont(mk2) { return walk(isCapturing, mk2, nextIndex); } - target = union(target, skipNested(mk, cont)); - } else if (is_keyClose(key)) { - // do nothing - } else { - target = union(target, walk(isCapturing, mk, nextIndex)); - } - } - } - } - return target; - } - - var result; - if (m instanceof $WildcardSequence) { - if (is_keyOpen(item)) { - result = walk(isCapturing, rwildseq(m), nextIndex); - } else if (is_keyClose(item)) { - result = walk(isCapturing, m.matcher, nextIndex); - } else { - result = walk(isCapturing, m, nextIndex); - } - } else if (m instanceof $Success) { - result = emptyMatcher; - } else { - if (is_keyOpen(item)) { - result = walk(isCapturing, rwildseq(m.get(__)), nextIndex); - } else if (is_keyClose(item)) { - result = emptyMatcher; - } else { - result = walk(isCapturing, m.get(__), nextIndex); - } - result = union(result, walk(isCapturing, m.get(item), nextIndex)); - } - if (isCapturing) { - result = rseq(item, result); - } - return result; - } - - function captureNested(m, cont) { - if (m instanceof $WildcardSequence) { - return rwildseq(cont(m.matcher)); - } - - if (is_emptyMatcher(m) || (m instanceof $Success)) { - return emptyMatcher; - } - - var target = new $Dict(); - rupdateInplace(target, __, captureNested(m.get(__), cont)); - for (var key in m.entries) { - if (key !== __) { - var mk = m.get(key); - if (is_keyOpen(key)) { - function cont2(mk2) { return captureNested(mk2, cont); } - rupdateInplace(target, key, captureNested(mk, cont2)); - } else if (is_keyClose(key)) { - rupdateInplace(target, key, cont(mk)); - } else { - rupdateInplace(target, key, captureNested(mk, cont)); - } - } - } - return target.emptyGuard(); - } - - function skipNested(m, cont) { - if (m instanceof $WildcardSequence) { - return cont(m.matcher); - } - - if (is_emptyMatcher(m) || (m instanceof $Success)) { - return emptyMatcher; - } - - var target = skipNested(m.get(__), cont); - for (var key in m.entries) { - if (key !== __) { - var mk = m.get(key); - if (is_keyOpen(key)) { - function cont2(mk2) { return skipNested(mk2, cont); } - target = union(target, skipNested(mk, cont2)); - } else if (is_keyClose(key)) { - target = union(target, cont(mk)); - } else { - target = union(target, skipNested(mk, cont)); - } - } - } - return target; - } - } - - function matcherKeys(m) { - if (is_emptyMatcher(m)) return []; - return walkSeq(m, function (vss, vsk) { return vss; }); - - function walk(m, k) { - if (m instanceof $WildcardSequence) return null; - if (m instanceof $Success) return []; - if (m.has(__)) return null; - var acc = []; - for (var key in m.entries) { - var mk = m.get(key); - var piece; - if (is_keyOpen(key)) { - function seqK(vss, vsk) { - var acc = []; - for (var i = 0; i < vss.length; i++) { - var vs = vss[i]; - acc = acc.concat(k(transformSeqs(vs, key), vsk)); - } - return acc; - } - piece = walkSeq(mk, seqK); - } else if (is_keyClose(key)) { - die("matcherKeys: internal error: unexpected key-close"); - } else { - piece = k(JSON.parse(key), mk); - } - if (piece == null) return null; - acc = acc.concat(piece); - } - return acc; - } - - function walkSeq(m, k) { - if (m instanceof $WildcardSequence) return null; - if (m instanceof $Success) return k([], emptyMatcher); // TODO: ?? - if (m.has(__)) return null; - var acc = []; - for (var key in m.entries) { - var mk = m.get(key); - var piece; - if (is_keyClose(key)) { - piece = k([[]], mk); - } else { - function outerK(v, vk) { - return walkSeq(vk, innerK); - function innerK(vss, vsk) { - var acc = []; - for (var i = 0; i < vss.length; i++) { - var vs = shallowCopyArray(vss[i]); - vs.unshift(v); - acc.push(vs); - } - return k(acc, vsk); - } - } - piece = walk(rseq(key, mk), outerK); - } - if (piece == null) return null; - acc = acc.concat(piece); - } - return acc; - } - - function transformSeqs(vs, opener) { - if (opener === SOA) return vs; - die("Internal error: unknown opener " + opener); - } - } - - function prettyMatcher(m, initialIndent) { - var acc = []; - walk(initialIndent || 0, m); - return acc.join(''); - - function walk(i, m) { - if (is_emptyMatcher(m)) { - acc.push("::: no further matches possible"); - return; - } - if (m instanceof $WildcardSequence) { - acc.push("...>"); - walk(i + 4, m.matcher); - return; - } - if (m instanceof $Success) { - var vs = JSON.stringify(typeof m.value === 'object' - ? setToArray(m.value) - : m.value); - acc.push("{" + vs + "}"); - return; - } - - if (m.length === 0) { - acc.push(" ::: empty hash!"); - return; - } - - var needSep = false; - var keys = m.sortedKeys(); - for (var keyi = 0; keyi < keys.length; keyi++) { - var key = keys[keyi]; - var k = m.entries[key]; - if (needSep) { - acc.push("\n"); - acc.push(indentStr(i)); - } else { - needSep = true; - } - acc.push(" "); - if (key === __) key = '★'; - if (key === SOA) key = '<'; - if (key === EOA) key = '>'; - acc.push(key); - walk(i + key.length + 1, k); - } - } - - function indentStr(i) { - return new Array(i + 1).join(' '); // eww - } - } - - function serializeMatcher(m, serializeSuccess) { - return walk(m); - function walk(m) { - if (is_emptyMatcher(m)) return []; - if (m instanceof $WildcardSequence) { - return ["...)", walk(m.matcher)]; - } - if (m instanceof $Success) { - return ["", serializeSuccess(m.value)]; - } - var acc = []; - for (var key in m.entries) { - var k = m.entries[key]; - if (key === __) key = ["__"]; - else if (key === SOA) key = ["("]; - else if (key === EOA) key = [")"]; - else key = JSON.parse(key); - acc.push([key, walk(k)]); - } - return acc; - } - } - - function deserializeMatcher(r, deserializeSuccess) { - return walk(r); - function walk(r) { - if (r.length === 0) return emptyMatcher; - if (r[0] === "...)") return rwildseq(walk(r[1])); - if (r[0] === "") return rsuccess(deserializeSuccess(r[1])); - var acc = new $Dict(); - for (var i = 0; i < r.length; i++) { - var rkey = r[i][0]; - var rk = r[i][1]; - var key; - if (Array.isArray(rkey)) { - switch (rkey[0]) { - case "__": key = __; break; - case "(": key = SOA; break; - case ")": key = EOA; break; - default: die("Invalid serialized special key: " + rkey[0]); - } - } else { - key = JSON.stringify(rkey); - } - rupdateInplace(acc, key, walk(rk)); - } - return acc; - } - } - - /////////////////////////////////////////////////////////////////////////// - // Gestalts. - // TODO: support Infinity as a level number - - function GestaltLevel(subs, advs) { - this.subscriptions = subs; - this.advertisements = advs; - } - - GestaltLevel.prototype.isEmpty = function () { - return is_emptyMatcher(this.subscriptions) && is_emptyMatcher(this.advertisements); - }; - - GestaltLevel.prototype.equals = function (other) { - return matcherEquals(this.subscriptions, other.subscriptions) - && matcherEquals(this.advertisements, other.advertisements); - }; - - GestaltLevel.prototype.pretty = function () { - var acc = []; - if (!is_emptyMatcher(this.subscriptions)) { - acc.push(" - subs:"); - acc.push(prettyMatcher(this.subscriptions, 9)); - acc.push("\n"); - } - if (!is_emptyMatcher(this.advertisements)) { - acc.push(" - advs:"); - acc.push(prettyMatcher(this.advertisements, 9)); - acc.push("\n"); - } - return acc.join(''); - }; - - function straightGestaltLevelOp(op) { - return function (p1, p2) { - return new GestaltLevel(op(p1.subscriptions, p2.subscriptions), - op(p1.advertisements, p2.advertisements)); - }; - }; - - var emptyLevel = new GestaltLevel(emptyMatcher, emptyMatcher); - var emptyMetaLevel = []; - - function Gestalt(metaLevels) { - this.metaLevels = metaLevels; - } - - Gestalt.prototype.getMetaLevel = function (n) { - return this.metaLevels[n] || emptyMetaLevel; - }; - - Gestalt.prototype.getLevel = function (metaLevel, level) { - return this.getMetaLevel(metaLevel)[level] || emptyLevel; - }; - - Gestalt.prototype.metaLevelCount = function () { return this.metaLevels.length; }; - Gestalt.prototype.levelCount = function (n) { return this.getMetaLevel(n).length; }; - - Gestalt.prototype.matchValue = function (body, metaLevel, isFeedback) { - var levels = this.getMetaLevel(metaLevel); - var pids = {}; - for (var i = 0; i < levels.length; i++) { - var matcher = (isFeedback ? levels[i].advertisements : levels[i].subscriptions); - setUnionInplace(pids, matchValue(matcher, body)); - } - return setToArray(pids); - }; - - Gestalt.prototype.project = function (spec, getAdvertisements, metaLevel, level) { - var l = this.getLevel(metaLevel | 0, level | 0); - var matcher = (getAdvertisements ? l.advertisements : l.subscriptions); - return project(matcher, spec); - }; - - Gestalt.prototype.drop = function () { - var mls = shallowCopyArray(this.metaLevels); - mls.shift(); - return new Gestalt(mls); - }; - - Gestalt.prototype.lift = function () { - var mls = shallowCopyArray(this.metaLevels); - mls.unshift(emptyMetaLevel); - return new Gestalt(mls); - }; - - Gestalt.prototype.equals = function (other) { - if (this.metaLevels.length !== other.metaLevels.length) return false; - for (var i = 0; i < this.metaLevels.length; i++) { - var ls1 = this.metaLevels[i]; - var ls2 = other.metaLevels[i]; - if (ls1.length !== ls2.length) return false; - for (var j = 0; j < ls1.length; j++) { - var p1 = ls1[j]; - var p2 = ls2[j]; - if (!p1.equals(p2)) return false; - } - } - return true; - }; - - function simpleGestalt(isAdv, pat, metaLevel, level) { - metaLevel = metaLevel || 0; - level = level || 0; - var matcher = compilePattern(true, pat); - var l = new GestaltLevel(isAdv ? emptyMatcher : matcher, - isAdv ? matcher : emptyMatcher); - var levels = [l]; - while (level--) { levels.unshift(emptyLevel); } - var metaLevels = [levels]; - while (metaLevel--) { metaLevels.unshift(emptyMetaLevel); } - return new Gestalt(metaLevels); - } - - var emptyGestalt = new Gestalt([]); - - // Not quite what it says on the tin - the true fullGestalt - // wouldn't be parameterized on the number of levels and - // metalevels, but instead would be full at *all* levels and - // metalevels. Our representation leaks through into the interface - // here :-/ - function fullGestalt(nMetalevels, nLevels) { - var matcher = compilePattern(true, __); - var l = new GestaltLevel(matcher, matcher); - var levels = []; - while (nLevels--) { levels.push(l); } - var metaLevels = []; - while (nMetalevels--) { metaLevels.push(levels); } - return new Gestalt(metaLevels); - } - - Gestalt.prototype.isEmpty = function () { - for (var i = 0; i < this.metaLevels.length; i++) { - var levels = this.metaLevels[i]; - for (var j = 0; j < levels.length; j++) { - if (!levels[j].isEmpty()) return false; - } - } - return true; - }; - - function maybePushLevel(levels, i, level) { - if (!level.isEmpty()) { - while (levels.length < i) levels.push(emptyLevel); - levels.push(level); - } - } - - function maybePushMetaLevel(metaLevels, i, metaLevel) { - if (metaLevel.length > 0) { - while (metaLevels.length < i) metaLevels.push(emptyMetaLevel); - metaLevels.push(metaLevel); - } - } - - Gestalt.prototype.mapZip = function (other, lengthCombiner, f) { - var metaLevels = []; - var mls1 = this.metaLevels; - var mls2 = other.metaLevels; - var nm = lengthCombiner(mls1.length, mls2.length); - for (var i = 0; i < nm; i++) { - var levels = []; - var ls1 = mls1[i] || emptyMetaLevel; - var ls2 = mls2[i] || emptyMetaLevel; - var nl = lengthCombiner(ls1.length, ls2.length); - for (var j = 0; j < nl; j++) { - var p1 = ls1[j] || emptyLevel; - var p2 = ls2[j] || emptyLevel; - var p = f(p1, p2); - maybePushLevel(levels, j, p); - } - maybePushMetaLevel(metaLevels, i, levels); - } - return new Gestalt(metaLevels); - }; - - Gestalt.prototype.union1 = function (other) { - return this.mapZip(other, Math.max, straightGestaltLevelOp(union)); - }; - - function gestaltUnion(gs) { - if (gs.length === 0) return emptyGestalt; - var acc = gs[0]; - for (var i = 1; i < gs.length; i++) { - acc = acc.union1(gs[i]); - } - return acc; - } - - Gestalt.prototype.union = function () { - return arguments.length > 0 ? this.union1(gestaltUnion(arguments)) : this; - }; - - // Accumulates matchers from higher-numbered levels into - // lower-numbered levels. - function telescopeLevels(levels) { - var result = shallowCopyArray(levels); - for (var i = result.length - 2; i >= 0; i--) { - result[i] = - new GestaltLevel(union(result[i].subscriptions, result[i+1].subscriptions), - union(result[i].advertisements, result[i+1].advertisements)); - } - return result; - }; - - Gestalt.prototype.telescoped = function () { - var mls = []; - for (var i = 0; i < this.metaLevels.length; i++) { - mls.push(telescopeLevels(this.metaLevels[i])); - } - return new Gestalt(mls); - }; - - Gestalt.prototype.filter = function (perspective) { - var metaLevels = []; - var mls1 = this.metaLevels; - var mls2 = perspective.metaLevels; - var nm = Math.min(mls1.length, mls2.length); - for (var i = 0; i < nm; i++) { - var levels = []; - var ls1 = mls1[i] || emptyMetaLevel; - var ls2 = mls2[i] || emptyMetaLevel; - var nl = Math.min(ls1.length, ls2.length - 1); - for (var j = 0; j < nl; j++) { - var p1 = ls1[j] || emptyLevel; - var subs = emptyMatcher; - var advs = emptyMatcher; - for (var k = j + 1; k < ls2.length; k++) { - var p2 = ls2[k] || emptyLevel; - subs = union(subs, intersect(p1.subscriptions, p2.advertisements)); - advs = union(advs, intersect(p1.advertisements, p2.subscriptions)); - } - maybePushLevel(levels, j, new GestaltLevel(subs, advs)); - } - maybePushMetaLevel(metaLevels, i, levels); - } - return new Gestalt(metaLevels); - }; - - Gestalt.prototype.match = function (perspective) { - var pids = {}; - var nm = Math.min(this.metaLevels.length, perspective.metaLevels.length); - for (var i = 0; i < nm; i++) { - var ls1 = this.metaLevels[i] || emptyMetaLevel; - var ls2 = perspective.metaLevels[i] || emptyMetaLevel; - var nl = Math.min(ls1.length, ls2.length - 1); - for (var j = 0; j < nl; j++) { - var p1 = ls1[j] || emptyLevel; - for (var k = j + 1; k < ls2.length; k++) { - var p2 = ls2[k] || emptyLevel; - matchMatcher(p1.subscriptions, p2.advertisements, pids); - matchMatcher(p1.advertisements, p2.subscriptions, pids); - } - } - } - return setToArray(pids); - }; - - Gestalt.prototype.erasePath = function (path) { - return this.mapZip(path, Math.max, straightGestaltLevelOp(erasePath)); - }; - - function mapLevels(inputMetaLevels, f, emptyCheck, inputEmptyLevel, outputEmptyLevel) { - var outputMetaLevels = []; - for (var i = 0; i < inputMetaLevels.length; i++) { - var ls = inputMetaLevels[i]; - var levels = []; - for (var j = 0; j < ls.length; j++) { - var p = f(ls[j] || inputEmptyLevel, i, j); - if (!emptyCheck(p, i, j)) { - while (levels.length < j) levels.push(outputEmptyLevel); - levels.push(p); - } - } - if (levels.length > 0) { - while (outputMetaLevels.length < i) outputMetaLevels.push(emptyMetaLevel); - outputMetaLevels.push(levels); - } - } - return outputMetaLevels; - }; - - Gestalt.prototype.transform = function (f) { - return new Gestalt(mapLevels(this.metaLevels, function (p, ml, l) { - return new GestaltLevel(f(p.subscriptions, ml, l, false), - f(p.advertisements, ml, l, true)); - }, function (p) { - return p.isEmpty(); - }, emptyLevel, emptyLevel)); - }; - - Gestalt.prototype.stripLabel = function () { - return this.transform(function (m) { return relabel(m, function (v) { return true; }); }); - }; - - Gestalt.prototype.label = function (pid) { - var pids = arrayToSet([pid]); - return this.transform(function (m) { return relabel(m, function (v) { return pids; }); }); - }; - - Gestalt.prototype.pretty = function () { - var acc = []; - if (this.isEmpty()) { - acc.push("EMPTY GESTALT\n"); - } else { - for (var i = 0; i < this.metaLevels.length; i++) { - var ls = this.metaLevels[i]; - for (var j = 0; j < ls.length; j++) { - var p = ls[j]; - if (!p.isEmpty()) { - acc.push("GESTALT metalevel " + i + " level " + j + ":\n"); - acc.push(p.pretty()); - } - } - } - } - return acc.join(''); - }; - - Gestalt.prototype.serialize = function (serializeSuccess) { - if (typeof serializeSuccess === 'undefined') { - serializeSuccess = function (v) { return v === true ? true : setToArray(v); }; - } - return ["gestalt", mapLevels(this.metaLevels, function (p) { - return [serializeMatcher(p.subscriptions, serializeSuccess), - serializeMatcher(p.advertisements, serializeSuccess)]; - }, function (pr) { - return pr.length === 2 && pr[0].length === 0 && pr[1].length === 0; - }, emptyLevel, [[],[]])]; - }; - - function deserializeGestalt(r, deserializeSuccess) { - if (typeof deserializeSuccess === 'undefined') { - deserializeSuccess = function (v) { return v === true ? true : arrayToSet(v); }; - } - if (r[0] !== "gestalt") die("Invalid gestalt serialization: " + r); - return new Gestalt(mapLevels(r[1], function (pr) { - return new GestaltLevel(deserializeMatcher(pr[0], deserializeSuccess), - deserializeMatcher(pr[1], deserializeSuccess)); - }, function (p) { - return p.isEmpty(); - }, [[],[]], emptyLevel)); - } - - /////////////////////////////////////////////////////////////////////////// - - exports.__ = __; - exports.arrayToSet = arrayToSet; - exports.setToArray = setToArray; - exports.setUnion = setUnion; - exports.setSubtract = setSubtract; - exports.setIntersect = setIntersect; - exports.setEqual = setEqual; - exports.is_emptySet = is_emptySet; - exports.$Capture = $Capture; - exports._$ = _$; - exports.is_emptyMatcher = is_emptyMatcher; - exports.emptyMatcher = emptyMatcher; - exports.embeddedMatcher = embeddedMatcher; - exports.compilePattern = compilePattern; - exports.union = unionN; - exports.intersect = intersect; - exports.erasePath = erasePath; - exports.matchValue = matchValue; - exports.matchMatcher = matchMatcher; - exports.appendMatcher = appendMatcher; - exports.relabel = relabel; - exports.compileProjection = compileProjection; - exports.projectionToPattern = projectionToPattern; - exports.project = project; - exports.matcherKeys = matcherKeys; - exports.matcherEquals = matcherEquals; - exports.prettyMatcher = prettyMatcher; - exports.serializeMatcher = serializeMatcher; - exports.deserializeMatcher = deserializeMatcher; - - exports.GestaltLevel = GestaltLevel; - exports.Gestalt = Gestalt; - exports.simpleGestalt = simpleGestalt; - exports.emptyGestalt = emptyGestalt; - exports.fullGestalt = fullGestalt; - exports.gestaltUnion = gestaltUnion; - exports.deserializeGestalt = deserializeGestalt; -} - -if (typeof module !== 'undefined' && module.exports) { - Routing(module.exports); -} else if (window) { - window.route = {}; - Routing(window.route); -} diff --git a/routing-table-widget.css b/routing-table-widget.css deleted file mode 100644 index 2c1851b..0000000 --- a/routing-table-widget.css +++ /dev/null @@ -1,49 +0,0 @@ -.routing-table li { list-style-type: none; } - -.routing-table .sub .pattern { background-color: lightblue; } -.routing-table .sub .level { background-color: lightblue; } -.routing-table .pub .pattern { background-color: lightgreen; } -.routing-table .pub .level { background-color: lightgreen; } - -.routing-table .route { - display: inline-block; - height: 2em; -} - -.routing-table .route .level { font-style: italic; line-height: 1em; padding: 0 0.5em; } -.routing-table .route .polarity { display: none; } -.routing-table .route .pattern { padding-right: 0.5em; } - -.routing-table .route:before { - content: " "; - float: left; -} - -.routing-table .pub:before { - border-right: 0.6em solid lightgreen; - border-top: 0.75em solid transparent; - border-bottom: 0.75em solid transparent; -} - -.routing-table .sub:before { - border-left: 0.6em solid transparent; - border-top: 0.75em solid lightblue; - border-bottom: 0.75em solid lightblue; -} - -.routing-table .route:after { - content: " "; - float: right; -} - -.routing-table .pub:after { - border-left: 0.6em solid lightgreen; - border-top: 0.75em solid transparent; - border-bottom: 0.75em solid transparent; -} - -.routing-table .sub:after { - border-right: 0.6em solid transparent; - border-top: 0.75em solid lightblue; - border-bottom: 0.75em solid lightblue; -} diff --git a/dom-driver.js b/src/dom-driver.js similarity index 85% rename from dom-driver.js rename to src/dom-driver.js index 8d91755..500c131 100644 --- a/dom-driver.js +++ b/src/dom-driver.js @@ -1,7 +1,13 @@ // DOM fragment display driver +var Minimart = require("./minimart.js"); +var World = Minimart.World; +var sub = Minimart.sub; +var pub = Minimart.pub; +var __ = Minimart.__; +var _$ = Minimart._$; function spawnDOMDriver() { - var d = new DemandMatcher(["DOM", _$, _$, _$]); + var d = new Minimart.DemandMatcher(["DOM", _$, _$, _$]); d.onDemandIncrease = function (captures) { var selector = captures[0]; var fragmentClass = captures[1]; @@ -24,7 +30,7 @@ DOMFragment.prototype.boot = function () { var self = this; var monitoring = sub(["DOM", self.selector, self.fragmentClass, self.fragmentSpec], 1, 2); World.spawn(new World(function () { - spawnJQueryDriver(self.selector+" > ."+self.fragmentClass, 1); + Minimart.JQuery.spawnJQueryDriver(self.selector+" > ."+self.fragmentClass, 1); World.spawn({ handleEvent: function (e) { if (e.type === "routes") { @@ -86,3 +92,7 @@ DOMFragment.prototype.buildNodes = function () { }); return nodes; }; + +/////////////////////////////////////////////////////////////////////////// + +module.exports.spawnDOMDriver = spawnDOMDriver; diff --git a/jquery-driver.js b/src/jquery-driver.js similarity index 78% rename from jquery-driver.js rename to src/jquery-driver.js index d3aa111..bc1d8a7 100644 --- a/jquery-driver.js +++ b/src/jquery-driver.js @@ -1,8 +1,15 @@ // JQuery event driver +var Minimart = require("./minimart.js"); +var World = Minimart.World; +var sub = Minimart.sub; +var pub = Minimart.pub; +var __ = Minimart.__; +var _$ = Minimart._$; function spawnJQueryDriver(baseSelector, metaLevel) { metaLevel = metaLevel || 0; - var d = new DemandMatcher(["jQuery", _$, _$, __], metaLevel, {demandSideIsSubscription: true}); + var d = new Minimart.DemandMatcher(["jQuery", _$, _$, __], metaLevel, + {demandSideIsSubscription: true}); d.onDemandIncrease = function (captures) { var selector = captures[0]; var eventName = captures[1]; @@ -44,3 +51,7 @@ JQueryEventRouter.prototype.computeNodes = function () { return $(this.selector); } }; + +/////////////////////////////////////////////////////////////////////////// + +module.exports.spawnJQueryDriver = spawnJQueryDriver; diff --git a/src/main.js b/src/main.js new file mode 100644 index 0000000..bfbbad4 --- /dev/null +++ b/src/main.js @@ -0,0 +1,9 @@ +module.exports = require("./minimart.js"); + +module.exports.DOM = require("./dom-driver.js"); +module.exports.JQuery = require("./jquery-driver.js"); +module.exports.RoutingTableWidget = require("./routing-table-widget.js"); +module.exports.WebSocket = require("./websocket-driver.js"); + +module.exports.Spy = require("./spy.js").Spy; +module.exports.WakeDetector = require("./wake-detector.js").WakeDetector; diff --git a/marketplace.js b/src/minimart.js similarity index 89% rename from marketplace.js rename to src/minimart.js index ee2cca9..d91572a 100644 --- a/marketplace.js +++ b/src/minimart.js @@ -1,27 +1,31 @@ +var Route = require("./route.js"); + +/////////////////////////////////////////////////////////////////////////// + // TODO: trigger-guards as per minimart /*---------------------------------------------------------------------------*/ /* Events and Actions */ -var __ = route.__; -var _$ = route._$; +var __ = Route.__; +var _$ = Route._$; function sub(pattern, metaLevel, level) { - return route.simpleGestalt(false, pattern, metaLevel, level); + return Route.simpleGestalt(false, pattern, metaLevel, level); } function pub(pattern, metaLevel, level) { - return route.simpleGestalt(true, pattern, metaLevel, level); + return Route.simpleGestalt(true, pattern, metaLevel, level); } function spawn(behavior, initialGestalts) { return { type: "spawn", behavior: behavior, - initialGestalt: route.gestaltUnion(initialGestalts || []) }; + initialGestalt: Route.gestaltUnion(initialGestalts || []) }; } function updateRoutes(gestalts) { - return { type: "routes", gestalt: route.gestaltUnion(gestalts) }; + return { type: "routes", gestalt: Route.gestaltUnion(gestalts) }; } function pendingRoutingUpdate(aggregate, affectedSubgestalt, knownTarget) { @@ -49,11 +53,11 @@ function World(bootFn) { this.alive = true; this.eventQueue = []; this.runnablePids = {}; - this.partialGestalt = route.emptyGestalt; // Only gestalt from local processes - this.fullGestalt = route.emptyGestalt ;; // partialGestalt unioned with downwardGestalt + this.partialGestalt = Route.emptyGestalt; // Only gestalt from local processes + this.fullGestalt = Route.emptyGestalt ;; // partialGestalt unioned with downwardGestalt this.processTable = {}; this.tombstones = {}; - this.downwardGestalt = route.emptyGestalt; + this.downwardGestalt = Route.emptyGestalt; this.processActions = []; this.asChild(-1, bootFn, true); } @@ -134,7 +138,7 @@ World.prototype.enqueueAction = function (pid, action) { World.prototype.isInert = function () { return this.eventQueue.length === 0 && this.processActions.length === 0 - && route.is_emptySet(this.runnablePids); + && Route.is_emptySet(this.runnablePids); }; World.prototype.markPidRunnable = function (pid) { @@ -183,7 +187,7 @@ World.prototype.kill = function (pid, exn) { p.exitReason = exn; this.tombstones[pid] = p; } - this.applyAndIssueRoutingUpdate(p.gestalt, route.emptyGestalt); + this.applyAndIssueRoutingUpdate(p.gestalt, Route.emptyGestalt); } }; @@ -227,7 +231,7 @@ World.prototype.performAction = function (pid, action) { this.asChild(pid, function () { action.behavior.boot() }); this.markPidRunnable(pid); } - this.applyAndIssueRoutingUpdate(route.emptyGestalt, newGestalt, pid); + this.applyAndIssueRoutingUpdate(Route.emptyGestalt, newGestalt, pid); break; case "routes": if (pid in this.processTable) { @@ -391,8 +395,8 @@ function DemandMatcher(projection, metaLevel, options) { supplyLevel: 0, demandSideIsSubscription: false }, options); - this.pattern = route.projectionToPattern(projection); - this.projectionSpec = route.compileProjection(projection); + this.pattern = Route.projectionToPattern(projection); + this.projectionSpec = Route.compileProjection(projection); this.metaLevel = metaLevel | 0; this.demandLevel = options.demandLevel; this.supplyLevel = options.supplyLevel; @@ -428,12 +432,12 @@ DemandMatcher.prototype.handleGestalt = function (gestalt) { this.demandSideIsSubscription, this.metaLevel, this.supplyLevel); - var newDemand = route.arrayToSet(route.matcherKeys(newDemandMatcher)); - var newSupply = route.arrayToSet(route.matcherKeys(newSupplyMatcher)); - var demandDelta = route.setSubtract(newDemand, this.currentDemand); - var supplyDelta = route.setSubtract(this.currentSupply, newSupply); - var demandIncr = route.setSubtract(demandDelta, newSupply); - var supplyDecr = route.setIntersect(supplyDelta, newDemand); + var newDemand = Route.arrayToSet(Route.matcherKeys(newDemandMatcher)); + var newSupply = Route.arrayToSet(Route.matcherKeys(newSupplyMatcher)); + var demandDelta = Route.setSubtract(newDemand, this.currentDemand); + var supplyDelta = Route.setSubtract(this.currentSupply, newSupply); + var demandIncr = Route.setSubtract(demandDelta, newSupply); + var supplyDecr = Route.setIntersect(supplyDelta, newDemand); this.currentDemand = newDemand; this.currentSupply = newSupply; for (var k in demandIncr) this.onDemandIncrease(demandIncr[k]); @@ -533,3 +537,21 @@ Ground.prototype.enqueueAction = function (pid, action) { console.error("You have sent a message into the outer void.", action); } }; + +/////////////////////////////////////////////////////////////////////////// + +module.exports.__ = __; +module.exports._$ = _$; + +module.exports.sub = sub; +module.exports.pub = pub; +module.exports.spawn = spawn; +module.exports.updateRoutes = updateRoutes; +module.exports.sendMessage = sendMessage; +module.exports.shutdownWorld = shutdownWorld; + +module.exports.World = World; +module.exports.DemandMatcher = DemandMatcher; +module.exports.Deduplicator = Deduplicator; +module.exports.Ground = Ground; +module.exports.Route = Route; diff --git a/src/route.js b/src/route.js new file mode 100644 index 0000000..c4c5eb7 --- /dev/null +++ b/src/route.js @@ -0,0 +1,1519 @@ +var __ = "__"; /* wildcard marker */ + +var SOA = "__["; // start of array +var EOA = "__]"; // end of array + +function die(message) { + throw new Error(message); +} + +function $Embedded(matcher) { + this.matcher = matcher; +} + +function embeddedMatcher(matcher) { + return new $Embedded(matcher); +} + +// The pattern argument defaults to wildcard, __. +function $Capture(pattern) { + this.pattern = (typeof pattern === 'undefined' ? __ : pattern); +} + +// Abbreviation: _$(x) <==> new $Capture(x) +function _$(pattern) { + return new $Capture(pattern); +} + +function isCapture(x) { return x instanceof $Capture || x === _$; } +function capturePattern(x) { return x instanceof $Capture ? x.pattern : __; } + +var SOC = "__{{"; // start of capture +var EOC = "__}}"; // end of capture + +function $Success(value) { + this.value = value; +} + +function $WildcardSequence(matcher) { + this.matcher = matcher; +} + +function $Dict() { + this.length = 0; + this.entries = {}; +} + +$Dict.prototype.get = function (key) { + return this.entries[key] || emptyMatcher; +}; + +$Dict.prototype.set = function (key, val) { + if (!(key in this.entries)) this.length++; + this.entries[key] = val; +}; + +$Dict.prototype.clear = function (key) { + if (key in this.entries) this.length--; + delete this.entries[key]; +}; + +$Dict.prototype.isEmpty = function () { + return this.length === 0; +}; + +$Dict.prototype.copy = function () { + var other = new $Dict(); + other.length = this.length; + for (var key in this.entries) { + if (this.entries.hasOwnProperty(key)) { + other.entries[key] = this.entries[key]; + } + } + return other; +}; + +$Dict.prototype.emptyGuard = function () { + if (this.isEmpty()) return emptyMatcher; + return this; +}; + +$Dict.prototype.has = function (key) { + return key in this.entries; +}; + +$Dict.prototype.sortedKeys = function () { + var ks = []; + for (var k in this.entries) ks.push(k); + ks.sort(); + return ks; +} + +function is_emptyMatcher(m) { + return (m === emptyMatcher); +} + +/////////////////////////////////////////////////////////////////////////// +// Constructors + +var emptyMatcher = null; + +function rsuccess(v) { + return (v === emptyMatcher) ? emptyMatcher : new $Success(v); +} + +function rseq(e, r) { + if (r === emptyMatcher) return emptyMatcher; + var s = new $Dict(); + s.set(e, r); + return s; +} + +function rwild(r) { + return rseq(__, r); +} + +function rwildseq(r) { + return (r === emptyMatcher) ? emptyMatcher : new $WildcardSequence(r); +} + +/////////////////////////////////////////////////////////////////////////// + +function compilePattern(v, p) { + if (!p) die("compilePattern: missing pattern"); + return walk(p, rseq(EOA, rsuccess(v))); + + function walk(p, acc) { + if (p === __) return rwild(acc); + + if (Array.isArray(p)) { + acc = rseq(EOA, acc); + for (var i = p.length - 1; i >= 0; i--) { + acc = walk(p[i], acc); + } + return rseq(SOA, acc); + } + + if (p instanceof $Embedded) { + return appendMatcher(p.matcher, function (v) { return acc; }); + } else { + return rseq(JSON.stringify(p), acc); + } + } +} + +function shallowCopyArray(s) { + return s.slice(); +} + +function rupdateInplace(r, key, k) { + if (is_emptyMatcher(k)) { + r.clear(key); + } else { + r.set(key, k); + } +} + +function matcherEquals(a, b) { + if (a === null) { + return (b === null); + } + if (b === null) return false; + + if (a instanceof $WildcardSequence) { + if (!(b instanceof $WildcardSequence)) return false; + a = a.matcher; + b = b.matcher; + } else if (b instanceof $WildcardSequence) return false; + + if (a instanceof $Success) { + if (!(b instanceof $Success)) return false; + return valuesEqual(a.value, b.value); + } + if (b instanceof $Success) return false; + + for (var key in a.entries) { + if (!b.has(key)) return false; + if (!matcherEquals(a.entries[key], b.entries[key])) return false; + } + return true; +} + +function is_keyOpen(k) { + return k === SOA; +} + +function is_keyClose(k) { + return k === EOA; +} + +function is_keyNormal(k) { + return !(is_keyOpen(k) || is_keyClose(k)); +} + +/////////////////////////////////////////////////////////////////////////// +// Enough of sets to get by with + +function arrayToSet(xs) { + var s = {}; + for (var i = 0; i < xs.length; i++) { + s[JSON.stringify(xs[i])] = xs[i]; + } + return s; +} + +function setToArray(s) { + var r = []; + for (var k in s) r.push(s[k]); + return r; +} + +function setUnion(s1, s2) { + var s = {}; + setUnionInplace(s, s1); + setUnionInplace(s, s2); + return s; +} + +function is_emptySet(s) { + for (var k in s) { + if (s.hasOwnProperty(k)) + return false; + } + return true; +} + +function setSubtract(s1, s2) { + var s = {}; + for (var key in s1) { + if (s1.hasOwnProperty(key) && !s2.hasOwnProperty(key)) { + s[key] = s1[key]; + } + } + return s; +} + +function setIntersect(s1, s2) { + var s = {}; + for (var key in s1) { + if (s1.hasOwnProperty(key) && s2.hasOwnProperty(key)) { + s[key] = s1[key]; + } + } + return s; +} + +function setUnionInplace(acc, s) { + for (var key in s) { + if (s.hasOwnProperty(key)) { + acc[key] = s[key]; + } + } +} + +function setEqual(s1, s2) { + for (var key in s1) { + if (s1.hasOwnProperty(key)) { + if (s1[key] !== s2[key]) return false; + } + } + for (var key in s2) { + if (s2.hasOwnProperty(key)) { + if (s1[key] !== s2[key]) return false; + } + } + return true; +} + +/////////////////////////////////////////////////////////////////////////// + +var unionSuccesses = function (v1, v2) { + if (v1 === true) return v2; + if (v2 === true) return v1; + return setUnion(v1, v2); +}; + +var intersectSuccesses = function (v1, v2) { + return v1; +}; + +var erasePathSuccesses = function (v1, v2) { + var r = setSubtract(v1, v2); + if (is_emptySet(r)) return null; + return r; +}; + +var matchMatcherSuccesses = function (v1, v2, acc) { + setUnionInplace(acc, v2); +}; + +var projectSuccess = function (v) { + return v; +}; + +var valuesEqual = function (a, b) { + return setEqual(a, b); +}; + +/////////////////////////////////////////////////////////////////////////// + +function expandWildseq(r) { + return union(rwild(rwildseq(r)), rseq(EOA, r)); +} + +function union(o1, o2) { + return merge(o1, o2); + + function merge(o1, o2) { + if (is_emptyMatcher(o1)) return o2; + if (is_emptyMatcher(o2)) return o1; + return walk(o1, o2); + } + + function walk(r1, r2) { + if (r1 instanceof $WildcardSequence) { + if (r2 instanceof $WildcardSequence) { + return rwildseq(walk(r1.matcher, r2.matcher)); + } + r1 = expandWildseq(r1.matcher); + } else if (r2 instanceof $WildcardSequence) { + r2 = expandWildseq(r2.matcher); + } + + if (r1 instanceof $Success && r2 instanceof $Success) { + return rsuccess(unionSuccesses(r1.value, r2.value)); + } + + var w = merge(r1.get(__), r2.get(__)); + if (is_emptyMatcher(w)) { + var smaller = r1.length < r2.length ? r1 : r2; + var larger = r1.length < r2.length ? r2 : r1; + var target = larger.copy(); + for (var key in smaller.entries) { + var k = merge(smaller.get(key), larger.get(key)); + rupdateInplace(target, key, k); + } + return target.emptyGuard(); + } else { + function examineKey(rA, key, rB) { + if ((key !== __) && !target.has(key)) { + var k = merge(rA.get(key), rB.get(key)); + if (is_keyOpen(key)) { + rupdateInplace(target, key, merge(rwildseq(w), k)); + } else if (is_keyClose(key)) { + if (w instanceof $WildcardSequence) { + rupdateInplace(target, key, merge(w.matcher, k)); + } else { + rupdateInplace(target, key, k); + } + } else { + rupdateInplace(target, key, merge(w, k)); + } + } + } + var target = rwild(w).copy(); + for (var key in r1.entries) { examineKey(r1, key, r2); } + for (var key in r2.entries) { examineKey(r2, key, r1); } + return target; + } + } +} + +function unionN() { + var acc = emptyMatcher; + for (var i = 0; i < arguments.length; i++) { + acc = union(acc, arguments[i]); + } + return acc; +} + +function intersect(o1, o2) { + if (is_emptyMatcher(o1)) return emptyMatcher; + if (is_emptyMatcher(o2)) return emptyMatcher; + return walk(o1, o2); + + function walkFlipped(r2, r1) { return walk(r1, r2); } + + function walk(r1, r2) { + // INVARIANT: r1 is a part of the original o1, and + // likewise for r2. This is so that the first arg to + // intersectSuccesses always comes from r1, and the second + // from r2. + if (is_emptyMatcher(r1)) return emptyMatcher; + if (is_emptyMatcher(r2)) return emptyMatcher; + + if (r1 instanceof $WildcardSequence) { + if (r2 instanceof $WildcardSequence) { + return rwildseq(walk(r1.matcher, r2.matcher)); + } + r1 = expandWildseq(r1.matcher); + } else if (r2 instanceof $WildcardSequence) { + r2 = expandWildseq(r2.matcher); + } + + if (r1 instanceof $Success && r2 instanceof $Success) { + return rsuccess(intersectSuccesses(r1.value, r2.value)); + } + + var w1 = r1.get(__); + var w2 = r2.get(__); + var w = walk(w1, w2); + + var target = new $Dict(); + + function examineKey(key) { + if ((key !== __) && !target.has(key)) { + var k1 = r1.get(key); + var k2 = r2.get(key); + if (is_emptyMatcher(k1)) { + if (is_emptyMatcher(k2)) { + rupdateInplace(target, key, emptyMatcher); + } else { + rupdateInplace(target, key, walkWild(walk, w1, key, k2)); + } + } else { + if (is_emptyMatcher(k2)) { + rupdateInplace(target, key, walkWild(walkFlipped, w2, key, k1)); + } else { + rupdateInplace(target, key, walk(k1, k2)); + } + } + } + } + + if (is_emptyMatcher(w1)) { + if (is_emptyMatcher(w2)) { + for (var key in (r1.length < r2.length ? r1 : r2).entries) examineKey(key); + } else { + for (var key in r1.entries) examineKey(key); + } + } else { + if (is_emptyMatcher(w2)) { + for (var key in r2.entries) examineKey(key); + } else { + rupdateInplace(target, __, w); + for (var key in r1.entries) examineKey(key); + for (var key in r2.entries) examineKey(key); + } + } + return target.emptyGuard(); + } + + function walkWild(walker, w, key, k) { + if (is_emptyMatcher(w)) return emptyMatcher; + if (is_keyOpen(key)) return walker(rwildseq(w), k); + if (is_keyClose(key)) { + if (w instanceof $WildcardSequence) return walker(w.matcher, k); + return emptyMatcher; + } + return walker(w, k); + } +} + +// Removes r2's mappings from r1. Assumes r2 has previously been +// union'd into r1. The erasePathSuccesses function should return +// null to signal "no remaining success values". +function erasePath(o1, o2) { + return walk(o1, o2); + + function walk(r1, r2) { + if (is_emptyMatcher(r1)) { + return emptyMatcher; + } else { + if (is_emptyMatcher(r2)) { + return r1; + } + } + + if (r1 instanceof $WildcardSequence) { + if (r2 instanceof $WildcardSequence) { + return rwildseq(walk(r1.matcher, r2.matcher)); + } + r1 = expandWildseq(r1.matcher); + } else if (r2 instanceof $WildcardSequence) { + r2 = expandWildseq(r2.matcher); + } + + if (r1 instanceof $Success && r2 instanceof $Success) { + return rsuccess(erasePathSuccesses(r1.value, r2.value)); + } + + var w1 = r1.get(__); + var w2 = r2.get(__); + var w = walk(w1, w2); + var target; + + function examineKey(key) { + if (key !== __) { + var k1 = r1.get(key); + var k2 = r2.get(key); + var updatedK; + if (is_emptyMatcher(k2)) { + updatedK = walkWild(key, k1, w2); + } else { + updatedK = walk(k1, k2); + } + // Here we ensure a "minimal" remainder in cases + // where after an erasure, a particular key's + // continuation is the same as the wildcard's + // continuation. TODO: the matcherEquals check may + // be expensive. If so, how can it be made + // cheaper? + if (is_keyOpen(key)) { + rupdateInplace(target, key, + ((updatedK instanceof $WildcardSequence) && + matcherEquals(updatedK.matcher, w)) + ? emptyMatcher + : updatedK); + } else if (is_keyClose(key)) { + // We take care of this case later, after the + // target is fully constructed/rebuilt. + rupdateInplace(target, key, updatedK); + } else { + rupdateInplace(target, key, + (matcherEquals(updatedK, w) ? emptyMatcher : updatedK)); + } + } + } + + if (is_emptyMatcher(w2)) { + target = r1.copy(); + for (var key in r2.entries) examineKey(key); + } else { + target = new $Dict(); + rupdateInplace(target, __, w); + for (var key in r1.entries) examineKey(key); + for (var key in r2.entries) examineKey(key); + } + + // Here, the target is complete. If it has only two keys, + // one wild and one is_keyClose, and wild's continuation + // is a $WildcardSequence and the other continuation is + // identical to the sequence's continuation, then replace + // the whole thing with a nested $WildcardSequence. + // (We know w === target.get(__) from before.) + // + // TODO: I suspect actually this applies even if there are + // more than two keys, so long as all their continuations + // are identical and there's at least one is_keyClose + // alongside a wild. + if (target.length === 2) { + var finalW = target.get(__); + if (finalW instanceof $WildcardSequence) { + for (var key in target.entries) { + if ((key !== __) && is_keyClose(key)) { + var k = target.get(key); + if (matcherEquals(k, finalW.matcher)) { + return finalW; + } + } + } + } + } + + return target.emptyGuard(); + } + + function walkWild(key, k, w) { + if (is_emptyMatcher(w)) return k; + if (is_keyOpen(key)) return walk(k, rwildseq(w)); + if (is_keyClose(key)) { + if (w instanceof $WildcardSequence) return walk(k, w.matcher); + return k; + } + return walk(k, w); + } +} + +// Returns null on failed match, otherwise the appropriate success +// value contained in the matcher r. +function matchValue(r, v) { + var failureResult = null; + + var vs = [v]; + var stack = [[]]; + + while (!is_emptyMatcher(r)) { + if (r instanceof $WildcardSequence) { + if (stack.length === 0) return failureResult; + vs = stack.pop(); + r = r.matcher; + continue; + } + + if (r instanceof $Success) { + if (vs.length === 0 && stack.length === 0) return r.value; + return failureResult; + } + + if (vs.length === 0) { + if (stack.length === 0) return failureResult; + vs = stack.pop(); + r = r.get(EOA); + continue; + } + + var v = vs.shift(); + + if (typeof v === 'string' && v.substring(0, 2) === '__') { + die("Cannot match special string starting with __"); + } + + if (Array.isArray(v)) { + if (SOA in r.entries) { + r = r.get(SOA); + stack.push(vs); + vs = shallowCopyArray(v); + } else { + r = r.get(__); + } + } else { + var key; + try { + key = JSON.stringify(v); + } catch (exn) { + // For example, v might be cyclic, as in DOM events. + key = null; + } + if (key in r.entries) { + r = r.get(key); + } else { + r = r.get(__); + } + } + } + + return failureResult; +} + +// TODO: better name for this +function matchMatcher(o1, o2, seed) { + var acc = typeof seed === 'undefined' ? {} : seed; // will be modified in place + walk(o1, o2); + return acc; + + function walkFlipped(r2, r1) { return walk(r1, r2); } + + function walk(r1, r2) { + if (is_emptyMatcher(r1) || is_emptyMatcher(r2)) return; + + if (r1 instanceof $WildcardSequence) { + if (r2 instanceof $WildcardSequence) { + walk(r1.matcher, r2.matcher); + return; + } + r1 = expandWildseq(r1.matcher); + } else if (r2 instanceof $WildcardSequence) { + r2 = expandWildseq(r2.matcher); + } + + if (r1 instanceof $Success && r2 instanceof $Success) { + matchMatcherSuccesses(r1.value, r2.value, acc); + return; + } + + var w1 = r1.get(__); + var w2 = r2.get(__); + walk(w1, w2); + + function examineKey(key) { + if (key !== __) { + var k1 = r1.get(key); + var k2 = r2.get(key); + if (is_emptyMatcher(k1)) { + if (is_emptyMatcher(k2)) { + return; + } else { + walkWild(walk, w1, key, k2); + } + } else { + if (is_emptyMatcher(k2)) { + walkWild(walkFlipped, w2, key, k1); + } else { + walk(k1, k2); + } + } + } + } + + // Optimize similarly to intersect(). + if (is_emptyMatcher(w1)) { + if (is_emptyMatcher(w2)) { + for (var key in (r1.length < r2.length ? r1 : r2).entries) examineKey(key); + } else { + for (var key in r1.entries) examineKey(key); + } + } else { + if (is_emptyMatcher(w2)) { + for (var key in r2.entries) examineKey(key); + } else { + for (var key in r1.entries) examineKey(key); + for (var key in r2.entries) examineKey(key); + } + } + } + + function walkWild(walker, w, key, k) { + if (is_emptyMatcher(w)) return; + if (is_keyOpen(key)) { + walker(rwildseq(w), k); + return; + } + if (is_keyClose(key)) { + if (w instanceof $WildcardSequence) walker(w.matcher, k); + return; + } + walker(w, k); + } +} + +function appendMatcher(m, mTailFn) { + return walk(m); + + function walk(m) { + if (is_emptyMatcher(m)) return emptyMatcher; + if (m instanceof $WildcardSequence) return rwildseq(walk(m.matcher)); + if (m instanceof $Success) die("Ill-formed matcher"); + + var target = new $Dict(); + for (var key in m.entries) { + var k = m.get(key); + if (is_keyClose(key) && (k instanceof $Success)) { + target = union(target, mTailFn(k.value)); + } else { + rupdateInplace(target, key, walk(k)); + } + } + return target.emptyGuard(); + } +} + +function relabel(m, f) { + return walk(m); + + function walk(m) { + if (is_emptyMatcher(m)) return emptyMatcher; + if (m instanceof $WildcardSequence) return rwildseq(walk(m.matcher)); + if (m instanceof $Success) return rsuccess(f(m.value)); + + var target = new $Dict(); + for (var key in m.entries) { + rupdateInplace(target, key, walk(m.get(key))); + } + return target.emptyGuard(); + } +} + +function compileProjection(/* projection, projection, ... */) { + var acc = []; + for (var i = 0; i < arguments.length; i++) { + walk(arguments[i]); + } + acc.push(EOA); + return acc; + + function walk(p) { + if (isCapture(p)) { + acc.push(SOC); + walk(capturePattern(p)); + acc.push(EOC); + return; + } + + if (Array.isArray(p)) { + acc.push(SOA); + for (var i = 0; i < p.length; i++) { + walk(p[i]); + } + acc.push(EOA); + return; + } + + if (p instanceof $Embedded) { + die("Cannot embed matcher in projection"); + } else { + if (p === __) { + acc.push(p); + } else { + acc.push(JSON.stringify(p)); + } + } + } +} + +function projectionToPattern(p) { + return walk(p); + + function walk(p) { + if (isCapture(p)) return walk(capturePattern(p)); + + if (Array.isArray(p)) { + var result = []; + for (var i = 0; i < p.length; i++) { + result.push(walk(p[i])); + } + return result; + } + + if (p instanceof $Embedded) { + return p.matcher; + } else { + return p; + } + } +} + +function project(m, spec) { + return walk(false, m, 0); + + function walk(isCapturing, m, specIndex) { + if (specIndex >= spec.length) { + if (isCapturing) die("Bad specification: unclosed capture"); + if (m instanceof $Success) { + return rseq(EOA, rsuccess(projectSuccess(m.value))); + } else { + return emptyMatcher; + } + } + + if (is_emptyMatcher(m)) return emptyMatcher; + + var item = spec[specIndex]; + var nextIndex = specIndex + 1; + + if (item === EOC) { + if (!isCapturing) die("Bad specification: unepxected EOC"); + return walk(false, m, nextIndex); + } + + if (item === SOC) { + if (isCapturing) die("Bad specification: nested capture"); + return walk(true, m, nextIndex); + } + + if (item === __) { + if (m instanceof $WildcardSequence) { + if (isCapturing) { + return rwild(walk(isCapturing, m, nextIndex)); + } else { + return walk(isCapturing, m, nextIndex); + } + } + + if (m instanceof $Success) { + return emptyMatcher; + } + + var target; + if (isCapturing) { + target = new $Dict(); + rupdateInplace(target, __, walk(isCapturing, m.get(__), nextIndex)); + for (var key in m.entries) { + if (key !== __) { + var mk = m.get(key); + if (is_keyOpen(key)) { + function cont(mk2) { return walk(isCapturing, mk2, nextIndex); } + rupdateInplace(target, key, captureNested(mk, cont)); + } else if (is_keyClose(key)) { + // do nothing + } else { + rupdateInplace(target, key, walk(isCapturing, mk, nextIndex)); + } + } + } + } else { + target = walk(isCapturing, m.get(__), nextIndex); + for (var key in m.entries) { + if (key !== __) { + var mk = m.get(key); + if (is_keyOpen(key)) { + function cont(mk2) { return walk(isCapturing, mk2, nextIndex); } + target = union(target, skipNested(mk, cont)); + } else if (is_keyClose(key)) { + // do nothing + } else { + target = union(target, walk(isCapturing, mk, nextIndex)); + } + } + } + } + return target; + } + + var result; + if (m instanceof $WildcardSequence) { + if (is_keyOpen(item)) { + result = walk(isCapturing, rwildseq(m), nextIndex); + } else if (is_keyClose(item)) { + result = walk(isCapturing, m.matcher, nextIndex); + } else { + result = walk(isCapturing, m, nextIndex); + } + } else if (m instanceof $Success) { + result = emptyMatcher; + } else { + if (is_keyOpen(item)) { + result = walk(isCapturing, rwildseq(m.get(__)), nextIndex); + } else if (is_keyClose(item)) { + result = emptyMatcher; + } else { + result = walk(isCapturing, m.get(__), nextIndex); + } + result = union(result, walk(isCapturing, m.get(item), nextIndex)); + } + if (isCapturing) { + result = rseq(item, result); + } + return result; + } + + function captureNested(m, cont) { + if (m instanceof $WildcardSequence) { + return rwildseq(cont(m.matcher)); + } + + if (is_emptyMatcher(m) || (m instanceof $Success)) { + return emptyMatcher; + } + + var target = new $Dict(); + rupdateInplace(target, __, captureNested(m.get(__), cont)); + for (var key in m.entries) { + if (key !== __) { + var mk = m.get(key); + if (is_keyOpen(key)) { + function cont2(mk2) { return captureNested(mk2, cont); } + rupdateInplace(target, key, captureNested(mk, cont2)); + } else if (is_keyClose(key)) { + rupdateInplace(target, key, cont(mk)); + } else { + rupdateInplace(target, key, captureNested(mk, cont)); + } + } + } + return target.emptyGuard(); + } + + function skipNested(m, cont) { + if (m instanceof $WildcardSequence) { + return cont(m.matcher); + } + + if (is_emptyMatcher(m) || (m instanceof $Success)) { + return emptyMatcher; + } + + var target = skipNested(m.get(__), cont); + for (var key in m.entries) { + if (key !== __) { + var mk = m.get(key); + if (is_keyOpen(key)) { + function cont2(mk2) { return skipNested(mk2, cont); } + target = union(target, skipNested(mk, cont2)); + } else if (is_keyClose(key)) { + target = union(target, cont(mk)); + } else { + target = union(target, skipNested(mk, cont)); + } + } + } + return target; + } +} + +function matcherKeys(m) { + if (is_emptyMatcher(m)) return []; + return walkSeq(m, function (vss, vsk) { return vss; }); + + function walk(m, k) { + if (m instanceof $WildcardSequence) return null; + if (m instanceof $Success) return []; + if (m.has(__)) return null; + var acc = []; + for (var key in m.entries) { + var mk = m.get(key); + var piece; + if (is_keyOpen(key)) { + function seqK(vss, vsk) { + var acc = []; + for (var i = 0; i < vss.length; i++) { + var vs = vss[i]; + acc = acc.concat(k(transformSeqs(vs, key), vsk)); + } + return acc; + } + piece = walkSeq(mk, seqK); + } else if (is_keyClose(key)) { + die("matcherKeys: internal error: unexpected key-close"); + } else { + piece = k(JSON.parse(key), mk); + } + if (piece == null) return null; + acc = acc.concat(piece); + } + return acc; + } + + function walkSeq(m, k) { + if (m instanceof $WildcardSequence) return null; + if (m instanceof $Success) return k([], emptyMatcher); // TODO: ?? + if (m.has(__)) return null; + var acc = []; + for (var key in m.entries) { + var mk = m.get(key); + var piece; + if (is_keyClose(key)) { + piece = k([[]], mk); + } else { + function outerK(v, vk) { + return walkSeq(vk, innerK); + function innerK(vss, vsk) { + var acc = []; + for (var i = 0; i < vss.length; i++) { + var vs = shallowCopyArray(vss[i]); + vs.unshift(v); + acc.push(vs); + } + return k(acc, vsk); + } + } + piece = walk(rseq(key, mk), outerK); + } + if (piece == null) return null; + acc = acc.concat(piece); + } + return acc; + } + + function transformSeqs(vs, opener) { + if (opener === SOA) return vs; + die("Internal error: unknown opener " + opener); + } +} + +function prettyMatcher(m, initialIndent) { + var acc = []; + walk(initialIndent || 0, m); + return acc.join(''); + + function walk(i, m) { + if (is_emptyMatcher(m)) { + acc.push("::: no further matches possible"); + return; + } + if (m instanceof $WildcardSequence) { + acc.push("...>"); + walk(i + 4, m.matcher); + return; + } + if (m instanceof $Success) { + var vs = JSON.stringify(typeof m.value === 'object' + ? setToArray(m.value) + : m.value); + acc.push("{" + vs + "}"); + return; + } + + if (m.length === 0) { + acc.push(" ::: empty hash!"); + return; + } + + var needSep = false; + var keys = m.sortedKeys(); + for (var keyi = 0; keyi < keys.length; keyi++) { + var key = keys[keyi]; + var k = m.entries[key]; + if (needSep) { + acc.push("\n"); + acc.push(indentStr(i)); + } else { + needSep = true; + } + acc.push(" "); + if (key === __) key = '★'; + if (key === SOA) key = '<'; + if (key === EOA) key = '>'; + acc.push(key); + walk(i + key.length + 1, k); + } + } + + function indentStr(i) { + return new Array(i + 1).join(' '); // eww + } +} + +function serializeMatcher(m, serializeSuccess) { + return walk(m); + function walk(m) { + if (is_emptyMatcher(m)) return []; + if (m instanceof $WildcardSequence) { + return ["...)", walk(m.matcher)]; + } + if (m instanceof $Success) { + return ["", serializeSuccess(m.value)]; + } + var acc = []; + for (var key in m.entries) { + var k = m.entries[key]; + if (key === __) key = ["__"]; + else if (key === SOA) key = ["("]; + else if (key === EOA) key = [")"]; + else key = JSON.parse(key); + acc.push([key, walk(k)]); + } + return acc; + } +} + +function deserializeMatcher(r, deserializeSuccess) { + return walk(r); + function walk(r) { + if (r.length === 0) return emptyMatcher; + if (r[0] === "...)") return rwildseq(walk(r[1])); + if (r[0] === "") return rsuccess(deserializeSuccess(r[1])); + var acc = new $Dict(); + for (var i = 0; i < r.length; i++) { + var rkey = r[i][0]; + var rk = r[i][1]; + var key; + if (Array.isArray(rkey)) { + switch (rkey[0]) { + case "__": key = __; break; + case "(": key = SOA; break; + case ")": key = EOA; break; + default: die("Invalid serialized special key: " + rkey[0]); + } + } else { + key = JSON.stringify(rkey); + } + rupdateInplace(acc, key, walk(rk)); + } + return acc; + } +} + +/////////////////////////////////////////////////////////////////////////// +// Gestalts. +// TODO: support Infinity as a level number + +function GestaltLevel(subs, advs) { + this.subscriptions = subs; + this.advertisements = advs; +} + +GestaltLevel.prototype.isEmpty = function () { + return is_emptyMatcher(this.subscriptions) && is_emptyMatcher(this.advertisements); +}; + +GestaltLevel.prototype.equals = function (other) { + return matcherEquals(this.subscriptions, other.subscriptions) + && matcherEquals(this.advertisements, other.advertisements); +}; + +GestaltLevel.prototype.pretty = function () { + var acc = []; + if (!is_emptyMatcher(this.subscriptions)) { + acc.push(" - subs:"); + acc.push(prettyMatcher(this.subscriptions, 9)); + acc.push("\n"); + } + if (!is_emptyMatcher(this.advertisements)) { + acc.push(" - advs:"); + acc.push(prettyMatcher(this.advertisements, 9)); + acc.push("\n"); + } + return acc.join(''); +}; + +function straightGestaltLevelOp(op) { + return function (p1, p2) { + return new GestaltLevel(op(p1.subscriptions, p2.subscriptions), + op(p1.advertisements, p2.advertisements)); + }; +}; + +var emptyLevel = new GestaltLevel(emptyMatcher, emptyMatcher); +var emptyMetaLevel = []; + +function Gestalt(metaLevels) { + this.metaLevels = metaLevels; +} + +Gestalt.prototype.getMetaLevel = function (n) { + return this.metaLevels[n] || emptyMetaLevel; +}; + +Gestalt.prototype.getLevel = function (metaLevel, level) { + return this.getMetaLevel(metaLevel)[level] || emptyLevel; +}; + +Gestalt.prototype.metaLevelCount = function () { return this.metaLevels.length; }; +Gestalt.prototype.levelCount = function (n) { return this.getMetaLevel(n).length; }; + +Gestalt.prototype.matchValue = function (body, metaLevel, isFeedback) { + var levels = this.getMetaLevel(metaLevel); + var pids = {}; + for (var i = 0; i < levels.length; i++) { + var matcher = (isFeedback ? levels[i].advertisements : levels[i].subscriptions); + setUnionInplace(pids, matchValue(matcher, body)); + } + return setToArray(pids); +}; + +Gestalt.prototype.project = function (spec, getAdvertisements, metaLevel, level) { + var l = this.getLevel(metaLevel | 0, level | 0); + var matcher = (getAdvertisements ? l.advertisements : l.subscriptions); + return project(matcher, spec); +}; + +Gestalt.prototype.drop = function () { + var mls = shallowCopyArray(this.metaLevels); + mls.shift(); + return new Gestalt(mls); +}; + +Gestalt.prototype.lift = function () { + var mls = shallowCopyArray(this.metaLevels); + mls.unshift(emptyMetaLevel); + return new Gestalt(mls); +}; + +Gestalt.prototype.equals = function (other) { + if (this.metaLevels.length !== other.metaLevels.length) return false; + for (var i = 0; i < this.metaLevels.length; i++) { + var ls1 = this.metaLevels[i]; + var ls2 = other.metaLevels[i]; + if (ls1.length !== ls2.length) return false; + for (var j = 0; j < ls1.length; j++) { + var p1 = ls1[j]; + var p2 = ls2[j]; + if (!p1.equals(p2)) return false; + } + } + return true; +}; + +function simpleGestalt(isAdv, pat, metaLevel, level) { + metaLevel = metaLevel || 0; + level = level || 0; + var matcher = compilePattern(true, pat); + var l = new GestaltLevel(isAdv ? emptyMatcher : matcher, + isAdv ? matcher : emptyMatcher); + var levels = [l]; + while (level--) { levels.unshift(emptyLevel); } + var metaLevels = [levels]; + while (metaLevel--) { metaLevels.unshift(emptyMetaLevel); } + return new Gestalt(metaLevels); +} + +var emptyGestalt = new Gestalt([]); + +// Not quite what it says on the tin - the true fullGestalt +// wouldn't be parameterized on the number of levels and +// metalevels, but instead would be full at *all* levels and +// metalevels. Our representation leaks through into the interface +// here :-/ +function fullGestalt(nMetalevels, nLevels) { + var matcher = compilePattern(true, __); + var l = new GestaltLevel(matcher, matcher); + var levels = []; + while (nLevels--) { levels.push(l); } + var metaLevels = []; + while (nMetalevels--) { metaLevels.push(levels); } + return new Gestalt(metaLevels); +} + +Gestalt.prototype.isEmpty = function () { + for (var i = 0; i < this.metaLevels.length; i++) { + var levels = this.metaLevels[i]; + for (var j = 0; j < levels.length; j++) { + if (!levels[j].isEmpty()) return false; + } + } + return true; +}; + +function maybePushLevel(levels, i, level) { + if (!level.isEmpty()) { + while (levels.length < i) levels.push(emptyLevel); + levels.push(level); + } +} + +function maybePushMetaLevel(metaLevels, i, metaLevel) { + if (metaLevel.length > 0) { + while (metaLevels.length < i) metaLevels.push(emptyMetaLevel); + metaLevels.push(metaLevel); + } +} + +Gestalt.prototype.mapZip = function (other, lengthCombiner, f) { + var metaLevels = []; + var mls1 = this.metaLevels; + var mls2 = other.metaLevels; + var nm = lengthCombiner(mls1.length, mls2.length); + for (var i = 0; i < nm; i++) { + var levels = []; + var ls1 = mls1[i] || emptyMetaLevel; + var ls2 = mls2[i] || emptyMetaLevel; + var nl = lengthCombiner(ls1.length, ls2.length); + for (var j = 0; j < nl; j++) { + var p1 = ls1[j] || emptyLevel; + var p2 = ls2[j] || emptyLevel; + var p = f(p1, p2); + maybePushLevel(levels, j, p); + } + maybePushMetaLevel(metaLevels, i, levels); + } + return new Gestalt(metaLevels); +}; + +Gestalt.prototype.union1 = function (other) { + return this.mapZip(other, Math.max, straightGestaltLevelOp(union)); +}; + +function gestaltUnion(gs) { + if (gs.length === 0) return emptyGestalt; + var acc = gs[0]; + for (var i = 1; i < gs.length; i++) { + acc = acc.union1(gs[i]); + } + return acc; +} + +Gestalt.prototype.union = function () { + return arguments.length > 0 ? this.union1(gestaltUnion(arguments)) : this; +}; + +// Accumulates matchers from higher-numbered levels into +// lower-numbered levels. +function telescopeLevels(levels) { + var result = shallowCopyArray(levels); + for (var i = result.length - 2; i >= 0; i--) { + result[i] = + new GestaltLevel(union(result[i].subscriptions, result[i+1].subscriptions), + union(result[i].advertisements, result[i+1].advertisements)); + } + return result; +}; + +Gestalt.prototype.telescoped = function () { + var mls = []; + for (var i = 0; i < this.metaLevels.length; i++) { + mls.push(telescopeLevels(this.metaLevels[i])); + } + return new Gestalt(mls); +}; + +Gestalt.prototype.filter = function (perspective) { + var metaLevels = []; + var mls1 = this.metaLevels; + var mls2 = perspective.metaLevels; + var nm = Math.min(mls1.length, mls2.length); + for (var i = 0; i < nm; i++) { + var levels = []; + var ls1 = mls1[i] || emptyMetaLevel; + var ls2 = mls2[i] || emptyMetaLevel; + var nl = Math.min(ls1.length, ls2.length - 1); + for (var j = 0; j < nl; j++) { + var p1 = ls1[j] || emptyLevel; + var subs = emptyMatcher; + var advs = emptyMatcher; + for (var k = j + 1; k < ls2.length; k++) { + var p2 = ls2[k] || emptyLevel; + subs = union(subs, intersect(p1.subscriptions, p2.advertisements)); + advs = union(advs, intersect(p1.advertisements, p2.subscriptions)); + } + maybePushLevel(levels, j, new GestaltLevel(subs, advs)); + } + maybePushMetaLevel(metaLevels, i, levels); + } + return new Gestalt(metaLevels); +}; + +Gestalt.prototype.match = function (perspective) { + var pids = {}; + var nm = Math.min(this.metaLevels.length, perspective.metaLevels.length); + for (var i = 0; i < nm; i++) { + var ls1 = this.metaLevels[i] || emptyMetaLevel; + var ls2 = perspective.metaLevels[i] || emptyMetaLevel; + var nl = Math.min(ls1.length, ls2.length - 1); + for (var j = 0; j < nl; j++) { + var p1 = ls1[j] || emptyLevel; + for (var k = j + 1; k < ls2.length; k++) { + var p2 = ls2[k] || emptyLevel; + matchMatcher(p1.subscriptions, p2.advertisements, pids); + matchMatcher(p1.advertisements, p2.subscriptions, pids); + } + } + } + return setToArray(pids); +}; + +Gestalt.prototype.erasePath = function (path) { + return this.mapZip(path, Math.max, straightGestaltLevelOp(erasePath)); +}; + +function mapLevels(inputMetaLevels, f, emptyCheck, inputEmptyLevel, outputEmptyLevel) { + var outputMetaLevels = []; + for (var i = 0; i < inputMetaLevels.length; i++) { + var ls = inputMetaLevels[i]; + var levels = []; + for (var j = 0; j < ls.length; j++) { + var p = f(ls[j] || inputEmptyLevel, i, j); + if (!emptyCheck(p, i, j)) { + while (levels.length < j) levels.push(outputEmptyLevel); + levels.push(p); + } + } + if (levels.length > 0) { + while (outputMetaLevels.length < i) outputMetaLevels.push(emptyMetaLevel); + outputMetaLevels.push(levels); + } + } + return outputMetaLevels; +}; + +Gestalt.prototype.transform = function (f) { + return new Gestalt(mapLevels(this.metaLevels, function (p, ml, l) { + return new GestaltLevel(f(p.subscriptions, ml, l, false), + f(p.advertisements, ml, l, true)); + }, function (p) { + return p.isEmpty(); + }, emptyLevel, emptyLevel)); +}; + +Gestalt.prototype.stripLabel = function () { + return this.transform(function (m) { return relabel(m, function (v) { return true; }); }); +}; + +Gestalt.prototype.label = function (pid) { + var pids = arrayToSet([pid]); + return this.transform(function (m) { return relabel(m, function (v) { return pids; }); }); +}; + +Gestalt.prototype.pretty = function () { + var acc = []; + if (this.isEmpty()) { + acc.push("EMPTY GESTALT\n"); + } else { + for (var i = 0; i < this.metaLevels.length; i++) { + var ls = this.metaLevels[i]; + for (var j = 0; j < ls.length; j++) { + var p = ls[j]; + if (!p.isEmpty()) { + acc.push("GESTALT metalevel " + i + " level " + j + ":\n"); + acc.push(p.pretty()); + } + } + } + } + return acc.join(''); +}; + +Gestalt.prototype.serialize = function (serializeSuccess) { + if (typeof serializeSuccess === 'undefined') { + serializeSuccess = function (v) { return v === true ? true : setToArray(v); }; + } + return ["gestalt", mapLevels(this.metaLevels, function (p) { + return [serializeMatcher(p.subscriptions, serializeSuccess), + serializeMatcher(p.advertisements, serializeSuccess)]; + }, function (pr) { + return pr.length === 2 && pr[0].length === 0 && pr[1].length === 0; + }, emptyLevel, [[],[]])]; +}; + +function deserializeGestalt(r, deserializeSuccess) { + if (typeof deserializeSuccess === 'undefined') { + deserializeSuccess = function (v) { return v === true ? true : arrayToSet(v); }; + } + if (r[0] !== "gestalt") die("Invalid gestalt serialization: " + r); + return new Gestalt(mapLevels(r[1], function (pr) { + return new GestaltLevel(deserializeMatcher(pr[0], deserializeSuccess), + deserializeMatcher(pr[1], deserializeSuccess)); + }, function (p) { + return p.isEmpty(); + }, [[],[]], emptyLevel)); +} + +/////////////////////////////////////////////////////////////////////////// + +module.exports.__ = __; +module.exports.arrayToSet = arrayToSet; +module.exports.setToArray = setToArray; +module.exports.setUnion = setUnion; +module.exports.setSubtract = setSubtract; +module.exports.setIntersect = setIntersect; +module.exports.setEqual = setEqual; +module.exports.is_emptySet = is_emptySet; +module.exports.$Capture = $Capture; +module.exports._$ = _$; +module.exports.is_emptyMatcher = is_emptyMatcher; +module.exports.emptyMatcher = emptyMatcher; +module.exports.embeddedMatcher = embeddedMatcher; +module.exports.compilePattern = compilePattern; +module.exports.union = unionN; +module.exports.intersect = intersect; +module.exports.erasePath = erasePath; +module.exports.matchValue = matchValue; +module.exports.matchMatcher = matchMatcher; +module.exports.appendMatcher = appendMatcher; +module.exports.relabel = relabel; +module.exports.compileProjection = compileProjection; +module.exports.projectionToPattern = projectionToPattern; +module.exports.project = project; +module.exports.matcherKeys = matcherKeys; +module.exports.matcherEquals = matcherEquals; +module.exports.prettyMatcher = prettyMatcher; +module.exports.serializeMatcher = serializeMatcher; +module.exports.deserializeMatcher = deserializeMatcher; + +module.exports.GestaltLevel = GestaltLevel; +module.exports.Gestalt = Gestalt; +module.exports.simpleGestalt = simpleGestalt; +module.exports.emptyGestalt = emptyGestalt; +module.exports.fullGestalt = fullGestalt; +module.exports.gestaltUnion = gestaltUnion; +module.exports.deserializeGestalt = deserializeGestalt; diff --git a/routing-table-widget.js b/src/routing-table-widget.js similarity index 74% rename from routing-table-widget.js rename to src/routing-table-widget.js index dc96b1b..814a6f7 100644 --- a/routing-table-widget.js +++ b/src/routing-table-widget.js @@ -1,3 +1,11 @@ +var Minimart = require("./minimart.js"); +var Route = Minimart.Route; +var World = Minimart.World; +var sub = Minimart.sub; +var pub = Minimart.pub; +var __ = Minimart.__; +var _$ = Minimart._$; + function spawnRoutingTableWidget(selector, fragmentClass, observationLevel) { observationLevel = observationLevel || 10; // ^ arbitrary: should be Infinity, when route.js supports it. TODO @@ -5,8 +13,8 @@ function spawnRoutingTableWidget(selector, fragmentClass, observationLevel) { World.spawn({ boot: function () { this.updateState(); }, - state: route.emptyGestalt.serialize(), - nextState: route.emptyGestalt.serialize(), + state: Route.emptyGestalt.serialize(), + nextState: Route.emptyGestalt.serialize(), timer: false, localGestalt: (sub( ["DOM", selector, fragmentClass, __], 0, 2) @@ -18,8 +26,7 @@ function spawnRoutingTableWidget(selector, fragmentClass, observationLevel) { }, updateState: function () { - var elts = ["ul", {"class": "routing-table"}, - ["li", ["pre", route.deserializeGestalt(this.state).pretty()]]]; + var elts = ["pre", Route.deserializeGestalt(this.state).pretty()]; World.updateRoutes([sub(__, 0, observationLevel), pub(__, 0, observationLevel), pub(["DOM", selector, fragmentClass, elts])]); @@ -45,3 +52,5 @@ function spawnRoutingTableWidget(selector, fragmentClass, observationLevel) { }); } + +module.exports.spawnRoutingTableWidget = spawnRoutingTableWidget; diff --git a/spy.js b/src/spy.js similarity index 81% rename from spy.js rename to src/spy.js index 2abb991..42ff83e 100644 --- a/spy.js +++ b/src/spy.js @@ -1,4 +1,10 @@ // Generic Spy +var Minimart = require("./minimart.js"); +var World = Minimart.World; +var sub = Minimart.sub; +var pub = Minimart.pub; +var __ = Minimart.__; +var _$ = Minimart._$; function Spy(label, useJson, observationLevel) { this.label = label || "SPY"; @@ -29,3 +35,5 @@ Spy.prototype.handleEvent = function (e) { break; } }; + +module.exports.Spy = Spy; diff --git a/wake-detector.js b/src/wake-detector.js similarity index 80% rename from wake-detector.js rename to src/wake-detector.js index da11eb7..099b08d 100644 --- a/wake-detector.js +++ b/src/wake-detector.js @@ -2,6 +2,12 @@ // suspension/sleeping!) has caused periodic activities to be // interrupted, and warns others about it // Inspired by http://blog.alexmaccaw.com/javascript-wake-event +var Minimart = require("./minimart.js"); +var World = Minimart.World; +var sub = Minimart.sub; +var pub = Minimart.pub; +var __ = Minimart.__; +var _$ = Minimart._$; function WakeDetector(period) { this.message = "wake"; @@ -25,3 +31,5 @@ WakeDetector.prototype.trigger = function () { } this.mostRecentTrigger = now; }; + +module.exports.WakeDetector = WakeDetector; diff --git a/websocket-driver.js b/src/websocket-driver.js similarity index 83% rename from websocket-driver.js rename to src/websocket-driver.js index 40f7ef3..765c9f4 100644 --- a/websocket-driver.js +++ b/src/websocket-driver.js @@ -1,3 +1,11 @@ +var Minimart = require("./minimart.js"); +var Route = Minimart.Route; +var World = Minimart.World; +var sub = Minimart.sub; +var pub = Minimart.pub; +var __ = Minimart.__; +var _$ = Minimart._$; + /////////////////////////////////////////////////////////////////////////// // WebSocket client driver @@ -15,11 +23,11 @@ function WebSocketConnection(label, wsurl, shouldReconnect) { this.wsurl = wsurl; this.shouldReconnect = shouldReconnect ? true : false; this.reconnectDelay = DEFAULT_RECONNECT_DELAY; - this.localGestalt = route.emptyGestalt; - this.peerGestalt = route.emptyGestalt; + this.localGestalt = Route.emptyGestalt; + this.peerGestalt = Route.emptyGestalt; this.prevLocalRoutesMessage = null; this.prevPeerRoutesMessage = null; - this.deduplicator = new Deduplicator(); + this.deduplicator = new Minimart.Deduplicator(); this.connectionCount = 0; this.activityTimestamp = 0; @@ -58,8 +66,8 @@ WebSocketConnection.prototype.relayGestalt = function () { WebSocketConnection.prototype.aggregateGestalt = function () { var self = this; return this.peerGestalt.transform(function (m, metaLevel) { - return route.compilePattern(true, - [self.label, metaLevel, route.embeddedMatcher(m)]); + return Route.compilePattern(true, + [self.label, metaLevel, Route.embeddedMatcher(m)]); }).union(this.relayGestalt()); }; @@ -88,7 +96,8 @@ WebSocketConnection.prototype.safeSend = function (m) { }; WebSocketConnection.prototype.sendLocalRoutes = function () { - var newLocalRoutesMessage = JSON.stringify(encodeEvent(updateRoutes([this.localGestalt]))); + var newLocalRoutesMessage = + JSON.stringify(encodeEvent(Minimart.updateRoutes([this.localGestalt]))); if (this.prevLocalRoutesMessage !== newLocalRoutesMessage) { this.prevLocalRoutesMessage = newLocalRoutesMessage; this.safeSend(newLocalRoutesMessage); @@ -96,14 +105,14 @@ WebSocketConnection.prototype.sendLocalRoutes = function () { }; WebSocketConnection.prototype.collectMatchers = function (getAdvertisements, level, g) { - var extractMetaLevels = route.compileProjection([this.label, _$, __]); - var mls = route.matcherKeys(g.project(extractMetaLevels, getAdvertisements, 0, level)); + var extractMetaLevels = Route.compileProjection([this.label, _$, __]); + var mls = Route.matcherKeys(g.project(extractMetaLevels, getAdvertisements, 0, level)); for (var i = 0; i < mls.length; i++) { var metaLevel = mls[i][0]; // only one capture in the projection - var extractMatchers = route.compileProjection([this.label, metaLevel, _$]); + var extractMatchers = Route.compileProjection([this.label, metaLevel, _$]); var m = g.project(extractMatchers, getAdvertisements, 0, level); - this.localGestalt = this.localGestalt.union(route.simpleGestalt(getAdvertisements, - route.embeddedMatcher(m), + this.localGestalt = this.localGestalt.union(Route.simpleGestalt(getAdvertisements, + Route.embeddedMatcher(m), metaLevel, level)); } @@ -115,9 +124,9 @@ WebSocketConnection.prototype.handleEvent = function (e) { case "routes": // TODO: GROSS - erasing by pid! var nLevels = e.gestalt.levelCount(0); - var relayGestalt = route.fullGestalt(1, nLevels).label(World.activePid()); + var relayGestalt = Route.fullGestalt(1, nLevels).label(World.activePid()); var g = e.gestalt.erasePath(relayGestalt); - this.localGestalt = route.emptyGestalt; + this.localGestalt = Route.emptyGestalt; for (var level = 0; level < nLevels; level++) { this.collectMatchers(false, level, g); this.collectMatchers(true, level, g); @@ -129,7 +138,8 @@ WebSocketConnection.prototype.handleEvent = function (e) { var m = e.message; if (m.length && m.length === 3 && m[0] === this.label) { - var encoded = JSON.stringify(encodeEvent(sendMessage(m[2], m[1], e.isFeedback))); + var encoded = JSON.stringify(encodeEvent( + Minimart.sendMessage(m[2], m[1], e.isFeedback))); if (this.deduplicator.accept(encoded)) { this.safeSend(encoded); } @@ -232,10 +242,17 @@ function encodeEvent(e) { function decodeAction(j) { switch (j[0]) { case "routes": - return updateRoutes([route.deserializeGestalt(j[1], function (v) { return true; })]); + return Minimart.updateRoutes([ + Route.deserializeGestalt(j[1], function (v) { return true; })]); case "message": - return sendMessage(j[1], j[2], j[3]); + return Minimart.sendMessage(j[1], j[2], j[3]); default: throw { message: "Invalid JSON-encoded action: " + JSON.stringify(j) }; } } + +/////////////////////////////////////////////////////////////////////////// + +module.exports.WebSocketConnection = WebSocketConnection; +module.exports.encodeEvent = encodeEvent; +module.exports.decodeAction = decodeAction; diff --git a/tr.js b/test/tr.js similarity index 100% rename from tr.js rename to test/tr.js